From e0b930cad0e6a90afe5b70751f8eba10be2fbe4c Mon Sep 17 00:00:00 2001 From: Willie Date: Fri, 9 Oct 2026 00:58:34 +0800 Subject: [PATCH] refactor(sync): trim the naming migration's I/O and manifest bookkeeping The legacy lookup stat'ed the skill's current entry before looking for old names, adding syscalls to every flat sync; it now stats only the candidate names other than the current one (usually none exist) and checks the current entry only once an old managed entry is found. ReadManifest now always returns a Naming map, Manifest.Remove drops an entry's records in one place, copySkillToTarget takes the name to write instead of deciding it, and diff reads the manifest only for copy targets. --- cmd/skillshare/diff.go | 5 +++- internal/sync/copy.go | 33 ++++++++++++------------ internal/sync/manifest.go | 14 ++++++++-- internal/sync/skills_off.go | 4 +-- internal/sync/sync.go | 3 +-- internal/sync/target_naming_migration.go | 17 +++++++----- 6 files changed, 44 insertions(+), 32 deletions(-) diff --git a/cmd/skillshare/diff.go b/cmd/skillshare/diff.go index 2fda12afc..d834128e3 100644 --- a/cmd/skillshare/diff.go +++ b/cmd/skillshare/diff.go @@ -586,7 +586,10 @@ func collectTargetDiff(name string, target config.TargetConfig, source, mode str return r } - manifest, _ := sync.ReadManifest(sc.Path) + var manifest *sync.Manifest // only copy-mode legacy lookups read it + if mode == "copy" { + manifest, _ = sync.ReadManifest(sc.Path) + } legacyNames := resolution.LegacyNames(mode, sc.Path, manifest) if mode == "copy" { collectCopyDiff(&r, name, sc.Path, resolution.Skills, sourceSkills, legacyNames, manifest, ignorePatterns, dp) diff --git a/internal/sync/copy.go b/internal/sync/copy.go index e2e76ddf7..e0a78c344 100644 --- a/internal/sync/copy.go +++ b/internal/sync/copy.go @@ -97,9 +97,6 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al return nil, fmt.Errorf("failed to read manifest: %w", err) } naming := resolution.Naming - if manifest.Naming == nil { - manifest.Naming = make(map[string]string) - } taken := resolution.ValidTargetNames() for i, resolved := range resolution.Skills { @@ -126,6 +123,12 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al onDesiredName := activeName == resolved.TargetName recordedNaming := manifest.Naming[activeName] namingChanged := onDesiredName && recordedNaming != "" && recordedNaming != naming + // Under prefixed naming the copy's name: becomes the entry name, so it + // matches its folder. A legacy entry kept under its old name is copied as is. + rewriteName := "" + if naming == "prefixed" && onDesiredName && resolved.TargetName != resolved.SkillName { + rewriteName = resolved.TargetName + } recordNaming := func() { if onDesiredName && !dryRun { manifest.Naming[activeName] = naming @@ -174,7 +177,7 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al if err := os.RemoveAll(targetSkillPath); err != nil { return nil, fmt.Errorf("failed to remove invalid entry %s: %w", activeName, err) } - if err := copySkillToTarget(resolved, targetSkillPath, naming, onDesiredName, ignorePatterns); err != nil { + if err := copySkillToTarget(skill.SourcePath, targetSkillPath, rewriteName, ignorePatterns); err != nil { return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err) } manifest.Managed[activeName] = srcChecksum @@ -214,7 +217,7 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al } } if !dryRun { - if err := copySkillToTarget(resolved, targetSkillPath, naming, onDesiredName, ignorePatterns); err != nil { + if err := copySkillToTarget(skill.SourcePath, targetSkillPath, rewriteName, ignorePatterns); err != nil { return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err) } manifest.Managed[activeName] = srcChecksum @@ -239,7 +242,7 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al fmt.Fprintf(DiagOutput, "[dry-run] Would copy: %s -> %s\n", skill.SourcePath, targetSkillPath) } } else { - if err := copySkillToTarget(resolved, targetSkillPath, naming, onDesiredName, ignorePatterns); err != nil { + if err := copySkillToTarget(skill.SourcePath, targetSkillPath, rewriteName, ignorePatterns); err != nil { return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err) } manifest.Managed[activeName] = srcChecksum @@ -261,18 +264,16 @@ func SyncTargetCopyWithSkillsOptions(name string, target config.TargetConfig, al return result, nil } -// copySkillToTarget copies a skill into dst. Under prefixed naming the copy's -// name: is rewritten to the prefixed entry name, so it matches its folder; the -// source is never touched. A legacy entry kept under its old name (onDesiredName -// false) is copied as is. -func copySkillToTarget(skill ResolvedTargetSkill, dst, naming string, onDesiredName bool, ignorePatterns []string) error { - if err := copyDirectoryWithIgnore(skill.Skill.SourcePath, dst, ignorePatterns); err != nil { +// copySkillToTarget copies a skill into dst and, when newName is set, rewrites +// name: in the copied SKILL.md to it. The source is never touched. +func copySkillToTarget(src, dst, newName string, ignorePatterns []string) error { + if err := copyDirectoryWithIgnore(src, dst, ignorePatterns); err != nil { return err } - if naming != "prefixed" || !onDesiredName || skill.TargetName == skill.SkillName { + if newName == "" { return nil } - if err := utils.SetFrontmatterValue(filepath.Join(dst, "SKILL.md"), "name", skill.TargetName); err != nil { + if err := utils.SetFrontmatterValue(filepath.Join(dst, "SKILL.md"), "name", newName); err != nil { return fmt.Errorf("failed to set prefixed name: %w", err) } return nil @@ -326,9 +327,7 @@ func PruneOrphanCopiesWithSkills(targetPath string, allSourceSkills []Discovered fmt.Sprintf("%s: failed to remove: %v", entryName, err)) continue } - delete(manifest.Managed, entryName) - delete(manifest.Mtimes, entryName) - delete(manifest.Naming, entryName) + manifest.Remove(entryName) } result.Removed = append(result.Removed, entryName) } diff --git a/internal/sync/manifest.go b/internal/sync/manifest.go index 4bda0a9de..0074f5adb 100644 --- a/internal/sync/manifest.go +++ b/internal/sync/manifest.go @@ -29,7 +29,7 @@ func ReadManifest(targetPath string) (*Manifest, error) { data, err := os.ReadFile(p) if err != nil { if os.IsNotExist(err) { - return &Manifest{Managed: make(map[string]string), Mtimes: make(map[string]int64)}, nil + return &Manifest{Managed: make(map[string]string), Mtimes: make(map[string]int64), Naming: make(map[string]string)}, nil } return nil, err } @@ -37,7 +37,7 @@ func ReadManifest(targetPath string) (*Manifest, error) { var m Manifest if err := json.Unmarshal(data, &m); err != nil { // Corrupt manifest — treat as empty so next sync rebuilds it. - return &Manifest{Managed: make(map[string]string), Mtimes: make(map[string]int64)}, nil + return &Manifest{Managed: make(map[string]string), Mtimes: make(map[string]int64), Naming: make(map[string]string)}, nil } if m.Managed == nil { m.Managed = make(map[string]string) @@ -45,9 +45,19 @@ func ReadManifest(targetPath string) (*Manifest, error) { if m.Mtimes == nil { m.Mtimes = make(map[string]int64) } + if m.Naming == nil { + m.Naming = make(map[string]string) + } return &m, nil } +// Remove forgets every record of the entry name. +func (m *Manifest) Remove(name string) { + delete(m.Managed, name) + delete(m.Mtimes, name) + delete(m.Naming, name) +} + // SkipsHidden reports whether a target scan should skip name. Hidden entries // are skipped unless the manifest records them as managed (e.g. a source skill // under ".system/" synced as ".system__example"). diff --git a/internal/sync/skills_off.go b/internal/sync/skills_off.go index 58228c86f..2bb940103 100644 --- a/internal/sync/skills_off.go +++ b/internal/sync/skills_off.go @@ -104,9 +104,7 @@ func DetachSkills(targets map[string]config.TargetConfig, name, sourcePath strin } res.Removed = append(res.Removed, entryName) if _, managed := manifest.Managed[entryName]; managed { - delete(manifest.Managed, entryName) - delete(manifest.Mtimes, entryName) - delete(manifest.Naming, entryName) + manifest.Remove(entryName) manifestChanged = true } } diff --git a/internal/sync/sync.go b/internal/sync/sync.go index 784887a0c..5a971b05e 100644 --- a/internal/sync/sync.go +++ b/internal/sync/sync.go @@ -897,8 +897,7 @@ func PruneOrphanLinksWithSkills(opts PruneOptions) (*PruneResult, error) { result.Removed = append(result.Removed, name) // Track manifest changes for cleanup if _, inManifest := manifest.Managed[name]; inManifest { - delete(manifest.Managed, name) - delete(manifest.Naming, name) + manifest.Remove(name) manifestChanged = true } } diff --git a/internal/sync/target_naming_migration.go b/internal/sync/target_naming_migration.go index 732388863..3d2ce011c 100644 --- a/internal/sync/target_naming_migration.go +++ b/internal/sync/target_naming_migration.go @@ -56,14 +56,12 @@ func selectActiveTargetNameForSync(mode, targetPath string, skill ResolvedTarget // when the skill already has its current name, or the old name is one another // skill syncs to (taken), there is nothing to migrate. func findLegacyTargetEntry(mode, targetPath string, skill ResolvedTargetSkill, taken map[string]bool, manifest *Manifest) (string, string, error) { - desiredPath := filepath.Join(targetPath, skill.TargetName) - if info, err := os.Lstat(desiredPath); err == nil && isManagedTargetEntry(mode, desiredPath, info, skill, manifest, namedTarget{name: skill.TargetName}) { - return "", "", nil - } + prev := "" for _, c := range targetNameCandidates(skill.Skill) { - if c.name == "" || c.name == skill.TargetName || taken[c.name] { + if c.name == "" || c.name == prev || c.name == skill.TargetName || taken[c.name] { continue } + prev = c.name legacyPath := filepath.Join(targetPath, c.name) info, err := os.Lstat(legacyPath) if os.IsNotExist(err) { @@ -72,9 +70,14 @@ func findLegacyTargetEntry(mode, targetPath string, skill ResolvedTargetSkill, t if err != nil { return "", "", fmt.Errorf("failed to inspect legacy target entry %s: %w", c.name, err) } - if isManagedTargetEntry(mode, legacyPath, info, skill, manifest, c) { - return c.name, c.naming, nil + if !isManagedTargetEntry(mode, legacyPath, info, skill, manifest, c) { + continue } + desiredPath := filepath.Join(targetPath, skill.TargetName) + if info, err := os.Lstat(desiredPath); err == nil && isManagedTargetEntry(mode, desiredPath, info, skill, manifest, namedTarget{name: skill.TargetName}) { + return "", "", nil + } + return c.name, c.naming, nil } return "", "", nil }