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 }