mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Tools disagree on agent frontmatter and some need another format entirely, so an agent written for Claude is misread elsewhere. An `extension` on a target's agents block reuses the extras transform mechanism to convert each agent during sync. Converted targets hold transformed output, so collect never pulls them back into the source. Leftover symlinks from merge or symlink mode are removed rather than written through, and a failed conversion drops the old output so an unconverted agent never stays active. The bundled opencode-agents extension keeps only fields OpenCode documents and refuses agents that restrict their tools, since dropping those fields would widen the agent's access. Refs #267 Refs #241
856 lines
25 KiB
Go
856 lines
25 KiB
Go
package sync
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"skillshare/internal/resource"
|
|
)
|
|
|
|
func TestCheckAgentCollisions_NoCollision(t *testing.T) {
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", RelPath: "tutor.md"},
|
|
{FlatName: "reviewer.md", RelPath: "reviewer.md"},
|
|
}
|
|
collisions := CheckAgentCollisions(agents)
|
|
if len(collisions) != 0 {
|
|
t.Errorf("expected 0 collisions, got %d", len(collisions))
|
|
}
|
|
}
|
|
|
|
func TestCheckAgentCollisions_HasCollision(t *testing.T) {
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "team__helper.md", RelPath: "team/helper.md"},
|
|
{FlatName: "team__helper.md", RelPath: "team__helper.md"},
|
|
}
|
|
collisions := CheckAgentCollisions(agents)
|
|
if len(collisions) != 1 {
|
|
t.Fatalf("expected 1 collision, got %d", len(collisions))
|
|
}
|
|
if collisions[0].FlatName != "team__helper.md" {
|
|
t.Errorf("collision FlatName = %q", collisions[0].FlatName)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgentsToTarget_NewLinks(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
// Create agent source files
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
|
|
os.WriteFile(filepath.Join(sourceDir, "reviewer.md"), []byte("# Reviewer"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
|
|
{FlatName: "reviewer.md", AbsPath: filepath.Join(sourceDir, "reviewer.md")},
|
|
}
|
|
|
|
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgentsToTarget: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 2 {
|
|
t.Errorf("expected 2 linked, got %d", len(result.Linked))
|
|
}
|
|
|
|
// Verify symlinks exist
|
|
for _, name := range []string{"tutor.md", "reviewer.md"} {
|
|
linkPath := filepath.Join(targetDir, name)
|
|
info, err := os.Lstat(linkPath)
|
|
if err != nil {
|
|
t.Errorf("expected symlink %s to exist", name)
|
|
continue
|
|
}
|
|
if info.Mode()&os.ModeSymlink == 0 {
|
|
t.Errorf("expected %s to be a symlink", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSyncAgentsToTarget_ExistingSymlinkCorrect(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
srcFile := filepath.Join(sourceDir, "tutor.md")
|
|
os.WriteFile(srcFile, []byte("# Tutor"), 0644)
|
|
|
|
// Pre-create correct symlink
|
|
os.Symlink(srcFile, filepath.Join(targetDir, "tutor.md"))
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: srcFile},
|
|
}
|
|
|
|
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgentsToTarget: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked (existing correct), got %d", len(result.Linked))
|
|
}
|
|
if len(result.Updated) != 0 {
|
|
t.Errorf("expected 0 updated, got %d", len(result.Updated))
|
|
}
|
|
}
|
|
|
|
func TestSyncAgentsToTarget_LocalFileSkipped(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
srcFile := filepath.Join(sourceDir, "tutor.md")
|
|
os.WriteFile(srcFile, []byte("# Tutor source"), 0644)
|
|
|
|
// Pre-create local file (not a symlink)
|
|
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Local tutor"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: srcFile},
|
|
}
|
|
|
|
result, err := SyncAgentsToTarget(agents, targetDir, false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgentsToTarget: %v", err)
|
|
}
|
|
|
|
if len(result.Skipped) != 1 {
|
|
t.Errorf("expected 1 skipped, got %d", len(result.Skipped))
|
|
}
|
|
}
|
|
|
|
func TestSyncAgentsToTarget_ForceReplacesLocal(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
srcFile := filepath.Join(sourceDir, "tutor.md")
|
|
os.WriteFile(srcFile, []byte("# Tutor source"), 0644)
|
|
|
|
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Local"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: srcFile},
|
|
}
|
|
|
|
result, err := SyncAgentsToTarget(agents, targetDir, false, true)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgentsToTarget: %v", err)
|
|
}
|
|
|
|
if len(result.Updated) != 1 {
|
|
t.Errorf("expected 1 updated, got %d", len(result.Updated))
|
|
}
|
|
|
|
// Should now be a symlink
|
|
info, _ := os.Lstat(filepath.Join(targetDir, "tutor.md"))
|
|
if info.Mode()&os.ModeSymlink == 0 {
|
|
t.Error("expected symlink after force")
|
|
}
|
|
}
|
|
|
|
func TestPruneOrphanAgentLinks(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
// Create source file and active symlink
|
|
srcFile := filepath.Join(sourceDir, "active.md")
|
|
os.WriteFile(srcFile, []byte("# Active"), 0644)
|
|
os.Symlink(srcFile, filepath.Join(targetDir, "active.md"))
|
|
|
|
// Create orphan symlink
|
|
orphanSrc := filepath.Join(sourceDir, "orphan.md")
|
|
os.WriteFile(orphanSrc, []byte("# Orphan"), 0644)
|
|
os.Symlink(orphanSrc, filepath.Join(targetDir, "orphan.md"))
|
|
|
|
// Create non-symlink file (should not be removed)
|
|
os.WriteFile(filepath.Join(targetDir, "local.md"), []byte("# Local"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "active.md"},
|
|
}
|
|
|
|
removed, err := PruneOrphanAgentLinks(targetDir, agents, false)
|
|
if err != nil {
|
|
t.Fatalf("PruneOrphanAgentLinks: %v", err)
|
|
}
|
|
|
|
if len(removed) != 1 {
|
|
t.Fatalf("expected 1 removed, got %d: %v", len(removed), removed)
|
|
}
|
|
if removed[0] != "orphan.md" {
|
|
t.Errorf("expected orphan.md removed, got %q", removed[0])
|
|
}
|
|
|
|
// local.md should still exist
|
|
if _, err := os.Stat(filepath.Join(targetDir, "local.md")); err != nil {
|
|
t.Error("local.md should not be removed")
|
|
}
|
|
}
|
|
|
|
func TestPruneOrphanAgentLinks_NonExistentDir(t *testing.T) {
|
|
removed, err := PruneOrphanAgentLinks("/nonexistent/path", nil, false)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(removed) != 0 {
|
|
t.Errorf("expected 0 removed, got %d", len(removed))
|
|
}
|
|
}
|
|
|
|
func TestFindLocalAgentsAndPullAgents(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
sourceDir := t.TempDir()
|
|
|
|
// Create a local (non-symlink) agent file in target
|
|
os.WriteFile(filepath.Join(targetDir, "new-agent.md"), []byte("# New agent"), 0644)
|
|
|
|
// Create a symlink (should be skipped)
|
|
srcFile := filepath.Join(sourceDir, "existing.md")
|
|
os.WriteFile(srcFile, []byte("# Existing"), 0644)
|
|
os.Symlink(srcFile, filepath.Join(targetDir, "existing.md"))
|
|
|
|
// Create README (should be skipped)
|
|
os.WriteFile(filepath.Join(targetDir, "README.md"), []byte("# Readme"), 0644)
|
|
|
|
// Create non-md file (should be skipped)
|
|
os.WriteFile(filepath.Join(targetDir, "config.yaml"), []byte("key: val"), 0644)
|
|
|
|
collectDir := t.TempDir()
|
|
agents, err := FindLocalAgents(targetDir, collectDir)
|
|
if err != nil {
|
|
t.Fatalf("FindLocalAgents: %v", err)
|
|
}
|
|
|
|
if len(agents) != 1 {
|
|
t.Fatalf("expected 1 local agent, got %d: %v", len(agents), agents)
|
|
}
|
|
if agents[0].Name != "new-agent.md" {
|
|
t.Errorf("agent name = %q, want %q", agents[0].Name, "new-agent.md")
|
|
}
|
|
|
|
result, err := PullAgents(agents, collectDir, PullOptions{})
|
|
if err != nil {
|
|
t.Fatalf("PullAgents: %v", err)
|
|
}
|
|
if len(result.Pulled) != 1 || result.Pulled[0] != "new-agent.md" {
|
|
t.Fatalf("expected pulled=[new-agent.md], got %#v", result)
|
|
}
|
|
|
|
// Verify file was copied
|
|
data, err := os.ReadFile(filepath.Join(collectDir, "new-agent.md"))
|
|
if err != nil {
|
|
t.Fatalf("collected file not found: %v", err)
|
|
}
|
|
if string(data) != "# New agent" {
|
|
t.Errorf("collected content = %q", string(data))
|
|
}
|
|
}
|
|
|
|
func TestFindLocalAgents_TargetSymlinkToSource_ReturnsEmpty(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetParent := t.TempDir()
|
|
targetDir := filepath.Join(targetParent, "agents")
|
|
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
|
|
os.Symlink(sourceDir, targetDir)
|
|
|
|
agents, err := FindLocalAgents(targetDir, sourceDir)
|
|
if err != nil {
|
|
t.Fatalf("FindLocalAgents: %v", err)
|
|
}
|
|
if len(agents) != 0 {
|
|
t.Fatalf("expected 0 local agents, got %d", len(agents))
|
|
}
|
|
}
|
|
|
|
func TestPullAgents_SkipsExistingWithoutForce(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
collectDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Target"), 0644)
|
|
os.WriteFile(filepath.Join(collectDir, "agent.md"), []byte("# Source"), 0644)
|
|
|
|
agents, err := FindLocalAgents(targetDir, collectDir)
|
|
if err != nil {
|
|
t.Fatalf("FindLocalAgents: %v", err)
|
|
}
|
|
|
|
result, err := PullAgents(agents, collectDir, PullOptions{})
|
|
if err != nil {
|
|
t.Fatalf("PullAgents: %v", err)
|
|
}
|
|
if len(result.Skipped) != 1 || result.Skipped[0] != "agent.md" {
|
|
t.Fatalf("expected skipped=[agent.md], got %#v", result)
|
|
}
|
|
|
|
data, err := os.ReadFile(filepath.Join(collectDir, "agent.md"))
|
|
if err != nil {
|
|
t.Fatalf("read source agent: %v", err)
|
|
}
|
|
if string(data) != "# Source" {
|
|
t.Fatalf("source agent should remain unchanged, got %q", string(data))
|
|
}
|
|
}
|
|
|
|
func TestPullAgents_ForceOverwritesExisting(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
collectDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Target"), 0644)
|
|
os.WriteFile(filepath.Join(collectDir, "agent.md"), []byte("# Source"), 0644)
|
|
|
|
agents, err := FindLocalAgents(targetDir, collectDir)
|
|
if err != nil {
|
|
t.Fatalf("FindLocalAgents: %v", err)
|
|
}
|
|
|
|
result, err := PullAgents(agents, collectDir, PullOptions{Force: true})
|
|
if err != nil {
|
|
t.Fatalf("PullAgents: %v", err)
|
|
}
|
|
if len(result.Pulled) != 1 || result.Pulled[0] != "agent.md" {
|
|
t.Fatalf("expected pulled=[agent.md], got %#v", result)
|
|
}
|
|
|
|
data, err := os.ReadFile(filepath.Join(collectDir, "agent.md"))
|
|
if err != nil {
|
|
t.Fatalf("read source agent: %v", err)
|
|
}
|
|
if string(data) != "# Target" {
|
|
t.Fatalf("source agent should be overwritten, got %q", string(data))
|
|
}
|
|
}
|
|
|
|
// --- Symlink mode tests ---
|
|
|
|
func TestSyncAgents_SymlinkMode_NewDir(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
|
|
|
|
targetDir := filepath.Join(t.TempDir(), "agents")
|
|
|
|
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents symlink: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked, got %d", len(result.Linked))
|
|
}
|
|
|
|
// targetDir should be a symlink to sourceDir
|
|
info, err := os.Lstat(targetDir)
|
|
if err != nil {
|
|
t.Fatalf("Lstat: %v", err)
|
|
}
|
|
if info.Mode()&os.ModeSymlink == 0 {
|
|
t.Error("expected targetDir to be a symlink")
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_SymlinkMode_AlreadyCorrect(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
parentDir := t.TempDir()
|
|
targetDir := filepath.Join(parentDir, "agents")
|
|
|
|
os.Symlink(sourceDir, targetDir)
|
|
|
|
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents symlink: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked (already correct), got %d", len(result.Linked))
|
|
}
|
|
if len(result.Updated) != 0 {
|
|
t.Errorf("expected 0 updated, got %d", len(result.Updated))
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_SymlinkMode_RealDirSkipped(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir() // real directory
|
|
|
|
result, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents symlink: %v", err)
|
|
}
|
|
|
|
if len(result.Skipped) != 1 {
|
|
t.Errorf("expected 1 skipped, got %d", len(result.Skipped))
|
|
}
|
|
}
|
|
|
|
// --- Copy mode tests ---
|
|
|
|
func TestSyncAgents_CopyMode_NewFiles(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Tutor"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
|
|
}
|
|
|
|
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents copy: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked (new copy), got %d", len(result.Linked))
|
|
}
|
|
|
|
// Verify it's a real file, not a symlink
|
|
info, _ := os.Lstat(filepath.Join(targetDir, "tutor.md"))
|
|
if info.Mode()&os.ModeSymlink != 0 {
|
|
t.Error("copy mode should create real files, not symlinks")
|
|
}
|
|
|
|
data, _ := os.ReadFile(filepath.Join(targetDir, "tutor.md"))
|
|
if string(data) != "# Tutor" {
|
|
t.Errorf("content = %q", string(data))
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_CopyMode_SameContent(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# Same"), 0644)
|
|
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Same"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
|
|
}
|
|
|
|
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents copy: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked (same content), got %d", len(result.Linked))
|
|
}
|
|
if len(result.Updated) != 0 {
|
|
t.Errorf("expected 0 updated, got %d", len(result.Updated))
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_CopyMode_DifferentContent(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(sourceDir, "tutor.md"), []byte("# New"), 0644)
|
|
os.WriteFile(filepath.Join(targetDir, "tutor.md"), []byte("# Old"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "tutor.md", AbsPath: filepath.Join(sourceDir, "tutor.md")},
|
|
}
|
|
|
|
result, err := SyncAgents(agents, sourceDir, targetDir, "copy", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents copy: %v", err)
|
|
}
|
|
|
|
if len(result.Updated) != 1 {
|
|
t.Errorf("expected 1 updated, got %d", len(result.Updated))
|
|
}
|
|
|
|
data, _ := os.ReadFile(filepath.Join(targetDir, "tutor.md"))
|
|
if string(data) != "# New" {
|
|
t.Errorf("content = %q, want %q", string(data), "# New")
|
|
}
|
|
}
|
|
|
|
func TestPruneOrphanAgentCopies(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(targetDir, "active.md"), []byte("# Active"), 0644)
|
|
os.WriteFile(filepath.Join(targetDir, "orphan.md"), []byte("# Orphan"), 0644)
|
|
os.WriteFile(filepath.Join(targetDir, "README.md"), []byte("# Readme"), 0644) // conventional, skip
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "active.md"},
|
|
}
|
|
|
|
removed, err := PruneOrphanAgentCopies(targetDir, agents, "", false)
|
|
if err != nil {
|
|
t.Fatalf("PruneOrphanAgentCopies: %v", err)
|
|
}
|
|
|
|
if len(removed) != 1 || removed[0] != "orphan.md" {
|
|
t.Errorf("expected [orphan.md] removed, got %v", removed)
|
|
}
|
|
|
|
// README.md should still exist
|
|
if _, err := os.Stat(filepath.Join(targetDir, "README.md")); err != nil {
|
|
t.Error("README.md should not be removed")
|
|
}
|
|
}
|
|
|
|
// --- Dispatch tests ---
|
|
|
|
func TestSyncAgents_DefaultIsMerge(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
os.WriteFile(filepath.Join(sourceDir, "a.md"), []byte("# A"), 0644)
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "a.md", AbsPath: filepath.Join(sourceDir, "a.md")},
|
|
}
|
|
|
|
result, err := SyncAgents(agents, sourceDir, targetDir, "", false, false)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents default: %v", err)
|
|
}
|
|
|
|
if len(result.Linked) != 1 {
|
|
t.Errorf("expected 1 linked, got %d", len(result.Linked))
|
|
}
|
|
|
|
// Should be a symlink (merge mode)
|
|
info, _ := os.Lstat(filepath.Join(targetDir, "a.md"))
|
|
if info.Mode()&os.ModeSymlink == 0 {
|
|
t.Error("default mode should create symlinks (merge)")
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeMode_NestedSameBasename_IsStable(t *testing.T) {
|
|
sourceDir := t.TempDir()
|
|
targetDir := t.TempDir()
|
|
|
|
if err := os.MkdirAll(filepath.Join(sourceDir, "team-a"), 0o755); err != nil {
|
|
t.Fatalf("mkdir team-a: %v", err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(sourceDir, "team-b"), 0o755); err != nil {
|
|
t.Fatalf("mkdir team-b: %v", err)
|
|
}
|
|
|
|
teamAPath := filepath.Join(sourceDir, "team-a", "helper.md")
|
|
teamBPath := filepath.Join(sourceDir, "team-b", "helper.md")
|
|
if err := os.WriteFile(teamAPath, []byte("# Team A"), 0o644); err != nil {
|
|
t.Fatalf("write team-a helper: %v", err)
|
|
}
|
|
if err := os.WriteFile(teamBPath, []byte("# Team B"), 0o644); err != nil {
|
|
t.Fatalf("write team-b helper: %v", err)
|
|
}
|
|
|
|
agents, err := resource.AgentKind{}.Discover(sourceDir)
|
|
if err != nil {
|
|
t.Fatalf("discover agents: %v", err)
|
|
}
|
|
if len(agents) != 2 {
|
|
t.Fatalf("expected 2 agents, got %d", len(agents))
|
|
}
|
|
|
|
first, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatalf("first sync: %v", err)
|
|
}
|
|
if len(first.Linked) != 2 {
|
|
t.Fatalf("first sync: expected 2 linked, got %d", len(first.Linked))
|
|
}
|
|
if len(first.Updated) != 0 {
|
|
t.Fatalf("first sync: expected 0 updated, got %d", len(first.Updated))
|
|
}
|
|
|
|
second, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false)
|
|
if err != nil {
|
|
t.Fatalf("second sync: %v", err)
|
|
}
|
|
if len(second.Linked) != 2 {
|
|
t.Fatalf("second sync: expected 2 linked, got %d", len(second.Linked))
|
|
}
|
|
if len(second.Updated) != 0 {
|
|
t.Fatalf("second sync: expected 0 updated, got %d", len(second.Updated))
|
|
}
|
|
|
|
linkA, err := os.Readlink(filepath.Join(targetDir, "team-a__helper.md"))
|
|
if err != nil {
|
|
t.Fatalf("readlink team-a target: %v", err)
|
|
}
|
|
// EvalSymlinks to handle macOS /var → /private/var alias.
|
|
wantA, _ := filepath.EvalSymlinks(teamAPath)
|
|
gotA, _ := filepath.EvalSymlinks(linkA)
|
|
if gotA != wantA {
|
|
t.Fatalf("team-a symlink = %q, want %q", linkA, teamAPath)
|
|
}
|
|
|
|
linkB, err := os.Readlink(filepath.Join(targetDir, "team-b__helper.md"))
|
|
if err != nil {
|
|
t.Fatalf("readlink team-b target: %v", err)
|
|
}
|
|
wantB, _ := filepath.EvalSymlinks(teamBPath)
|
|
gotB, _ := filepath.EvalSymlinks(linkB)
|
|
if gotB != wantB {
|
|
t.Fatalf("team-b symlink = %q, want %q", linkB, teamBPath)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeMode_ProjectUsesRelativeSymlink(t *testing.T) {
|
|
projectRoot := t.TempDir()
|
|
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
|
|
targetDir := filepath.Join(projectRoot, ".claude", "agents")
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
srcFile := filepath.Join(sourceDir, "reviewer.md")
|
|
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "reviewer.md", AbsPath: srcFile},
|
|
}
|
|
|
|
if _, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot); err != nil {
|
|
t.Fatalf("SyncAgents merge: %v", err)
|
|
}
|
|
|
|
link, err := os.Readlink(filepath.Join(targetDir, "reviewer.md"))
|
|
if err != nil {
|
|
t.Fatalf("readlink: %v", err)
|
|
}
|
|
if filepath.IsAbs(link) {
|
|
t.Fatalf("expected project agent symlink to be relative, got %q", link)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_SymlinkMode_ProjectUsesRelativeSymlink(t *testing.T) {
|
|
projectRoot := t.TempDir()
|
|
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
|
|
targetDir := filepath.Join(projectRoot, ".claude", "agents")
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(sourceDir, "reviewer.md"), []byte("# Reviewer"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := SyncAgents(nil, sourceDir, targetDir, "symlink", false, false, projectRoot); err != nil {
|
|
t.Fatalf("SyncAgents symlink: %v", err)
|
|
}
|
|
|
|
link, err := os.Readlink(targetDir)
|
|
if err != nil {
|
|
t.Fatalf("readlink: %v", err)
|
|
}
|
|
if filepath.IsAbs(link) {
|
|
t.Fatalf("expected project agent directory symlink to be relative, got %q", link)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgents_MergeMode_ReformatsProjectAgentSymlink(t *testing.T) {
|
|
projectRoot := t.TempDir()
|
|
sourceDir := filepath.Join(projectRoot, ".skillshare", "agents")
|
|
targetDir := filepath.Join(projectRoot, ".claude", "agents")
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.MkdirAll(targetDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
srcFile := filepath.Join(sourceDir, "reviewer.md")
|
|
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
linkPath := filepath.Join(targetDir, "reviewer.md")
|
|
if err := os.Symlink(srcFile, linkPath); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "reviewer.md", AbsPath: srcFile},
|
|
}
|
|
|
|
result, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
|
|
if err != nil {
|
|
t.Fatalf("SyncAgents merge: %v", err)
|
|
}
|
|
if len(result.Updated) != 1 {
|
|
t.Fatalf("expected reformat to count as updated, got %#v", result)
|
|
}
|
|
|
|
link, err := os.Readlink(linkPath)
|
|
if err != nil {
|
|
t.Fatalf("readlink: %v", err)
|
|
}
|
|
if filepath.IsAbs(link) {
|
|
t.Fatalf("expected reformatted project agent symlink to be relative, got %q", link)
|
|
}
|
|
}
|
|
|
|
// TestSyncAgents_MergeMode_StableWhenSourceResolvesThroughSymlink reproduces the
|
|
// macOS /var → /private/var case on any platform: the project paths are expressed
|
|
// through a symlinked ancestor, while discovery records the agent's real
|
|
// (EvalSymlinks'd) AbsPath. A stable relative link must not be re-counted as
|
|
// "updated" on the second sync. Regression test for the agent-sync idempotency
|
|
// failure on macOS CI.
|
|
func TestSyncAgents_MergeMode_StableWhenSourceResolvesThroughSymlink(t *testing.T) {
|
|
base := t.TempDir()
|
|
real := filepath.Join(base, "real")
|
|
if err := os.MkdirAll(real, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
alias := filepath.Join(base, "alias")
|
|
if err := os.Symlink(real, alias); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
projectRoot := alias
|
|
sourceDir := filepath.Join(alias, ".skillshare", "agents")
|
|
targetDir := filepath.Join(alias, ".claude", "agents")
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
srcFile := filepath.Join(sourceDir, "reviewer.md")
|
|
if err := os.WriteFile(srcFile, []byte("# Reviewer"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// AbsPath mirrors real discovery, which resolves symlinked ancestors.
|
|
realSrc, err := filepath.EvalSymlinks(srcFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
agents := []resource.DiscoveredResource{
|
|
{FlatName: "reviewer.md", AbsPath: realSrc},
|
|
}
|
|
|
|
first, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
|
|
if err != nil {
|
|
t.Fatalf("first sync: %v", err)
|
|
}
|
|
if len(first.Updated) != 0 {
|
|
t.Fatalf("first sync should not update, got %#v", first)
|
|
}
|
|
|
|
second, err := SyncAgents(agents, sourceDir, targetDir, "merge", false, false, projectRoot)
|
|
if err != nil {
|
|
t.Fatalf("second sync: %v", err)
|
|
}
|
|
if len(second.Updated) != 0 {
|
|
t.Fatalf("second sync should be stable (0 updated), got %#v", second)
|
|
}
|
|
if len(second.Linked) != 1 {
|
|
t.Fatalf("second sync should re-link existing agent, got %#v", second)
|
|
}
|
|
}
|
|
|
|
func TestPullAgents_DryRun(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
os.WriteFile(filepath.Join(targetDir, "agent.md"), []byte("# Agent"), 0644)
|
|
|
|
collectDir := t.TempDir()
|
|
agents, err := FindLocalAgents(targetDir, collectDir)
|
|
if err != nil {
|
|
t.Fatalf("FindLocalAgents: %v", err)
|
|
}
|
|
|
|
result, err := PullAgents(agents, collectDir, PullOptions{DryRun: true})
|
|
if err != nil {
|
|
t.Fatalf("PullAgents dry-run: %v", err)
|
|
}
|
|
|
|
if len(result.Pulled) != 1 {
|
|
t.Fatalf("expected 1 collected in dry-run, got %d", len(result.Pulled))
|
|
}
|
|
|
|
// File should NOT exist (dry-run)
|
|
if _, err := os.Stat(filepath.Join(collectDir, "agent.md")); err == nil {
|
|
t.Error("file should not exist in dry-run")
|
|
}
|
|
}
|
|
|
|
// agentTransformFixture creates source agent tutor.md and returns it with an
|
|
// uppercasing spec, so any write-through to the source is visible.
|
|
func agentTransformFixture(t *testing.T) (string, []resource.DiscoveredResource, *ExtensionSpec) {
|
|
t.Helper()
|
|
sourceDir := t.TempDir()
|
|
src := filepath.Join(sourceDir, "tutor.md")
|
|
if err := os.WriteFile(src, []byte("body"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
agents := []resource.DiscoveredResource{{FlatName: "tutor.md", RelPath: "tutor.md", AbsPath: src}}
|
|
spec := &ExtensionSpec{Run: []string{"tr", "a-z", "A-Z"}, Dir: sourceDir, Name: "upper"}
|
|
return sourceDir, agents, spec
|
|
}
|
|
|
|
func assertSourceUntouched(t *testing.T, sourceDir string) {
|
|
t.Helper()
|
|
data, err := os.ReadFile(filepath.Join(sourceDir, "tutor.md"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(data) != "body" {
|
|
t.Errorf("source agent overwritten: %q", data)
|
|
}
|
|
}
|
|
|
|
func TestSyncAgentsTransform_ReplacesLeftoverFileSymlink(t *testing.T) {
|
|
sourceDir, agents, spec := agentTransformFixture(t)
|
|
targetDir := t.TempDir()
|
|
// Left over from merge mode.
|
|
if err := os.Symlink(agents[0].AbsPath, filepath.Join(targetDir, "tutor.md")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertSourceUntouched(t, sourceDir)
|
|
}
|
|
|
|
func TestSyncAgentsTransform_ReplacesLeftoverDirSymlink(t *testing.T) {
|
|
sourceDir, agents, spec := agentTransformFixture(t)
|
|
targetDir := filepath.Join(t.TempDir(), "agents")
|
|
// Left over from symlink mode.
|
|
if err := os.Symlink(sourceDir, targetDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", spec, false, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertSourceUntouched(t, sourceDir)
|
|
}
|
|
|
|
func TestSyncAgentsTransform_FailureRemovesStaleOutput(t *testing.T) {
|
|
sourceDir, agents, _ := agentTransformFixture(t)
|
|
targetDir := t.TempDir()
|
|
stale := filepath.Join(targetDir, "tutor.md")
|
|
if err := os.WriteFile(stale, []byte("unconverted"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
failing := &ExtensionSpec{Run: []string{"false"}, Dir: sourceDir, Name: "fail"}
|
|
|
|
if _, err := SyncAgentsTransform(agents, sourceDir, targetDir, "", failing, false, false); err == nil {
|
|
t.Fatal("expected conversion error")
|
|
}
|
|
if _, err := os.Lstat(stale); !os.IsNotExist(err) {
|
|
t.Error("an agent that fails to convert must not keep its old output")
|
|
}
|
|
}
|
|
|
|
func TestPruneOrphanAgentCopies_PrunesTransformedOrphans(t *testing.T) {
|
|
targetDir := t.TempDir()
|
|
orphan := filepath.Join(targetDir, "gone.toml")
|
|
if err := os.WriteFile(orphan, []byte("x"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, err := PruneOrphanAgentCopies(targetDir, nil, "toml", false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(orphan); !os.IsNotExist(err) {
|
|
t.Error("orphan gone.toml should be pruned")
|
|
}
|
|
}
|