//go:build !online package integration import ( "encoding/json" "os" "path/filepath" "strings" "testing" "skillshare/internal/testutil" ) func TestSync_MergeMode_CreatesSymlinks(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create a skill in source sb.CreateSkill("my-skill", map[string]string{ "SKILL.md": "# My Skill\n\nDescription here.", }) // Create target directory targetPath := sb.CreateTarget("claude") // Write config sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) result.AssertOutputContains(t, "merged") // Verify symlink was created skillLink := filepath.Join(targetPath, "my-skill") if !sb.IsSymlink(skillLink) { t.Error("skill should be a symlink") } expectedTarget := filepath.Join(sb.SourcePath, "my-skill") if got := sb.SymlinkTarget(skillLink); got != expectedTarget { t.Errorf("symlink target = %q, want %q", got, expectedTarget) } } func TestSync_MergeMode_PreservesLocalSkills(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create source skill sb.CreateSkill("shared-skill", map[string]string{ "SKILL.md": "# Shared", }) // Create target with local skill targetPath := sb.CreateTarget("claude") localSkillPath := filepath.Join(targetPath, "local-skill") os.MkdirAll(localSkillPath, 0755) os.WriteFile(filepath.Join(localSkillPath, "SKILL.md"), []byte("# Local"), 0644) sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify local skill preserved (is still a directory, not symlink) if sb.IsSymlink(localSkillPath) { t.Error("local skill should not be converted to symlink") } if !sb.FileExists(filepath.Join(localSkillPath, "SKILL.md")) { t.Error("local skill files should be preserved") } // Verify shared skill is symlinked sharedSkillPath := filepath.Join(targetPath, "shared-skill") if !sb.IsSymlink(sharedSkillPath) { t.Error("shared skill should be a symlink") } } func TestSync_DryRun_NoChanges(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("test-skill", map[string]string{ "SKILL.md": "# Test", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // Record initial state entriesBefore, _ := os.ReadDir(targetPath) // Execute with --dry-run result := sb.RunCLI("sync", "--dry-run") result.AssertSuccess(t) result.AssertOutputContains(t, "Dry run") // Verify no changes made entriesAfter, _ := os.ReadDir(targetPath) if len(entriesAfter) != len(entriesBefore) { t.Error("dry-run should not modify file system") } } func TestSync_NoConfig_ReturnsError(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Remove config file os.Remove(sb.ConfigPath) result := sb.RunCLI("sync") result.AssertFailure(t) result.AssertAnyOutputContains(t, "init") } func TestSync_SourceNotExist_ReturnsError(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Config points to non-existent source targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: /nonexistent/path targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertFailure(t) result.AssertAnyOutputContains(t, "source path does not exist") } func TestSync_GlobalDefaultSourceWhenOmitted(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("default-source-skill", map[string]string{ "SKILL.md": "# Default Source Skill", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`targets: claude: skills: path: ` + targetPath + ` `) result := sb.RunCLI("sync", "--global") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "default-source-skill")) { t.Error("skill from default source should be synced") } } func TestSync_SymlinkMode_CreatesSingleSymlink(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("skill1", map[string]string{"SKILL.md": "# Skill 1"}) sb.CreateSkill("skill2", map[string]string{"SKILL.md": "# Skill 2"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` mode: symlink `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify target is a symlink to source if !sb.IsSymlink(targetPath) { t.Error("target should be a symlink") } if got := sb.SymlinkTarget(targetPath); got != sb.SourcePath { t.Errorf("symlink target = %q, want %q", got, sb.SourcePath) } } func TestSync_MultipleTargets_SyncsAll(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("common-skill", map[string]string{ "SKILL.md": "# Common Skill", }) claudePath := sb.CreateTarget("claude") codexPath := sb.CreateTarget("codex") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + claudePath + ` codex: path: ` + codexPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify skill synced to both targets if !sb.IsSymlink(filepath.Join(claudePath, "common-skill")) { t.Error("skill should be synced to claude") } if !sb.IsSymlink(filepath.Join(codexPath, "common-skill")) { t.Error("skill should be synced to codex") } } func TestSync_Force_OverwritesConflict(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("skill", map[string]string{"SKILL.md": "# Skill"}) // Create target as symlink to wrong location targetPath := filepath.Join(sb.Home, ".claude", "skills") wrongSource := filepath.Join(sb.Home, "wrong-source") os.MkdirAll(wrongSource, 0755) os.MkdirAll(filepath.Dir(targetPath), 0755) os.RemoveAll(targetPath) os.Symlink(wrongSource, targetPath) sb.WriteConfig(`source: ` + sb.SourcePath + ` targets: claude: path: ` + targetPath + ` mode: symlink `) // Execute without force - should fail result := sb.RunCLI("sync") result.AssertFailure(t) // Execute with force - should succeed result = sb.RunCLI("sync", "--force") result.AssertSuccess(t) // Verify symlink now points to correct source if got := sb.SymlinkTarget(targetPath); got != sb.SourcePath { t.Errorf("symlink target = %q, want %q", got, sb.SourcePath) } } func TestSync_NestedSkills_FlatNaming(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create nested skill structure // Source: personal/writing/email/SKILL.md -> Target: personal__writing__email sb.CreateNestedSkill("personal/writing/email", map[string]string{ "SKILL.md": "# Email Writing Skill", }) // Also create a regular flat skill for comparison sb.CreateSkill("my-helper", map[string]string{ "SKILL.md": "# My Helper", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify flat skill is symlinked normally flatSkillLink := filepath.Join(targetPath, "my-helper") if !sb.IsSymlink(flatSkillLink) { t.Error("flat skill should be a symlink") } // Verify nested skill is symlinked with flat naming nestedSkillLink := filepath.Join(targetPath, "personal__writing__email") if !sb.IsSymlink(nestedSkillLink) { t.Errorf("nested skill should be a symlink at %s", nestedSkillLink) } // Verify symlink points to correct nested source expectedNestedTarget := filepath.Join(sb.SourcePath, "personal", "writing", "email") if got := sb.SymlinkTarget(nestedSkillLink); got != expectedNestedTarget { t.Errorf("nested symlink target = %q, want %q", got, expectedNestedTarget) } } func TestSync_TrackedRepoSkills_FlatNaming(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create a tracked repo structure with nested skills // Source: _team-repo/frontend/ui/SKILL.md -> Target: _team-repo__frontend__ui sb.CreateNestedSkill("_team-repo/frontend/ui", map[string]string{ "SKILL.md": "# UI Components", }) // Another skill in the same tracked repo sb.CreateNestedSkill("_team-repo/backend/api", map[string]string{ "SKILL.md": "# API Utilities", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify tracked repo skills are symlinked with flat naming uiSkillLink := filepath.Join(targetPath, "_team-repo__frontend__ui") if !sb.IsSymlink(uiSkillLink) { t.Errorf("tracked repo skill should be a symlink at %s", uiSkillLink) } apiSkillLink := filepath.Join(targetPath, "_team-repo__backend__api") if !sb.IsSymlink(apiSkillLink) { t.Errorf("tracked repo skill should be a symlink at %s", apiSkillLink) } // Verify symlinks point to correct nested sources expectedUITarget := filepath.Join(sb.SourcePath, "_team-repo", "frontend", "ui") if got := sb.SymlinkTarget(uiSkillLink); got != expectedUITarget { t.Errorf("UI symlink target = %q, want %q", got, expectedUITarget) } } func TestSync_TrackedRepoSkills_HiddenDirs(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Simulate a tracked repo with skills inside hidden directories (like openai/skills) // Structure: _openai-skills/.curated/pdf/SKILL.md // _openai-skills/.system/figma/SKILL.md sb.CreateNestedSkill("_openai-skills/.curated/pdf", map[string]string{ "SKILL.md": "# PDF", }) sb.CreateNestedSkill("_openai-skills/.system/figma", map[string]string{ "SKILL.md": "# Figma", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify skills inside hidden dirs are discovered and synced pdfLink := filepath.Join(targetPath, "_openai-skills__.curated__pdf") if !sb.IsSymlink(pdfLink) { t.Errorf("skill inside .curated/ should be synced: %s", pdfLink) } figmaLink := filepath.Join(targetPath, "_openai-skills__.system__figma") if !sb.IsSymlink(figmaLink) { t.Errorf("skill inside .system/ should be synced: %s", figmaLink) } } func TestSync_Pruning_RemovesOrphanLinks(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create initial skills sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# Skill A"}) sb.CreateSkill("skill-b", map[string]string{"SKILL.md": "# Skill B"}) sb.CreateNestedSkill("nested/skill-c", map[string]string{"SKILL.md": "# Skill C"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // First sync - creates all symlinks result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify all symlinks exist if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) { t.Error("skill-a should be a symlink") } if !sb.IsSymlink(filepath.Join(targetPath, "skill-b")) { t.Error("skill-b should be a symlink") } if !sb.IsSymlink(filepath.Join(targetPath, "nested__skill-c")) { t.Error("nested__skill-c should be a symlink") } // Remove skill-b from source os.RemoveAll(filepath.Join(sb.SourcePath, "skill-b")) // Second sync - should prune skill-b result = sb.RunCLI("sync") result.AssertSuccess(t) result.AssertOutputContains(t, "pruned") // Verify skill-b is removed, others remain if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) { t.Error("skill-a should still be a symlink") } if sb.FileExists(filepath.Join(targetPath, "skill-b")) { t.Error("skill-b should have been pruned") } if !sb.IsSymlink(filepath.Join(targetPath, "nested__skill-c")) { t.Error("nested__skill-c should still be a symlink") } } func TestSync_PreservesRegistryEntries(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create a local skill that sync will discover sb.CreateSkill("local-skill", map[string]string{"SKILL.md": "# Local"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // Write a registry with a remote-installed skill that has NO files on disk. // Sync must NOT prune this entry — registry is the source of truth for installations. registryPath := filepath.Join(sb.SourcePath, "registry.yaml") registryContent := "skills:\n - name: remote-tool\n source: github.com/someone/remote-tool\n" os.WriteFile(registryPath, []byte(registryContent), 0644) result := sb.RunCLI("sync") result.AssertSuccess(t) // Verify registry still contains the remote-tool entry data, err := os.ReadFile(registryPath) if err != nil { t.Fatalf("failed to read registry: %v", err) } content := string(data) if !strings.Contains(content, "remote-tool") { t.Errorf("sync should preserve registry entry for installed skill without local files, got:\n%s", content) } } func TestSync_MergeMode_IncludeThenExclude(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("codex-plan", map[string]string{"SKILL.md": "# Plan"}) sb.CreateSkill("codex-test", map[string]string{"SKILL.md": "# Test"}) sb.CreateSkill("claude-help", map[string]string{"SKILL.md": "# Claude"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` include: [codex-*] exclude: ["*-test"] `) result := sb.RunCLI("sync") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "codex-plan")) { t.Error("included skill should be symlinked") } if sb.FileExists(filepath.Join(targetPath, "codex-test")) { t.Error("exclude should be applied after include") } if sb.FileExists(filepath.Join(targetPath, "claude-help")) { t.Error("skills outside include should not be synced") } } func TestSync_Pruning_RemovesExcludedSourceLinkedSkill(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("keep-me", map[string]string{"SKILL.md": "# Keep"}) sb.CreateSkill("exclude-me", map[string]string{"SKILL.md": "# Exclude"}) targetPath := sb.CreateTarget("claude") // Initial sync with no filters so both links exist. sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) sb.RunCLI("sync").AssertSuccess(t) // Add an exclude filter and sync again. sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` exclude: [exclude-*] `) result := sb.RunCLI("sync") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "keep-me")) { t.Error("non-excluded skill should stay synced") } if sb.FileExists(filepath.Join(targetPath, "exclude-me")) { t.Error("excluded source-linked skill should be removed by sync") } } func TestSync_Pruning_PreservesExcludedSourceLocalCopy(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("exclude-me", map[string]string{"SKILL.md": "# Source"}) targetPath := sb.CreateTarget("claude") // Create local copy in target (not symlink) localSkillPath := filepath.Join(targetPath, "exclude-me") if err := os.MkdirAll(localSkillPath, 0755); err != nil { t.Fatalf("failed to create local skill dir: %v", err) } if err := os.WriteFile(filepath.Join(localSkillPath, "SKILL.md"), []byte("# Local"), 0644); err != nil { t.Fatalf("failed to write local skill: %v", err) } // First sync keeps local copy (no force). sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) sb.RunCLI("sync").AssertSuccess(t) if !sb.FileExists(localSkillPath) { t.Fatal("local copy should exist before exclude") } // Add exclude and sync again - local copy should stay. sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` exclude: [exclude-*] `) result := sb.RunCLI("sync") result.AssertSuccess(t) if !sb.FileExists(localSkillPath) { t.Error("excluded source skill local copy should be preserved") } } func TestSync_Pruning_RemovesBrokenExternalSymlinks(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() // Create a skill and sync it sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# Skill A"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Simulate data migration: create a symlink pointing to a non-existent // external path (as if the old source directory was moved/deleted) oldPath := filepath.Join(sb.Home, "old-config", "skillshare", "skills", "migrated-skill") os.Symlink(oldPath, filepath.Join(targetPath, "migrated-skill")) if !sb.IsSymlink(filepath.Join(targetPath, "migrated-skill")) { t.Fatal("setup: migrated-skill symlink should exist") } // Sync again — broken external symlink should be auto-removed result = sb.RunCLI("sync") result.AssertSuccess(t) if sb.FileExists(filepath.Join(targetPath, "migrated-skill")) { t.Error("broken external symlink should have been pruned") } // Valid skill should still exist if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) { t.Error("skill-a should still be a symlink") } } func TestSync_Pruning_ForceRemovesExternalSymlinks(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# Skill A"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) // Create a valid external symlink (target exists but outside source dir) externalDir := filepath.Join(sb.Home, "external-skills", "ext-skill") os.MkdirAll(externalDir, 0755) os.WriteFile(filepath.Join(externalDir, "SKILL.md"), []byte("# External"), 0644) os.Symlink(externalDir, filepath.Join(targetPath, "ext-skill")) // Sync without force — external symlink should be preserved (with warning) result = sb.RunCLI("sync") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "ext-skill")) { t.Error("valid external symlink should be preserved without --force") } // Sync with --force — external symlink should be removed result = sb.RunCLI("sync", "--force") result.AssertSuccess(t) if sb.FileExists(filepath.Join(targetPath, "ext-skill")) { t.Error("external symlink should have been removed with --force") } // Valid source skill should still exist if !sb.IsSymlink(filepath.Join(targetPath, "skill-a")) { t.Error("skill-a should still be a symlink") } } func TestSync_MergeMode_ManifestPrunesOrphanDir(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") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // First sync — creates symlink + manifest result := sb.RunCLI("sync") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "my-skill")) { t.Fatal("my-skill should be a symlink after sync") } // Replace symlink with a real directory (simulates copy-mode residue) os.Remove(filepath.Join(targetPath, "my-skill")) os.MkdirAll(filepath.Join(targetPath, "my-skill"), 0755) os.WriteFile(filepath.Join(targetPath, "my-skill", "SKILL.md"), []byte("# Copy"), 0644) // Remove source skill (simulates uninstall) os.RemoveAll(filepath.Join(sb.SourcePath, "my-skill")) // Sync again — manifest knows my-skill was managed, so it should be pruned result = sb.RunCLI("sync") result.AssertSuccess(t) if sb.FileExists(filepath.Join(targetPath, "my-skill")) { t.Error("manifest-tracked orphan directory should have been pruned") } } func TestSync_MergeMode_ManifestPreservesUserDir(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("shared-skill", map[string]string{"SKILL.md": "# Shared"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // Sync to establish manifest result := sb.RunCLI("sync") result.AssertSuccess(t) // Manually create a user directory (never synced by skillshare) userDir := filepath.Join(targetPath, "user-created") os.MkdirAll(userDir, 0755) os.WriteFile(filepath.Join(userDir, "SKILL.md"), []byte("# User"), 0644) // Remove source skill os.RemoveAll(filepath.Join(sb.SourcePath, "shared-skill")) // Sync again — user-created should be preserved (not in manifest) result = sb.RunCLI("sync") result.AssertSuccess(t) if !sb.FileExists(userDir) { t.Error("user-created directory should be preserved (not in manifest)") } } func TestSync_MergeMode_InvalidFilterPatternFails(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("skill-a", map[string]string{"SKILL.md": "# Skill"}) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` include: ["["] `) result := sb.RunCLI("sync") result.AssertFailure(t) result.AssertAnyOutputContains(t, "invalid include pattern") } func TestSync_IgnoredSkillsTextOutput(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("keep-me", map[string]string{ "SKILL.md": "---\nname: keep-me\n---\nKeep", }) sb.CreateSkill("ignore-me", map[string]string{ "SKILL.md": "---\nname: ignore-me\n---\nIgnored", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) os.WriteFile(filepath.Join(sb.SourcePath, ".skillignore"), []byte("ignore-me\n"), 0644) result := sb.RunCLI("sync") result.AssertSuccess(t) result.AssertAnyOutputContains(t, "1 skill(s) ignored by .skillignore") result.AssertAnyOutputContains(t, "ignore-me") } func TestSync_IgnoredSkillsJSONOutput(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("keep-me", map[string]string{ "SKILL.md": "---\nname: keep-me\n---\nKeep", }) sb.CreateSkill("ignore-me", map[string]string{ "SKILL.md": "---\nname: ignore-me\n---\nIgnored", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) os.WriteFile(filepath.Join(sb.SourcePath, ".skillignore"), []byte("ignore-me\n"), 0644) result := sb.RunCLI("sync", "--json") result.AssertSuccess(t) var output map[string]any if err := json.Unmarshal([]byte(result.Stdout), &output); err != nil { t.Fatalf("failed to parse JSON: %v", err) } ignoredCount := int(output["ignored_count"].(float64)) if ignoredCount != 1 { t.Errorf("expected ignored_count=1, got %d", ignoredCount) } ignoredSkills := output["ignored_skills"].([]any) if len(ignoredSkills) != 1 || ignoredSkills[0].(string) != "ignore-me" { t.Errorf("expected ignored_skills=[ignore-me], got %v", ignoredSkills) } } func TestSync_NoSkillignore_NoIgnoredOutput(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("my-skill", map[string]string{ "SKILL.md": "---\nname: my-skill\n---\nContent", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) result := sb.RunCLI("sync") result.AssertSuccess(t) result.AssertOutputNotContains(t, "ignored by .skillignore") } func TestSync_SkillignoreLocal_OverridesBase(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("keep-me", map[string]string{ "SKILL.md": "---\nname: keep-me\n---\nKeep", }) sb.CreateSkill("private-mine", map[string]string{ "SKILL.md": "---\nname: private-mine\n---\nMine", }) sb.CreateSkill("private-other", map[string]string{ "SKILL.md": "---\nname: private-other\n---\nOther", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // .skillignore blocks all private-* skills os.WriteFile(filepath.Join(sb.SourcePath, ".skillignore"), []byte("private-*\n"), 0644) // .skillignore.local un-ignores private-mine os.WriteFile(filepath.Join(sb.SourcePath, ".skillignore.local"), []byte("!private-mine\n"), 0644) result := sb.RunCLI("sync") result.AssertSuccess(t) // private-mine should be synced (un-ignored by .local) if _, err := os.Stat(filepath.Join(targetPath, "private-mine")); os.IsNotExist(err) { t.Error("private-mine should be synced (un-ignored by .skillignore.local)") } // private-other should NOT be synced (still ignored) if _, err := os.Stat(filepath.Join(targetPath, "private-other")); err == nil { t.Error("private-other should NOT be synced (still ignored)") } // keep-me should be synced if _, err := os.Stat(filepath.Join(targetPath, "keep-me")); os.IsNotExist(err) { t.Error("keep-me should be synced") } // Output should show 1 ignored skill and .local hint result.AssertAnyOutputContains(t, "1 skill(s) ignored by .skillignore") result.AssertAnyOutputContains(t, "private-other") result.AssertAnyOutputContains(t, ".local") } func TestSync_SkillignoreLocal_OnlyLocalFile(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("my-skill", map[string]string{ "SKILL.md": "---\nname: my-skill\n---\nContent", }) sb.CreateSkill("debug-tool", map[string]string{ "SKILL.md": "---\nname: debug-tool\n---\nDebug", }) targetPath := sb.CreateTarget("claude") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: claude: path: ` + targetPath + ` `) // Only .skillignore.local, no .skillignore os.WriteFile(filepath.Join(sb.SourcePath, ".skillignore.local"), []byte("debug-tool\n"), 0644) result := sb.RunCLI("sync") result.AssertSuccess(t) // debug-tool should be ignored if _, err := os.Stat(filepath.Join(targetPath, "debug-tool")); err == nil { t.Error("debug-tool should be ignored by .skillignore.local") } // my-skill should be synced if _, err := os.Stat(filepath.Join(targetPath, "my-skill")); os.IsNotExist(err) { t.Error("my-skill should be synced") } } // A built-in target listed without a path takes its path from targets.yaml. // antigravity-cli used to be an alias, and DefaultTargets() is not alias-aware, // so a path-less entry failed validation instead of resolving. func TestSync_BuiltinTargetWithoutPath_UsesDefaultPath(t *testing.T) { sb := testutil.NewSandbox(t) defer sb.Cleanup() sb.CreateSkill("my-skill", map[string]string{ "SKILL.md": "# My Skill", }) targetPath := sb.CreateTarget("antigravity-cli") sb.WriteConfig(`source: ` + sb.SourcePath + ` mode: merge targets: antigravity-cli: `) result := sb.RunCLI("sync") result.AssertSuccess(t) if !sb.IsSymlink(filepath.Join(targetPath, "my-skill")) { t.Errorf("symlink not created at %s", filepath.Join(targetPath, "my-skill")) } }