//go:build !online package integration import ( "encoding/json" "os" "path/filepath" "strings" "testing" "skillshare/internal/testutil" ) func TestSyncExtras_MergeMode(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create a skill so config.Load() has a valid source sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create extras source: rules directory with 2 .md files sourceRoot := filepath.Dir(sb.SourcePath) // ~/.config/skillshare/ rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding Rules"), 0644) os.WriteFile(filepath.Join(rulesSource, "testing.md"), []byte("# Testing Rules"), 0644) // Create extras target directory rulesTarget := filepath.Join(sb.Home, ".claude", "rules") os.MkdirAll(rulesTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "Syncing extras") result.AssertAnyOutputContains(t, "2 files") // Verify files are symlinks codingLink := filepath.Join(rulesTarget, "coding.md") if !sb.IsSymlink(codingLink) { t.Error("coding.md should be a symlink in merge mode") } testingLink := filepath.Join(rulesTarget, "testing.md") if !sb.IsSymlink(testingLink) { t.Error("testing.md should be a symlink in merge mode") } // Verify symlink targets point to the source files expectedCoding := filepath.Join(rulesSource, "coding.md") if got := sb.SymlinkTarget(codingLink); got != expectedCoding { t.Errorf("coding.md symlink target = %q, want %q", got, expectedCoding) } } func TestSyncExtras_CopyMode(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create extras source sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding Rules"), 0644) // Create extras target rulesTarget := filepath.Join(sb.Home, ".cursor", "rules") os.MkdirAll(rulesTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` mode: copy `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "Syncing extras") // Verify file exists and is a real copy (not a symlink) copiedFile := filepath.Join(rulesTarget, "coding.md") if !sb.FileExists(copiedFile) { t.Fatal("coding.md should exist in target") } if sb.IsSymlink(copiedFile) { t.Error("coding.md should be a real copy, not a symlink, in copy mode") } // Verify content matches content := sb.ReadFile(copiedFile) if content != "# Coding Rules" { t.Errorf("copied file content = %q, want %q", content, "# Coding Rules") } } func TestSyncExtras_NoExtrasConfigured(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Config with no extras section sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "No extras configured") } func TestSyncExtras_AfterFlags(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + sb.CreateTarget("claude") + ` `) result := sb.RunCLI("sync", "-g", "--dry-run", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "No extras configured") result.AssertOutputNotContains(t, "Syncing skills") } func TestSyncExtras_PrunesOrphans(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create extras source with 1 file sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "keep.md"), []byte("# Keep"), 0644) // Create extras target with an orphan symlink pointing to non-existent source rulesTarget := filepath.Join(sb.Home, ".claude", "rules") os.MkdirAll(rulesTarget, 0755) orphanSource := filepath.Join(rulesSource, "deleted.md") orphanLink := filepath.Join(rulesTarget, "deleted.md") os.Symlink(orphanSource, orphanLink) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) // Verify orphan is removed if sb.FileExists(orphanLink) { t.Error("orphan symlink should have been pruned") } // Verify real file is synced keepLink := filepath.Join(rulesTarget, "keep.md") if !sb.IsSymlink(keepLink) { t.Error("keep.md should be synced as a symlink") } } func TestSync_AllFlag(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Setup skills sb.CreateSkill("my-skill", map[string]string{ "SKILL.md": "# My Skill\n\nDescription here.", }) targetPath := sb.CreateTarget("claude") // Setup extras sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) rulesTarget := filepath.Join(sb.Home, ".claude", "rules") os.MkdirAll(rulesTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` `) result := sb.RunCLI("sync", "--all") result.AssertSuccess(t) // Verify skill sync happened result.AssertAnyOutputContains(t, "merged") // Verify extras sync happened result.AssertAnyOutputContains(t, "Syncing extras") // Verify skill symlink if !sb.IsSymlink(filepath.Join(targetPath, "my-skill")) { t.Error("skill should be synced to target") } // Verify extras symlink if !sb.IsSymlink(filepath.Join(rulesTarget, "coding.md")) { t.Error("extras rule should be synced to target") } } // TestSyncExtras_ModeSwitchMergeToCopy verifies that switching mode from merge // to copy and re-syncing replaces symlinks with copies without needing --force. func TestSyncExtras_ModeSwitchMergeToCopy(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create extras source sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding Rules"), 0644) rulesTarget := filepath.Join(sb.Home, ".claude", "rules") os.MkdirAll(rulesTarget, 0755) // Step 1: Sync with merge mode (creates symlinks) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) codingFile := filepath.Join(rulesTarget, "coding.md") if !sb.IsSymlink(codingFile) { t.Fatal("coding.md should be a symlink after merge sync") } // Step 2: Change mode to copy and re-sync sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` mode: copy `) result = sb.RunCLI("sync", "extras") result.AssertSuccess(t) // Verify: file should now be a regular copy, not a symlink if sb.IsSymlink(codingFile) { t.Error("coding.md should be a regular file after switching to copy mode, but is still a symlink") } if !sb.FileExists(codingFile) { t.Fatal("coding.md should exist in target after copy sync") } content := sb.ReadFile(codingFile) if content != "# Coding Rules" { t.Errorf("copied file content = %q, want %q", content, "# Coding Rules") } } // TestSyncExtras_ModeSwitchCopyToMerge verifies that switching mode from copy // to merge and re-syncing replaces copies with symlinks (requires --force since // regular files are not auto-replaced). func TestSyncExtras_ModeSwitchCopyToMerge(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create extras source sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding Rules"), 0644) rulesTarget := filepath.Join(sb.Home, ".claude", "rules") os.MkdirAll(rulesTarget, 0755) // Step 1: Sync with copy mode sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` mode: copy `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) codingFile := filepath.Join(rulesTarget, "coding.md") if sb.IsSymlink(codingFile) { t.Fatal("coding.md should be a regular file after copy sync") } // Step 2: Change mode to merge and sync WITHOUT --force (should skip) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + rulesTarget + ` `) result = sb.RunCLI("sync", "extras") result.AssertSuccess(t) // File should still be a regular file (skipped because no --force) if sb.IsSymlink(codingFile) { t.Error("coding.md should still be a regular file without --force") } // Step 3: Sync WITH --force (should replace with symlink) result = sb.RunCLI("sync", "extras", "--force") result.AssertSuccess(t) if !sb.IsSymlink(codingFile) { t.Error("coding.md should be a symlink after --force sync with merge mode") } expectedTarget := filepath.Join(rulesSource, "coding.md") if got := sb.SymlinkTarget(codingFile); got != expectedTarget { t.Errorf("symlink target = %q, want %q", got, expectedTarget) } } func TestSyncExtras_SourceNotExist(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Config with extras pointing to non-existent source directory // The source name "nonexistent" resolves to ~/.config/skillshare/nonexistent sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: nonexistent targets: - path: ` + filepath.Join(sb.Home, ".claude", "rules") + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) // A missing source skips the extra with a hint instead of creating it result.AssertAnyOutputContains(t, "Source directory does not exist") result.AssertAnyOutputContains(t, "Create it to start syncing nonexistent") } func TestSyncExtras_FlattenMerge(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") sourceRoot := filepath.Dir(sb.SourcePath) agentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(filepath.Join(agentsSource, "curriculum"), 0755) os.MkdirAll(filepath.Join(agentsSource, "software"), 0755) os.WriteFile(filepath.Join(agentsSource, "curriculum", "tactician.md"), []byte("# Tactician"), 0644) os.WriteFile(filepath.Join(agentsSource, "software", "implementer.md"), []byte("# Implementer"), 0644) os.WriteFile(filepath.Join(agentsSource, "reviewer.md"), []byte("# Reviewer"), 0644) agentsTarget := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(agentsTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: agents targets: - path: ` + agentsTarget + ` flatten: true `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "3 files") for _, name := range []string{"tactician.md", "implementer.md", "reviewer.md"} { if !sb.IsSymlink(filepath.Join(agentsTarget, name)) { t.Errorf("%s should be a flat symlink in target", name) } } if _, err := os.Stat(filepath.Join(agentsTarget, "curriculum")); !os.IsNotExist(err) { t.Error("curriculum/ should not exist in target") } } func TestSyncExtras_FlattenCollision(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") sourceRoot := filepath.Dir(sb.SourcePath) agentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(filepath.Join(agentsSource, "team-a"), 0755) os.MkdirAll(filepath.Join(agentsSource, "team-b"), 0755) os.WriteFile(filepath.Join(agentsSource, "team-a", "agent.md"), []byte("# Team A"), 0644) os.WriteFile(filepath.Join(agentsSource, "team-b", "agent.md"), []byte("# Team B"), 0644) agentsTarget := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(agentsTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: agents targets: - path: ` + agentsTarget + ` flatten: true `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "flatten conflict") if !sb.IsSymlink(filepath.Join(agentsTarget, "agent.md")) { t.Error("agent.md should be a symlink") } } func TestSyncExtras_FlattenConfigRoundTrip(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") agentsTarget := filepath.Join(sb.Home, ".claude", "agents") sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: agents targets: - path: ` + agentsTarget + ` flatten: true `) content := sb.ReadFile(sb.ConfigPath) if !strings.Contains(content, "flatten: true") { t.Error("config should contain flatten: true") } } // --- Extras "agents" overlap with agents sync --- func TestSyncExtras_AgentsOverlap_Skipped(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create agents source with a real agent (the regular agents sync system) agentsDir := filepath.Join(filepath.Dir(sb.SourcePath), "agents") os.MkdirAll(agentsDir, 0755) os.WriteFile(filepath.Join(agentsDir, "helper.md"), []byte("# Helper Agent"), 0644) // Create extras source for "agents" with a file sourceRoot := filepath.Dir(sb.SourcePath) extrasAgentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(extrasAgentsSource, 0755) os.WriteFile(filepath.Join(extrasAgentsSource, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(claudeAgents, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: skills: path: ` + targetPath + ` agents: path: ` + claudeAgents + ` extras: - name: agents targets: - path: ` + claudeAgents + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "Skipping extras") result.AssertAnyOutputContains(t, "already managed by agents sync") } func TestSyncExtras_AgentsOverlap_NoAgentsSource(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // NO agents source directory — extras "agents" should sync normally sourceRoot := filepath.Dir(sb.SourcePath) extrasAgentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(extrasAgentsSource, 0755) os.WriteFile(filepath.Join(extrasAgentsSource, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(claudeAgents, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: skills: path: ` + targetPath + ` agents: path: ` + claudeAgents + ` extras: - name: agents targets: - path: ` + claudeAgents + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertOutputNotContains(t, "Skipping extras") // Extras agent file should be synced normally if !sb.FileExists(filepath.Join(claudeAgents, "extra-agent.md")) { t.Error("extra-agent.md should be synced when no agents source exists") } } func TestSyncExtras_AgentsOverlap_PartialSkip(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create agents source agentsDir := filepath.Join(filepath.Dir(sb.SourcePath), "agents") os.MkdirAll(agentsDir, 0755) os.WriteFile(filepath.Join(agentsDir, "helper.md"), []byte("# Helper Agent"), 0644) // Create extras "agents" source sourceRoot := filepath.Dir(sb.SourcePath) extrasAgentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(extrasAgentsSource, 0755) os.WriteFile(filepath.Join(extrasAgentsSource, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") customTarget := filepath.Join(sb.Home, "custom-agents") os.MkdirAll(claudeAgents, 0755) os.MkdirAll(customTarget, 0755) // Two targets: one overlaps with agents, one doesn't sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: skills: path: ` + targetPath + ` agents: path: ` + claudeAgents + ` extras: - name: agents targets: - path: ` + claudeAgents + ` - path: ` + customTarget + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) // Overlapping target should be skipped result.AssertAnyOutputContains(t, "Skipping extras") // Non-overlapping target should be synced if !sb.FileExists(filepath.Join(customTarget, "extra-agent.md")) { t.Error("extra-agent.md should be synced to non-overlapping target") } } func TestSyncExtras_AgentsOverlap_NonAgentsNameNotSkipped(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create agents source (real agents system active) agentsDir := filepath.Join(filepath.Dir(sb.SourcePath), "agents") os.MkdirAll(agentsDir, 0755) os.WriteFile(filepath.Join(agentsDir, "helper.md"), []byte("# Helper Agent"), 0644) // Create extras "rules" that targets the agents directory sourceRoot := filepath.Dir(sb.SourcePath) rulesSource := filepath.Join(sourceRoot, "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "rule.md"), []byte("# Rule"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(claudeAgents, 0755) // extras "rules" targets the same path as agents — should NOT be skipped (name != "agents") sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: skills: path: ` + targetPath + ` agents: path: ` + claudeAgents + ` extras: - name: rules targets: - path: ` + claudeAgents + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertOutputNotContains(t, "Skipping extras") if !sb.FileExists(filepath.Join(claudeAgents, "rule.md")) { t.Error("rule.md should be synced — extras named 'rules' should not be affected by agents overlap") } } func TestSyncExtras_AgentsOverlap_NoTargetOverlap(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") // Create agents source agentsDir := filepath.Join(filepath.Dir(sb.SourcePath), "agents") os.MkdirAll(agentsDir, 0755) os.WriteFile(filepath.Join(agentsDir, "helper.md"), []byte("# Helper Agent"), 0644) // Create extras "agents" source targeting a DIFFERENT path sourceRoot := filepath.Dir(sb.SourcePath) extrasAgentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(extrasAgentsSource, 0755) os.WriteFile(filepath.Join(extrasAgentsSource, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") customTarget := filepath.Join(sb.Home, "my-agents") os.MkdirAll(customTarget, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: skills: path: ` + targetPath + ` agents: path: ` + claudeAgents + ` extras: - name: agents targets: - path: ` + customTarget + ` `) result := sb.RunCLI("sync", "extras") result.AssertSuccess(t) result.AssertOutputNotContains(t, "Skipping extras") if !sb.FileExists(filepath.Join(customTarget, "extra-agent.md")) { t.Error("extra-agent.md should be synced to non-overlapping target") } } func TestSyncAll_AgentsExtrasOverlap_WarnsAndPreservesAgents_Global(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{ "SKILL.md": "# Placeholder", }) targetPath := sb.CreateTarget("claude") agentsDir := filepath.Join(filepath.Dir(sb.SourcePath), "agents") os.MkdirAll(agentsDir, 0755) os.WriteFile(filepath.Join(agentsDir, "demo.md"), []byte("# Demo Agent"), 0644) sourceRoot := filepath.Dir(sb.SourcePath) extrasAgentsSource := filepath.Join(sourceRoot, "extras", "agents") os.MkdirAll(extrasAgentsSource, 0755) os.WriteFile(filepath.Join(extrasAgentsSource, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(sb.Home, ".claude", "agents") os.MkdirAll(claudeAgents, 0755) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: agents targets: - path: ` + claudeAgents + ` `) result := sb.RunCLI("sync", "--all") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "Skipping extras") result.AssertAnyOutputContains(t, "already managed by agents sync") if !sb.IsSymlink(filepath.Join(claudeAgents, "demo.md")) { t.Error("demo agent should remain synced in global mode") } if sb.FileExists(filepath.Join(claudeAgents, "extra-agent.md")) { t.Error("extras agent file should not be synced when target overlaps agents sync") } } func TestSyncExtras_ProjectUsesRelativeSymlinks(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() projectRoot := sb.SetupProjectDir("claude") rulesSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules") if err := os.MkdirAll(rulesSource, 0755); err != nil { t.Fatal(err) } if err := os.WriteFile(filepath.Join(rulesSource, "rule.md"), []byte("# Rule"), 0644); err != nil { t.Fatal(err) } sb.WriteProjectConfig(projectRoot, `targets: - claude extras: - name: rules targets: - path: .cursor/rules `) result := sb.RunCLIInDir(projectRoot, "sync", "extras", "-p") result.AssertSuccess(t) link := filepath.Join(projectRoot, ".cursor", "rules", "rule.md") if !sb.IsSymlink(link) { t.Fatal("extra file should be a symlink") } if target := sb.SymlinkTarget(link); filepath.IsAbs(target) { t.Fatalf("project-mode extra symlink should be relative, got %q", target) } } func TestSyncAll_AgentsExtrasOverlap_WarnsAndPreservesAgents_Project(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() projectRoot := sb.SetupProjectDir("claude", "cursor") projectAgents := filepath.Join(projectRoot, ".skillshare", "agents") os.MkdirAll(projectAgents, 0755) os.WriteFile(filepath.Join(projectAgents, "demo.md"), []byte("# Demo Agent"), 0644) projectExtrasAgents := filepath.Join(projectRoot, ".skillshare", "extras", "agents") os.MkdirAll(projectExtrasAgents, 0755) os.WriteFile(filepath.Join(projectExtrasAgents, "extra-agent.md"), []byte("# Extra Agent"), 0644) claudeAgents := filepath.Join(projectRoot, ".claude", "agents") cursorAgents := filepath.Join(projectRoot, ".cursor", "agents") os.MkdirAll(claudeAgents, 0755) os.MkdirAll(cursorAgents, 0755) sb.WriteProjectConfig(projectRoot, `targets: - claude - cursor extras: - name: agents targets: - path: .claude/agents - path: .cursor/agents `) result := sb.RunCLIInDir(projectRoot, "sync", "--all", "-p") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "Skipping extras") result.AssertAnyOutputContains(t, "already managed by agents sync") if !sb.IsSymlink(filepath.Join(claudeAgents, "demo.md")) { t.Error("claude demo agent should remain synced in project mode") } if !sb.IsSymlink(filepath.Join(cursorAgents, "demo.md")) { t.Error("cursor demo agent should remain synced in project mode") } if sb.FileExists(filepath.Join(claudeAgents, "extra-agent.md")) { t.Error("project extras agent file should not be synced to claude when target overlaps agents sync") } if sb.FileExists(filepath.Join(cursorAgents, "extra-agent.md")) { t.Error("project extras agent file should not be synced to cursor when target overlaps agents sync") } } // syncExtrasJSONTargets parses `sync extras --json` output and returns the // targets of its only extra. func syncExtrasJSONTargets(t *testing.T, stdout string) []map[string]any { t.Helper() var out struct { Extras []struct { Targets []map[string]any `json:"targets"` } `json:"extras"` } if err := json.Unmarshal([]byte(stdout), &out); err != nil { t.Fatalf("invalid JSON: %v\n%s", err, stdout) } if len(out.Extras) != 1 { t.Fatalf("expected 1 extra, got %d:\n%s", len(out.Extras), stdout) } return out.Extras[0].Targets } // Global sync skips an extra whose source directory is missing instead of // creating it, like project sync. func TestSyncExtras_GlobalSkipsMissingSource(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{"SKILL.md": "# Placeholder"}) targetPath := sb.CreateTarget("claude") rulesSource := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules") sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + filepath.Join(sb.Home, ".claude", "rules") + ` `) result := sb.RunCLI("sync", "extras", "--json") result.AssertSuccess(t) if targets := syncExtrasJSONTargets(t, result.Stdout); len(targets) != 0 { t.Errorf("expected no targets for a missing source, got %v", targets) } if _, err := os.Stat(rulesSource); !os.IsNotExist(err) { t.Errorf("global sync must not create %s, stat err = %v", rulesSource, err) } } // Characterization: global JSON reports the target path from the loaded config, // where config.Load has already expanded "~". func TestSyncExtras_GlobalJSONReportsConfiguredPath(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("placeholder", map[string]string{"SKILL.md": "# Placeholder"}) targetPath := sb.CreateTarget("claude") rulesSource := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ~/.claude/rules `) result := sb.RunCLI("sync", "extras", "--json") result.AssertSuccess(t) targets := syncExtrasJSONTargets(t, result.Stdout) want := filepath.Join(sb.Home, ".claude", "rules") if got := targets[0]["path"]; got != want { t.Errorf("path = %v, want %q", got, want) } } // Project sync skips an extra whose source directory is missing instead of // creating it. func TestSyncExtras_ProjectSkipsMissingSource(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() projectRoot := sb.SetupProjectDir("claude") rulesSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules") sb.WriteProjectConfig(projectRoot, `targets: - claude extras: - name: rules targets: - path: .claude/rules `) result := sb.RunCLIInDir(projectRoot, "sync", "extras", "-p", "--json") result.AssertSuccess(t) if targets := syncExtrasJSONTargets(t, result.Stdout); len(targets) != 0 { t.Errorf("expected no targets for a missing source, got %v", targets) } if _, err := os.Stat(rulesSource); !os.IsNotExist(err) { t.Errorf("project sync must not create %s, stat err = %v", rulesSource, err) } } // Characterization: project JSON reports the resolved target path. func TestSyncExtras_ProjectJSONReportsResolvedPath(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() projectRoot := sb.SetupProjectDir("claude") rulesSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) sb.WriteProjectConfig(projectRoot, `targets: - claude extras: - name: rules targets: - path: .claude/rules `) result := sb.RunCLIInDir(projectRoot, "sync", "extras", "-p", "--json") result.AssertSuccess(t) // The CLI reports the real path; on macOS the temp dir sits behind /var -> /private/var. want, _ := filepath.EvalSymlinks(filepath.Join(projectRoot, ".claude", "rules")) if got := syncExtrasJSONTargets(t, result.Stdout)[0]["path"]; got != want { t.Errorf("path = %v, want %q", got, want) } } // `sync --all --json` exits non-zero when an extras target fails, as // `sync extras` does, while still writing the JSON result. func TestSyncAll_JSONExtrasTargetErrorExitsNonZero(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("my-skill", map[string]string{"SKILL.md": "# My Skill"}) targetPath := sb.CreateTarget("claude") rulesSource := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + filepath.Join(sb.Home, ".claude", "rules") + ` extension: missing-ext `) result := sb.RunCLI("sync", "--all", "--json") result.AssertFailure(t) var out struct { Extras []struct { Targets []map[string]any `json:"targets"` } `json:"extras"` } if err := json.Unmarshal([]byte(result.Stdout), &out); err != nil { t.Fatalf("invalid JSON: %v\n%s", err, result.Stdout) } if len(out.Extras) != 1 || len(out.Extras[0].Targets) != 1 || out.Extras[0].Targets[0]["error"] == nil { t.Errorf("expected the failed extras target in JSON, got %s", result.Stdout) } } // Text `sync --all` exits non-zero when an extras target fails, matching // `sync --all --json`, and still prints the extras warning. func TestSyncAll_TextExtrasTargetErrorExitsNonZero(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("my-skill", map[string]string{"SKILL.md": "# My Skill"}) targetPath := sb.CreateTarget("claude") rulesSource := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` extras: - name: rules targets: - path: ` + filepath.Join(sb.Home, ".claude", "rules") + ` extension: missing-ext `) result := sb.RunCLI("sync", "--all") result.AssertFailure(t) result.AssertAnyOutputContains(t, "Extras sync:") } // Project text `sync --all -p` exits non-zero when an extras target fails. func TestSyncAll_ProjectTextExtrasTargetErrorExitsNonZero(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() projectRoot := sb.SetupProjectDir("claude") rulesSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules") os.MkdirAll(rulesSource, 0755) os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644) sb.WriteProjectConfig(projectRoot, `targets: - claude extras: - name: rules targets: - path: .claude/rules extension: missing-ext `) result := sb.RunCLIInDir(projectRoot, "sync", "--all", "-p") result.AssertFailure(t) result.AssertAnyOutputContains(t, "Extras sync:") }