Files
skillshare/internal/sync/copy.go
T
Willie f01ec9ec12 fix(sync): summarize resolution warnings instead of printing each one
With 25000+ skipped skills (standard naming + name collisions),
the CLI sync output was flooded with per-skill warning lines.

Now prints a concise summary:
  12345 skill(s) skipped (naming validation)
  456 name collision(s) excluded

Applied to both merge and copy sync modes.
2026-04-01 00:32:49 +08:00

466 lines
14 KiB
Go

package sync
import (
"crypto/sha256"
"fmt"
"io"
"os"
"path/filepath"
"sort"
"strings"
"skillshare/internal/config"
"skillshare/internal/utils"
)
// CopyResult holds the result of a copy sync operation.
type CopyResult struct {
Copied []string // newly copied skills
Skipped []string // checksum unchanged, skipped
Updated []string // checksum changed, overwritten
DirCreated string // Non-empty if target directory was auto-created (or would be in dry-run)
}
// SyncTargetCopy performs copy mode sync — copies each skill individually
// while preserving target-specific (unmanaged) skills.
func SyncTargetCopy(name string, target config.TargetConfig, sourcePath string, dryRun, force bool) (*CopyResult, error) {
skills, err := DiscoverSourceSkills(sourcePath)
if err != nil {
return nil, fmt.Errorf("failed to discover skills: %w", err)
}
return SyncTargetCopyWithSkills(name, target, skills, sourcePath, dryRun, force, nil)
}
// SyncTargetCopyWithSkills is like SyncTargetCopy but accepts pre-discovered skills
// and an optional progress callback for per-skill UI updates.
// sourcePath is the skills source directory, used to detect symlink-mode targets.
func SyncTargetCopyWithSkills(name string, target config.TargetConfig, allSkills []DiscoveredSkill, sourcePath string, dryRun, force bool, onProgress func(current, total int, skill string)) (*CopyResult, error) {
sc := target.SkillsConfig()
result := &CopyResult{}
// Convert from symlink mode if needed, auto-create if missing.
dirCreated, err := ensureRealTargetDir(sc.Path, sourcePath, "copy", dryRun)
if err != nil {
return nil, err
}
if dirCreated {
result.DirCreated = sc.Path
}
// When dry-run would create the directory, suppress per-skill diagnostic
// messages (they flood the terminal). Counts are still populated.
quietDryRun := dirCreated && dryRun
resolution, err := ResolveTargetSkillsForTarget(name, target.SkillsConfig(), allSkills)
if err != nil {
return nil, err
}
if n := len(resolution.Warnings); n > 0 {
fmt.Fprintf(DiagOutput, " %d skill(s) skipped (naming validation)\n", n)
}
if n := len(resolution.Collisions); n > 0 {
fmt.Fprintf(DiagOutput, " %d name collision(s) excluded\n", n)
}
// Read existing manifest
manifest, err := ReadManifest(sc.Path)
if err != nil {
return nil, fmt.Errorf("failed to read manifest: %w", err)
}
for i, resolved := range resolution.Skills {
skill := resolved.Skill
activeName, err := selectActiveTargetNameForSync("copy", sc.Path, resolved, manifest, dryRun)
if err != nil {
return nil, err
}
if onProgress != nil {
onProgress(i+1, len(resolution.Skills), activeName)
}
targetSkillPath := filepath.Join(sc.Path, activeName)
// Compute source mtime for fast-path skip
currentMtime, mtimeErr := DirMaxMtime(skill.SourcePath)
// mtime fast-path: if source mtime is unchanged AND target is still a valid dir, skip checksum
oldChecksum, isManaged := manifest.Managed[activeName]
oldMtime := manifest.Mtimes[activeName] // 0 if missing
if mtimeErr == nil && isManaged && !force && oldMtime > 0 && currentMtime == oldMtime {
// Verify target still exists as a directory (user may have replaced it)
if ti, err := os.Lstat(targetSkillPath); err == nil && ti.IsDir() {
result.Skipped = append(result.Skipped, activeName)
continue
}
}
// mtime changed or no record — compute full checksum
srcChecksum, err := DirChecksum(skill.SourcePath)
if err != nil {
return nil, fmt.Errorf("failed to checksum source skill %s: %w", activeName, err)
}
// Check what exists at the target path
targetInfo, lstatErr := os.Lstat(targetSkillPath)
exists := lstatErr == nil
if exists {
// If it's a symlink (leftover from merge mode), remove it
if utils.IsSymlinkOrJunction(targetSkillPath) {
if dryRun {
if !quietDryRun {
fmt.Fprintf(DiagOutput, "[dry-run] Would replace symlink with copy: %s\n", activeName)
}
} else {
os.Remove(targetSkillPath)
}
// Fall through to copy below
} else {
// Non-directory entries are invalid for managed skills.
// Managed/forced entries should be replaced with a proper skill directory.
if !targetInfo.IsDir() {
if isManaged || force {
if dryRun {
if !quietDryRun {
fmt.Fprintf(DiagOutput, "[dry-run] Would replace non-directory entry with copy: %s\n", activeName)
}
} else {
if err := os.RemoveAll(targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to remove invalid entry %s: %w", activeName, err)
}
if err := copyDirectory(skill.SourcePath, targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err)
}
manifest.Managed[activeName] = srcChecksum
if mtimeErr == nil {
manifest.Mtimes[activeName] = currentMtime
}
}
result.Updated = append(result.Updated, activeName)
continue
}
// Local non-directory entry — preserve unless --force.
result.Skipped = append(result.Skipped, activeName)
continue
}
if !force && isManaged && oldChecksum == srcChecksum {
// Unchanged — skip (but update mtime record if it changed)
if mtimeErr == nil && currentMtime != oldMtime && !dryRun {
manifest.Mtimes[activeName] = currentMtime
}
result.Skipped = append(result.Skipped, activeName)
continue
}
if isManaged || force {
// Managed or forced — overwrite
if dryRun {
if !quietDryRun {
fmt.Fprintf(DiagOutput, "[dry-run] Would update copy: %s\n", activeName)
}
} else {
if err := os.RemoveAll(targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to remove old copy %s: %w", activeName, err)
}
}
if !dryRun {
if err := copyDirectory(skill.SourcePath, targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err)
}
manifest.Managed[activeName] = srcChecksum
if mtimeErr == nil {
manifest.Mtimes[activeName] = currentMtime
}
}
result.Updated = append(result.Updated, activeName)
continue
}
// Not managed (local skill) — preserve
result.Skipped = append(result.Skipped, activeName)
continue
}
}
// Copy skill to target
if dryRun {
if !quietDryRun {
fmt.Fprintf(DiagOutput, "[dry-run] Would copy: %s -> %s\n", skill.SourcePath, targetSkillPath)
}
} else {
if err := copyDirectory(skill.SourcePath, targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to copy skill %s: %w", activeName, err)
}
manifest.Managed[activeName] = srcChecksum
if mtimeErr == nil {
manifest.Mtimes[activeName] = currentMtime
}
}
result.Copied = append(result.Copied, activeName)
}
// Write updated manifest
if !dryRun {
if err := WriteManifest(sc.Path, manifest); err != nil {
return nil, fmt.Errorf("failed to write manifest: %w", err)
}
}
return result, nil
}
// PruneOrphanCopies removes managed copies that no longer exist in source.
func PruneOrphanCopies(targetPath, sourcePath string, include, exclude []string, targetName, targetNaming string, dryRun bool) (*PruneResult, error) {
allSourceSkills, err := DiscoverSourceSkills(sourcePath)
if err != nil {
return nil, fmt.Errorf("failed to discover skills for pruning: %w", err)
}
return PruneOrphanCopiesWithSkills(targetPath, allSourceSkills, include, exclude, targetName, targetNaming, dryRun)
}
// PruneOrphanCopiesWithSkills is like PruneOrphanCopies but accepts pre-discovered skills.
func PruneOrphanCopiesWithSkills(targetPath string, allSourceSkills []DiscoveredSkill, include, exclude []string, targetName, targetNaming string, dryRun bool) (*PruneResult, error) {
result := &PruneResult{}
manifest, err := ReadManifest(targetPath)
if err != nil {
return nil, fmt.Errorf("failed to read manifest: %w", err)
}
resolution, err := ResolveTargetSkillsForTarget(targetName, config.ResourceTargetConfig{
Path: targetPath,
TargetNaming: targetNaming,
Include: include,
Exclude: exclude,
}, allSourceSkills)
if err != nil {
return nil, err
}
validTargetNames := resolution.ValidTargetNames()
legacyNames := resolution.LegacyFlatNames()
// Remove manifest entries that are no longer in source
for entryName := range manifest.Managed {
if validTargetNames[entryName] {
continue
}
if _, keepLegacy := legacyNames[entryName]; keepLegacy {
continue
}
entryPath := filepath.Join(targetPath, entryName)
if dryRun {
fmt.Fprintf(DiagOutput, "[dry-run] Would remove orphan copy: %s\n", entryPath)
} else {
if err := os.RemoveAll(entryPath); err != nil {
result.Warnings = append(result.Warnings,
fmt.Sprintf("%s: failed to remove: %v", entryName, err))
continue
}
delete(manifest.Managed, entryName)
delete(manifest.Mtimes, entryName)
}
result.Removed = append(result.Removed, entryName)
}
// Write updated manifest (only if we actually removed something)
if !dryRun && len(result.Removed) > 0 {
if err := WriteManifest(targetPath, manifest); err != nil {
return result, fmt.Errorf("failed to write manifest: %w", err)
}
}
return result, nil
}
// CheckStatusCopy checks the status of a target in copy mode.
// Returns: status, managed count, local count.
func CheckStatusCopy(targetPath string) (TargetStatus, int, int) {
info, err := os.Lstat(targetPath)
if err != nil {
if os.IsNotExist(err) {
return StatusNotExist, 0, 0
}
return StatusUnknown, 0, 0
}
// If it's a symlink, it's using symlink mode, not copy
if utils.IsSymlinkOrJunction(targetPath) {
return StatusLinked, 0, 0
}
if !info.IsDir() {
return StatusUnknown, 0, 0
}
manifest, err := ReadManifest(targetPath)
if err != nil {
return StatusUnknown, 0, 0
}
// Count managed entries that actually exist on disk
managedCount := 0
for name := range manifest.Managed {
if info, err := os.Stat(filepath.Join(targetPath, name)); err == nil && info.IsDir() {
managedCount++
}
}
// Count local (non-managed) entries
localCount := 0
entries, _ := os.ReadDir(targetPath)
for _, entry := range entries {
if utils.IsHidden(entry.Name()) {
continue
}
if !entry.IsDir() {
continue
}
if _, isManaged := manifest.Managed[entry.Name()]; !isManaged {
localCount++
}
}
if managedCount > 0 || len(manifest.Managed) > 0 {
return StatusCopied, managedCount, localCount
}
return StatusHasFiles, 0, localCount
}
// DirMaxMtime returns the latest ModTime (UnixNano) among all files in dir.
// Skips .git directories. Only uses os.Stat (via filepath.Walk), never reads file content.
func DirMaxMtime(dir string) (int64, error) {
var maxMtime int64
hasSymlink := false
err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
if info.Name() == ".git" {
return filepath.SkipDir
}
return nil
}
// Symlink targets can change without updating the link mtime.
// Disable mtime fast-path for symlink-containing skills.
if info.Mode()&os.ModeSymlink != 0 {
hasSymlink = true
return nil
}
if mt := info.ModTime().UnixNano(); mt > maxMtime {
maxMtime = mt
}
return nil
})
if err != nil {
return 0, err
}
if hasSymlink {
return 0, fmt.Errorf("mtime fast-path not supported for directories containing symlinks")
}
return maxMtime, nil
}
// DirChecksum computes a deterministic SHA256 checksum of a directory.
// It hashes sorted relative paths and file contents.
func DirChecksum(dir string) (string, error) {
var entries []checksumEntry
err := collectChecksumEntries(dir, "", &entries, map[string]bool{})
if err != nil {
return "", err
}
// Sort for deterministic output
sort.Slice(entries, func(i, j int) bool {
return entries[i].relPath < entries[j].relPath
})
h := sha256.New()
for _, e := range entries {
io.WriteString(h, e.relPath)
h.Write([]byte{0}) // separator
h.Write(e.content)
h.Write([]byte{0}) // separator
}
return fmt.Sprintf("%x", h.Sum(nil)), nil
}
type checksumEntry struct {
relPath string
content []byte
}
// collectChecksumEntries recursively collects file entries for checksumming.
// Directory symlinks are dereferenced to hash effective copied content.
func collectChecksumEntries(root, relPrefix string, entries *[]checksumEntry, active map[string]bool) error {
resolvedRoot, err := filepath.EvalSymlinks(root)
if err != nil {
return fmt.Errorf("failed to resolve checksum root %s: %w", root, err)
}
if active[resolvedRoot] {
return fmt.Errorf("detected symlink directory cycle while checksumming: %s", root)
}
active[resolvedRoot] = true
defer delete(active, resolvedRoot)
return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
// Skip .git directories
if info.Name() == ".git" {
return filepath.SkipDir
}
return nil
}
relPath, err := filepath.Rel(root, path)
if err != nil {
return err
}
// Normalize path separators for cross-platform consistency
relPath = strings.ReplaceAll(relPath, "\\", "/")
if relPath == "." {
relPath = ""
}
fullRelPath := relPath
if relPrefix != "" {
if fullRelPath == "" {
fullRelPath = relPrefix
} else {
fullRelPath = relPrefix + "/" + fullRelPath
}
}
// A symlink can point to a directory. In copy mode we dereference
// directory symlinks, so checksum should include effective contents.
if info.Mode()&os.ModeSymlink != 0 {
targetInfo, statErr := os.Stat(path)
if statErr != nil {
return fmt.Errorf("failed to stat symlink target %s: %w", path, statErr)
}
if targetInfo.IsDir() {
resolvedDir, resolveErr := filepath.EvalSymlinks(path)
if resolveErr != nil {
return fmt.Errorf("failed to resolve symlink directory %s: %w", path, resolveErr)
}
return collectChecksumEntries(resolvedDir, fullRelPath, entries, active)
}
}
content, err := os.ReadFile(path)
if err != nil {
return err
}
*entries = append(*entries, checksumEntry{relPath: fullRelPath, content: content})
return nil
})
}