Files
Willie 5e02ef7ef0 refactor(sync): select a target's skills through SelectTargetSkills
Status, doctor, diff, the dashboard's target and diff handlers and analyze each
repeated FilterSkills followed by FilterSkillsByTarget, and only some dropped
disabled skills first. Routing them through SelectTargetSkills keeps their
answers identical to sync and mcp serve when a selection rule changes.

The callers that did not drop disabled skills get discoveries without them, so
their output does not change.
2026-10-06 14:18:20 +08:00

133 lines
4.2 KiB
Go

package sync
import (
"os"
"path/filepath"
"strings"
"skillshare/internal/config"
"skillshare/internal/utils"
)
// TargetSkills returns the skills a target actually loads, for analyze and
// context-cost reports.
//
// A symlink-mode target exposes the whole source folder, so every discovered
// skill counts, .skillignore'd ones included (pass a discovery that keeps them,
// such as DiscoverSourceSkillsForAnalyze). Any other mode gets the enabled
// skills its include/exclude and `targets:` filters let through, plus the
// skills that already live in the target folder without coming from the
// source (Local), which the tool loads just the same.
func TargetSkills(name string, target config.TargetConfig, defaultMode, sourcePath string, discovered []DiscoveredSkill) ([]DiscoveredSkill, error) {
sc := target.SkillsConfig()
if !sc.IsEnabled() {
// Nothing is synced, but the tool still loads whatever the folder holds.
return folderSkills(sc.Path, sourcePath, discovered), nil
}
mode := sc.Mode
if mode == "" {
mode = defaultMode
}
if mode == "symlink" {
return discovered, nil
}
skills, err := SelectTargetSkills(discovered, name, sc)
if err != nil {
return nil, err
}
return append(skills, localTargetSkills(sc.Path, sourcePath)...), nil
}
// localTargetSkills finds skills that sit in targetPath as real folders but are
// not managed by skillshare: merge mode links source skills, so a real folder
// is local; copy mode records its copies in the manifest, so anything missing
// from it is local. Errors mean "nothing to report" — the target folder may
// not exist yet.
func localTargetSkills(targetPath, sourcePath string) []DiscoveredSkill {
if targetPath == "" || sourcePath == "" {
return nil
}
info, err := os.Stat(targetPath)
if err != nil || !info.IsDir() || utils.ResolveSymlink(targetPath) == utils.ResolveSymlink(sourcePath) {
return nil
}
manifest, err := ReadManifest(targetPath)
if err != nil {
return nil
}
// filepath.Walk does not follow symlinks, so merge-mode links never yield a SKILL.md.
found, _, _, err := discoverSourceSkillsInternal(targetPath, discoverOptions{collectContext: true})
if err != nil {
return nil
}
var local []DiscoveredSkill
for _, s := range found {
top, _, _ := strings.Cut(s.RelPath, "/")
if _, managed := manifest.Managed[s.RelPath]; managed {
continue
}
if _, managed := manifest.Managed[top]; managed {
continue
}
s.Local = true
s.Targets = nil // a folder the tool already reads is loaded whatever its path implies
local = append(local, s)
}
return local
}
// folderSkills lists every skill a target folder holds with skills off: links
// into the source that another target sharing the folder keeps, copies left
// from copy mode, and local skills. None of it is synced for this target, but
// the tool loads it all.
func folderSkills(targetPath, sourcePath string, discovered []DiscoveredSkill) []DiscoveredSkill {
if targetPath == "" || sourcePath == "" {
return nil
}
info, err := os.Stat(targetPath)
if err != nil || !info.IsDir() {
return nil
}
absSource, err := filepath.Abs(sourcePath)
if err != nil {
return nil
}
// The whole folder links to the source (symlink mode kept by another target).
if utils.ResolveSymlink(targetPath) == utils.ResolveSymlink(absSource) {
return discovered
}
byFlat := make(map[string]DiscoveredSkill, len(discovered))
for _, s := range discovered {
byFlat[s.FlatName] = s
}
var skills []DiscoveredSkill
entries, _ := os.ReadDir(targetPath)
for _, e := range entries {
path := filepath.Join(targetPath, e.Name())
if e.Type()&os.ModeSymlink == 0 || !linksIntoSource(path, absSource) {
continue
}
if s, ok := byFlat[e.Name()]; ok {
skills = append(skills, s)
}
}
// Real folders: copies and local skills alike (filepath.Walk skips the links above).
managedSet := map[string]string{}
if m, err := ReadManifest(targetPath); err == nil {
managedSet = m.Managed
}
found, _, _, err := discoverSourceSkillsInternal(targetPath, discoverOptions{collectContext: true})
if err != nil {
return skills
}
for _, s := range found {
top, _, _ := strings.Cut(s.RelPath, "/")
_, managed := managedSet[top]
s.Local = !managed
s.Targets = nil
skills = append(skills, s)
}
return skills
}