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.
This commit is contained in:
Willie
2026-10-09 00:58:34 +08:00
parent 92f3d809c0
commit e0b930cad0
6 changed files with 44 additions and 32 deletions
+4 -1
View File
@@ -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)
+16 -17
View File
@@ -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)
}
+12 -2
View File
@@ -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").
+1 -3
View File
@@ -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
}
}
+1 -2
View File
@@ -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
}
}
+10 -7
View File
@@ -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
}