Files
skillshare/internal/sync/discover_test.go
T
Willie 881d08e52e fix(sync): skip nested target dotdirs when discovering source skills
Installing a repo whose root is a skill copies the whole repo into the
source, including any .claude/skills/ the author keeps for their own
development. Install discovery already skips target dotdirs, but the
source walk used by sync, check, and the dashboard only skipped .git,
so those dev-only skills surfaced as nested skills and were synced to
every target.

Share the skip set through sourcewalk and apply it in both source
walks. Only dotdirs nested below the source root are skipped: host-style
paths directly under the root (.cursor/skills/*) stay visible because
they drive target inference.
2026-10-04 17:11:53 +08:00

849 lines
26 KiB
Go

package sync
import (
"os"
"path/filepath"
"strings"
"testing"
"skillshare/internal/sourcewalk"
)
func writeSkillMD(t *testing.T, dir, content string) {
t.Helper()
if err := os.MkdirAll(dir, 0755); err != nil {
t.Fatalf("mkdir %s: %v", dir, err)
}
if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte(content), 0644); err != nil {
t.Fatalf("write SKILL.md in %s: %v", dir, err)
}
}
func TestDiscoverSourceSkills_SingleSkill(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, "my-skill"), "---\nname: my-skill\n---\n# My Skill")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].RelPath != "my-skill" {
t.Errorf("expected relPath 'my-skill', got %q", skills[0].RelPath)
}
if skills[0].FlatName != "my-skill" {
t.Errorf("expected flatName 'my-skill', got %q", skills[0].FlatName)
}
if skills[0].IsInRepo {
t.Error("expected IsInRepo false for non-tracked skill")
}
}
func TestDiscoverSourceSkills_Nested(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, "group", "sub-skill"), "---\nname: sub-skill\n---\n# Sub")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].FlatName != "group__sub-skill" {
t.Errorf("expected flatName 'group__sub-skill', got %q", skills[0].FlatName)
}
}
func TestDiscoverSourceSkills_SkipsGitDir(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, "real-skill"), "---\nname: real\n---\n# Real")
// Put a SKILL.md inside .git — should be ignored
writeSkillMD(t, filepath.Join(src, ".git", "hidden-skill"), "---\nname: hidden\n---\n# Hidden")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill (skipping .git), got %d", len(skills))
}
if skills[0].FlatName != "real-skill" {
t.Errorf("expected 'real-skill', got %q", skills[0].FlatName)
}
}
func TestDiscoverSourceSkills_SkipsTargetDotDirs(t *testing.T) {
orig := sourcewalk.TargetDotDirs
sourcewalk.TargetDotDirs = map[string]bool{".claude": true, ".skillshare": true}
defer func() { sourcewalk.TargetDotDirs = orig }()
src := t.TempDir()
// A root-level skill installed from a repo that ships its own .claude/skills/
writeSkillMD(t, filepath.Join(src, "ffmpeg-skill"), "---\nname: ffmpeg-skill\n---\n# FFmpeg")
writeSkillMD(t, filepath.Join(src, "ffmpeg-skill", ".claude", "skills", "code-review"), "---\nname: code-review\n---\n# Dev only")
// A root-level host-style path stays visible (used for target inference)
writeSkillMD(t, filepath.Join(src, ".claude", "skills", "host-skill"), "---\nname: host-skill\n---\n# Host")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
got := map[string]bool{}
for _, s := range skills {
got[s.RelPath] = true
}
if len(skills) != 2 || !got["ffmpeg-skill"] || !got[".claude/skills/host-skill"] {
t.Fatalf("expected ffmpeg-skill and .claude/skills/host-skill only, got %+v", skills)
}
}
func TestDiscoverSourceSkills_SkipsRoot(t *testing.T) {
src := t.TempDir()
// SKILL.md at root level should be skipped (relPath == ".")
if err := os.WriteFile(filepath.Join(src, "SKILL.md"), []byte("---\nname: root\n---\n"), 0644); err != nil {
t.Fatal(err)
}
writeSkillMD(t, filepath.Join(src, "child"), "---\nname: child\n---\n# Child")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill (skipping root), got %d", len(skills))
}
if skills[0].FlatName != "child" {
t.Errorf("expected 'child', got %q", skills[0].FlatName)
}
}
func TestDiscoverSourceSkills_TrackedRepo(t *testing.T) {
src := t.TempDir()
// "_team" prefix indicates a tracked repo
writeSkillMD(t, filepath.Join(src, "_team", "coding"), "---\nname: coding\n---\n# Coding")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if !skills[0].IsInRepo {
t.Error("expected IsInRepo true for _-prefixed parent")
}
}
func TestDiscoverSourceSkills_ParsesTargets(t *testing.T) {
src := t.TempDir()
content := "---\nname: targeted\ntargets:\n - claude\n - cursor\n---\n# Targeted"
writeSkillMD(t, filepath.Join(src, "targeted-skill"), content)
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].Targets == nil {
t.Fatal("expected Targets to be non-nil")
}
if len(skills[0].Targets) != 2 {
t.Fatalf("expected 2 targets, got %d", len(skills[0].Targets))
}
}
func TestDiscoverSourceSkills_InfersTargetsFromHostPaths(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, ".cursor", "skills", "gstack-browse"), "---\nname: gstack-browse\n---\n# Cursor")
writeSkillMD(t, filepath.Join(src, "openclaw", "skills", "gstack-openclaw-investigate"), "---\nname: gstack-openclaw-investigate\n---\n# Openclaw")
writeSkillMD(t, filepath.Join(src, ".factory", "skills", "gstack-benchmark"), "---\nname: gstack-benchmark\n---\n# Factory")
writeSkillMD(t, filepath.Join(src, ".skills", "letta-skill"), "---\nname: letta-skill\n---\n# Letta")
writeSkillMD(t, filepath.Join(src, ".agents", "skills", "universal-skill"), "---\nname: universal-skill\n---\n# Universal")
writeSkillMD(t, filepath.Join(src, "shared", "generic"), "---\nname: generic\n---\n# Generic")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 6 {
t.Fatalf("expected 6 skills, got %d", len(skills))
}
byRel := make(map[string]DiscoveredSkill)
for _, s := range skills {
byRel[s.RelPath] = s
}
cursorSkill := byRel[".cursor/skills/gstack-browse"]
if cursorSkill.RelPath == "" {
t.Fatalf("missing .cursor/skills/gstack-browse")
}
if len(cursorSkill.Targets) != 1 || cursorSkill.Targets[0] != "cursor" {
t.Errorf("expected cursor host skill to target [cursor], got %v", cursorSkill.Targets)
}
openclawSkill := byRel["openclaw/skills/gstack-openclaw-investigate"]
if openclawSkill.RelPath == "" {
t.Fatalf("missing openclaw/skills/gstack-openclaw-investigate")
}
if len(openclawSkill.Targets) != 1 || openclawSkill.Targets[0] != "openclaw" {
t.Errorf("expected openclaw host skill to target [openclaw], got %v", openclawSkill.Targets)
}
factorySkill := byRel[".factory/skills/gstack-benchmark"]
if factorySkill.RelPath == "" {
t.Fatalf("missing .factory/skills/gstack-benchmark")
}
if len(factorySkill.Targets) != 1 || factorySkill.Targets[0] != "droid" {
t.Errorf("expected .factory host skill to target [droid], got %v", factorySkill.Targets)
}
lettaSkill := byRel[".skills/letta-skill"]
if lettaSkill.RelPath == "" {
t.Fatalf("missing .skills/letta-skill")
}
if len(lettaSkill.Targets) != 1 || lettaSkill.Targets[0] != "letta" {
t.Errorf("expected .skills host skill to target [letta], got %v", lettaSkill.Targets)
}
universalSkill := byRel[".agents/skills/universal-skill"]
if universalSkill.RelPath == "" {
t.Fatalf("missing .agents/skills/universal-skill")
}
// .agents/skills is shared by multiple targets (universal, codex, amp, etc.)
uTargets := make(map[string]bool, len(universalSkill.Targets))
for _, tgt := range universalSkill.Targets {
uTargets[tgt] = true
}
if !uTargets["universal"] || !uTargets["codex"] {
t.Errorf("expected .agents host skill targets to include universal and codex, got %v", universalSkill.Targets)
}
if len(universalSkill.Targets) < 2 {
t.Errorf("expected multiple targets for .agents/skills path, got %v", universalSkill.Targets)
}
genericSkill := byRel["shared/generic"]
if genericSkill.RelPath == "" {
t.Fatalf("missing shared/generic")
}
if genericSkill.Targets != nil {
t.Errorf("expected generic skill targets to be nil, got %v", genericSkill.Targets)
}
}
func TestDiscoverSourceSkills_EmptyDir(t *testing.T) {
src := t.TempDir()
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 0 {
t.Errorf("expected 0 skills for empty dir, got %d", len(skills))
}
}
func TestDiscoverSourceSkills_NonExistent(t *testing.T) {
// filepath.Walk skips inaccessible paths, so non-existent source returns empty list
skills, err := DiscoverSourceSkills("/nonexistent/path/for/test")
if err != nil {
// Acceptable: some OS may return walk error
return
}
if len(skills) != 0 {
t.Errorf("expected 0 skills for non-existent path, got %d", len(skills))
}
}
// --- DiscoverSourceSkillsLite tests ---
func TestDiscoverSourceSkillsLite_SkipsTargetsParsing(t *testing.T) {
src := t.TempDir()
content := "---\nname: targeted\ntargets:\n - claude\n - cursor\n---\n# Targeted"
writeSkillMD(t, filepath.Join(src, "targeted-skill"), content)
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
// Lite version should NOT parse targets
if skills[0].Targets != nil {
t.Errorf("expected Targets to be nil in Lite mode, got %v", skills[0].Targets)
}
if len(repos) != 0 {
t.Errorf("expected 0 tracked repos, got %d", len(repos))
}
}
func TestDiscoverSourceSkillsLite_DoesNotInferTargetsFromPath(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, ".cursor", "skills", "gstack-browse"), "---\nname: gstack-browse\n---\n# Cursor")
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].Targets != nil {
t.Errorf("expected Targets to be nil in Lite mode, got %v", skills[0].Targets)
}
if len(repos) != 0 {
t.Errorf("expected 0 tracked repos, got %d", len(repos))
}
}
func TestDiscoverSourceSkillsLite_CollectsTrackedRepos(t *testing.T) {
src := t.TempDir()
// Create a tracked repo with .git dir and a skill inside
repoDir := filepath.Join(src, "_team")
if err := os.MkdirAll(filepath.Join(repoDir, ".git"), 0755); err != nil {
t.Fatal(err)
}
writeSkillMD(t, filepath.Join(repoDir, "coding"), "---\nname: coding\n---\n# Coding")
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if !skills[0].IsInRepo {
t.Error("expected IsInRepo true")
}
if len(repos) != 1 {
t.Fatalf("expected 1 tracked repo, got %d", len(repos))
}
if repos[0] != "_team" {
t.Errorf("expected tracked repo '_team', got %q", repos[0])
}
}
func TestDiscoverSourceSkillsLite_BasicDiscovery(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, "skill-a"), "---\nname: a\n---\n# A")
writeSkillMD(t, filepath.Join(src, "group", "skill-b"), "---\nname: b\n---\n# B")
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 2 {
t.Fatalf("expected 2 skills, got %d", len(skills))
}
if len(repos) != 0 {
t.Errorf("expected 0 tracked repos, got %d", len(repos))
}
// Verify flat names are correct
names := map[string]bool{}
for _, s := range skills {
names[s.FlatName] = true
}
if !names["skill-a"] {
t.Error("missing skill-a")
}
if !names["group__skill-b"] {
t.Error("missing group__skill-b")
}
}
// --- .skillignore tests (Issue #83) ---
func TestDiscoverSourceSkills_RespectsSkillIgnore(t *testing.T) {
src := t.TempDir()
// Create a tracked repo with .skillignore excluding .venv
repoDir := filepath.Join(src, "_team-skills")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte(".venv\n"), 0644)
// Vendored SKILL.md inside .venv — should be ignored
venvSkill := filepath.Join(repoDir, ".venv", "lib", "python3.13", "site-packages", "fastapi", ".agents", "skills", "fastapi")
writeSkillMD(t, venvSkill, "not a real skill")
// Normal skill — should be discovered
writeSkillMD(t, filepath.Join(repoDir, "my-skill"), "---\nname: my-skill\n---\n# My Skill")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
for _, s := range skills {
if strings.Contains(s.RelPath, ".venv") {
t.Errorf("expected .venv skill to be filtered by .skillignore, got %s", s.RelPath)
}
}
if len(skills) != 1 {
t.Errorf("expected 1 skill, got %d", len(skills))
}
}
func TestDiscoverSourceSkillsLite_RespectsSkillIgnore(t *testing.T) {
src := t.TempDir()
// Same layout as above
repoDir := filepath.Join(src, "_team-skills")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte(".venv\n"), 0644)
venvSkill := filepath.Join(repoDir, ".venv", "lib", "fastapi")
writeSkillMD(t, venvSkill, "not a real skill")
writeSkillMD(t, filepath.Join(repoDir, "my-skill"), "---\nname: my-skill\n---\n# My Skill")
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
for _, s := range skills {
if strings.Contains(s.RelPath, ".venv") {
t.Errorf("expected .venv skill to be filtered by .skillignore, got %s", s.RelPath)
}
}
if len(skills) != 1 {
t.Errorf("expected 1 skill, got %d", len(skills))
}
if len(repos) != 1 || repos[0] != "_team-skills" {
t.Errorf("expected tracked repo [_team-skills], got %v", repos)
}
}
// --- SkipDir + root-level .skillignore tests ---
func TestDiscoverSourceSkills_SkipDirDoesNotDescend(t *testing.T) {
src := t.TempDir()
repoDir := filepath.Join(src, "_team")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte(".venv\n"), 0644)
// Deep nested SKILL.md inside .venv
deepPath := filepath.Join(repoDir, ".venv", "a", "b", "c", "d", "e")
writeSkillMD(t, deepPath, "deep vendored skill")
writeSkillMD(t, filepath.Join(repoDir, "real-skill"), "---\nname: real\n---\n# Real")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Errorf("expected 1 skill, got %d", len(skills))
}
}
func TestDiscoverSourceSkills_RootLevelSkillIgnore(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("draft-*\nmy-hidden\n"), 0644)
writeSkillMD(t, filepath.Join(src, "draft-feature"), "---\nname: draft-feature\n---\n")
writeSkillMD(t, filepath.Join(src, "draft-experiment"), "---\nname: draft-experiment\n---\n")
writeSkillMD(t, filepath.Join(src, "my-hidden"), "---\nname: my-hidden\n---\n")
writeSkillMD(t, filepath.Join(src, "visible-skill"), "---\nname: visible\n---\n")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Errorf("expected 1 skill (visible-skill), got %d", len(skills))
}
if len(skills) == 1 && skills[0].FlatName != "visible-skill" {
t.Errorf("expected 'visible-skill', got %q", skills[0].FlatName)
}
}
func TestDiscoverSourceSkillsLite_RootLevelSkillIgnore(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("hidden\n"), 0644)
writeSkillMD(t, filepath.Join(src, "hidden"), "---\nname: hidden\n---\n")
writeSkillMD(t, filepath.Join(src, "visible"), "---\nname: visible\n---\n")
skills, _, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Errorf("expected 1 skill, got %d", len(skills))
}
}
func TestDiscoverSourceSkills_RootSkipsEntireTrackedRepo(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("_unwanted\n"), 0644)
repoDir := filepath.Join(src, "_unwanted")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
writeSkillMD(t, filepath.Join(repoDir, "skill-a"), "---\nname: a\n---\n")
writeSkillMD(t, filepath.Join(repoDir, "skill-b"), "---\nname: b\n---\n")
writeSkillMD(t, filepath.Join(src, "kept"), "---\nname: kept\n---\n")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Errorf("expected 1 skill, got %d", len(skills))
}
}
func TestDiscoverSourceSkills_RootAndRepoLayering(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("draft-*\n"), 0644)
repoDir := filepath.Join(src, "_team")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte(".venv\n"), 0644)
writeSkillMD(t, filepath.Join(src, "draft-wip"), "---\nname: wip\n---\n")
writeSkillMD(t, filepath.Join(repoDir, ".venv", "pkg"), "vendored")
writeSkillMD(t, filepath.Join(repoDir, "real"), "---\nname: real\n---\n")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 1 {
t.Errorf("expected 1 skill (real), got %d", len(skills))
}
}
func TestDiscoverSourceSkills_EmptyRootSkillIgnore(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("# just a comment\n\n"), 0644)
writeSkillMD(t, filepath.Join(src, "skill-a"), "---\nname: a\n---\n")
writeSkillMD(t, filepath.Join(src, "skill-b"), "---\nname: b\n---\n")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 2 {
t.Errorf("expected 2 skills, got %d", len(skills))
}
}
// --- Gitignore syntax integration tests ---
// Exercise discovery wiring here; exhaustive pattern semantics live in internal/skillignore.
func TestDiscoverSourceSkills_IgnorePatterns(t *testing.T) {
for _, tt := range []struct {
name string
patterns string
ignored []string
kept []string
}{
{"DoubleStarPattern", "**/temp\n", []string{"temp", "sub/temp"}, []string{"real-skill"}},
{"NegationPattern", "test-*\n!test-important\n", []string{"test-alpha", "test-beta"}, []string{"test-important", "prod-skill"}},
{"DirOnlyPattern", "demo/\n", []string{"demo"}, []string{"demo-skill", "real"}},
{"QuestionMarkPattern", "?.md-test\n", []string{"a.md-test"}, []string{"ab.md-test", "real-skill"}},
{"CharClassPattern", "[Tt]emp\n", []string{"Temp", "temp"}, []string{"hemp"}},
} {
t.Run(tt.name, func(t *testing.T) {
src := t.TempDir()
repoDir := filepath.Join(src, "_team")
if err := os.MkdirAll(filepath.Join(repoDir, ".git"), 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte(tt.patterns), 0644); err != nil {
t.Fatal(err)
}
for _, paths := range [][]string{tt.ignored, tt.kept} {
for _, path := range paths {
writeSkillMD(t, filepath.Join(repoDir, path), "# Skill")
}
}
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != len(tt.kept) {
t.Fatalf("expected %d skills, got %v", len(tt.kept), skills)
}
found := map[string]bool{}
for _, skill := range skills {
found[skill.FlatName] = true
}
for _, path := range tt.kept {
if !found["_team__"+strings.ReplaceAll(path, "/", "__")] {
t.Errorf("missing kept skill %q", path)
}
}
})
}
}
func TestDiscoverSourceSkillsLite_NegationWithCanSkipDir(t *testing.T) {
src := t.TempDir()
repoDir := filepath.Join(src, "_team")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
// Ignore vendor/ but un-ignore vendor/important
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte("vendor/\n!vendor/important\n"), 0644)
writeSkillMD(t, filepath.Join(repoDir, "vendor", "lib-a"), "ignored")
writeSkillMD(t, filepath.Join(repoDir, "vendor", "important"), "kept by negation")
writeSkillMD(t, filepath.Join(repoDir, "real"), "kept")
skills, _, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
nameSet := map[string]bool{}
for _, s := range skills {
nameSet[s.FlatName] = true
}
if nameSet["_team__vendor__lib-a"] {
t.Error("vendor/lib-a should be ignored by vendor/")
}
if !nameSet["_team__vendor__important"] {
t.Error("vendor/important should be kept by !vendor/important negation")
}
if !nameSet["_team__real"] {
t.Error("real should be kept")
}
}
func TestDiscoverSourceSkills_RootLevelGitignoreSyntax(t *testing.T) {
src := t.TempDir()
// Root-level .skillignore with gitignore syntax
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("**/temp\ndemo/\n!demo/keep\n"), 0644)
writeSkillMD(t, filepath.Join(src, "temp"), "ignored by **/temp")
writeSkillMD(t, filepath.Join(src, "sub", "temp"), "ignored by **/temp")
writeSkillMD(t, filepath.Join(src, "demo", "sub"), "ignored by demo/")
writeSkillMD(t, filepath.Join(src, "demo", "keep"), "kept by !demo/keep")
writeSkillMD(t, filepath.Join(src, "real"), "kept")
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
nameSet := map[string]bool{}
for _, s := range skills {
nameSet[s.RelPath] = true
}
if nameSet["temp"] {
t.Error("temp should be ignored by **/temp")
}
if nameSet["sub/temp"] {
t.Error("sub/temp should be ignored by **/temp")
}
if nameSet["demo/sub"] {
t.Error("demo/sub should be ignored by demo/")
}
if !nameSet["demo/keep"] {
t.Error("demo/keep should be kept by !demo/keep")
}
if !nameSet["real"] {
t.Error("real should be kept")
}
}
func TestDiscoverSourceSkillsLite_EmptyDir(t *testing.T) {
src := t.TempDir()
skills, repos, err := DiscoverSourceSkillsLite(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 0 {
t.Errorf("expected 0 skills, got %d", len(skills))
}
if len(repos) != 0 {
t.Errorf("expected 0 repos, got %d", len(repos))
}
}
// --- DiscoverSourceSkillsWithStats tests ---
func TestDiscoverSourceSkillsWithStats_ReturnsIgnoredSkills(t *testing.T) {
src := t.TempDir()
// Create a tracked repo with .skillignore
repoDir := filepath.Join(src, "_team")
os.MkdirAll(filepath.Join(repoDir, ".git"), 0755)
os.WriteFile(filepath.Join(repoDir, ".skillignore"), []byte("test-*\nvendor/\n"), 0644)
// Skills that should be ignored
writeSkillMD(t, filepath.Join(repoDir, "test-alpha"), "ignored")
writeSkillMD(t, filepath.Join(repoDir, "test-beta"), "ignored")
writeSkillMD(t, filepath.Join(repoDir, "vendor", "lib"), "ignored")
// Skills that should be discovered
writeSkillMD(t, filepath.Join(repoDir, "real-skill"), "---\nname: real\n---\n# Real")
skills, stats, err := DiscoverSourceSkillsWithStats(src)
if err != nil {
t.Fatal(err)
}
// Should discover only the non-ignored skill
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].FlatName != "_team__real-skill" {
t.Errorf("expected '_team__real-skill', got %q", skills[0].FlatName)
}
// Stats should be active
if stats == nil {
t.Fatal("expected non-nil stats")
}
if !stats.Active() {
t.Error("expected stats.Active() = true")
}
// Repo file should be recorded
if len(stats.RepoFiles) != 1 {
t.Fatalf("expected 1 repo file, got %d", len(stats.RepoFiles))
}
if !strings.HasSuffix(stats.RepoFiles[0], "_team/.skillignore") &&
!strings.HasSuffix(stats.RepoFiles[0], "_team\\.skillignore") {
t.Errorf("expected repo file ending with _team/.skillignore, got %q", stats.RepoFiles[0])
}
// Patterns should be collected
if stats.PatternCount() != 2 {
t.Errorf("expected 2 patterns, got %d: %v", stats.PatternCount(), stats.Patterns)
}
// Ignored skills should be recorded
// Note: vendor/lib may be skipped by CanSkipDir (directory-level skip),
// so only skills that pass through the file-level Match check are recorded.
// test-alpha and test-beta should be recorded as ignored.
if stats.IgnoredCount() < 2 {
t.Errorf("expected at least 2 ignored skills, got %d: %v", stats.IgnoredCount(), stats.IgnoredSkills)
}
// Verify ignored paths contain the expected skills
ignoredSet := map[string]bool{}
for _, p := range stats.IgnoredSkills {
ignoredSet[p] = true
}
if !ignoredSet["_team/test-alpha"] {
t.Error("expected _team/test-alpha in ignored skills")
}
if !ignoredSet["_team/test-beta"] {
t.Error("expected _team/test-beta in ignored skills")
}
}
func TestDiscoverSourceSkillsWithStats_NoSkillignore(t *testing.T) {
src := t.TempDir()
writeSkillMD(t, filepath.Join(src, "skill-a"), "---\nname: a\n---\n# A")
writeSkillMD(t, filepath.Join(src, "skill-b"), "---\nname: b\n---\n# B")
skills, stats, err := DiscoverSourceSkillsWithStats(src)
if err != nil {
t.Fatal(err)
}
if len(skills) != 2 {
t.Fatalf("expected 2 skills, got %d", len(skills))
}
if stats == nil {
t.Fatal("expected non-nil stats")
}
if stats.Active() {
t.Error("expected stats.Active() = false when no .skillignore exists")
}
if stats.RootFile != "" {
t.Errorf("expected empty RootFile, got %q", stats.RootFile)
}
if len(stats.RepoFiles) != 0 {
t.Errorf("expected 0 repo files, got %d", len(stats.RepoFiles))
}
if stats.PatternCount() != 0 {
t.Errorf("expected 0 patterns, got %d", stats.PatternCount())
}
if stats.IgnoredCount() != 0 {
t.Errorf("expected 0 ignored skills, got %d", stats.IgnoredCount())
}
}
func TestDiscoverSourceSkillsWithStats_RootLevelSkillignore(t *testing.T) {
src := t.TempDir()
os.WriteFile(filepath.Join(src, ".skillignore"), []byte("draft-*\nhidden\n"), 0644)
writeSkillMD(t, filepath.Join(src, "draft-feature"), "---\nname: draft\n---\n")
writeSkillMD(t, filepath.Join(src, "hidden"), "---\nname: hidden\n---\n")
writeSkillMD(t, filepath.Join(src, "visible"), "---\nname: visible\n---\n")
skills, stats, err := DiscoverSourceSkillsWithStats(src)
if err != nil {
t.Fatal(err)
}
// Only visible should be discovered
if len(skills) != 1 {
t.Fatalf("expected 1 skill, got %d", len(skills))
}
if skills[0].FlatName != "visible" {
t.Errorf("expected 'visible', got %q", skills[0].FlatName)
}
// Stats checks
if stats == nil {
t.Fatal("expected non-nil stats")
}
if !stats.Active() {
t.Error("expected stats.Active() = true")
}
if stats.RootFile == "" {
t.Error("expected RootFile to be set")
}
if !strings.HasSuffix(stats.RootFile, ".skillignore") {
t.Errorf("expected RootFile ending with .skillignore, got %q", stats.RootFile)
}
if stats.PatternCount() != 2 {
t.Errorf("expected 2 patterns (draft-*, hidden), got %d: %v", stats.PatternCount(), stats.Patterns)
}
// Both draft-feature and hidden should be in ignored list
if stats.IgnoredCount() != 2 {
t.Errorf("expected 2 ignored skills, got %d: %v", stats.IgnoredCount(), stats.IgnoredSkills)
}
ignoredSet := map[string]bool{}
for _, p := range stats.IgnoredSkills {
ignoredSet[p] = true
}
if !ignoredSet["draft-feature"] {
t.Error("expected draft-feature in ignored skills")
}
if !ignoredSet["hidden"] {
t.Error("expected hidden in ignored skills")
}
}