mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 12:23:22 +00:00
perf(sync): cache discovery + add progress UI for sync operations
DiscoverSourceSkills was called 1+2N times (N = number of targets),
each doing a full filepath.Walk + SKILL.md frontmatter parsing.
Now discovered once and passed to all targets via WithSkills variants.
Changes:
- Add SyncTargetMergeWithSkills, PruneOrphanLinksWithSkills (PruneOptions struct)
- Add SyncTargetCopyWithSkills with onProgress callback, PruneOrphanCopiesWithSkills
- Discovery spinner + per-target reporting + summary line in CLI
- Copy mode shows per-skill spinner progress during slow checksum+copy
- Collision report uses dim gray text to avoid confusion with sync results
- Server handlers (handleSync, handlePull) use single discovery pass
- Fix pre-existing TestLog_StatsOutput assertion ("Success rate" → "OK:")
This commit is contained in:
+144
-21
@@ -23,6 +23,11 @@ type syncLogStats struct {
|
||||
ProjectScope bool
|
||||
}
|
||||
|
||||
// syncModeStats aggregates per-target sync results for UI summary.
|
||||
type syncModeStats struct {
|
||||
linked, local, updated, pruned int
|
||||
}
|
||||
|
||||
func cmdSync(args []string) error {
|
||||
start := time.Now()
|
||||
|
||||
@@ -70,29 +75,51 @@ func cmdSync(args []string) error {
|
||||
backupTargetsBeforeSync(cfg)
|
||||
}
|
||||
|
||||
// Check for name collisions before syncing (per-target aware)
|
||||
// Phase 1: Discovery — spinner
|
||||
spinner := ui.StartSpinner("Discovering skills")
|
||||
discoveredSkills, discoverErr := sync.DiscoverSourceSkills(cfg.Source)
|
||||
if discoverErr == nil {
|
||||
reportCollisions(discoveredSkills, cfg.Targets)
|
||||
if discoverErr != nil {
|
||||
spinner.Fail("Discovery failed")
|
||||
return discoverErr
|
||||
}
|
||||
spinner.Success(fmt.Sprintf("Discovered %d skills", len(discoveredSkills)))
|
||||
reportCollisions(discoveredSkills, cfg.Targets)
|
||||
|
||||
// Phase 2: Per-target sync
|
||||
ui.Header("Syncing skills")
|
||||
if dryRun {
|
||||
ui.Warning("Dry run mode - no changes will be made")
|
||||
}
|
||||
|
||||
failedTargets := 0
|
||||
var totals syncModeStats
|
||||
for name, target := range cfg.Targets {
|
||||
if err := syncTarget(name, target, cfg, dryRun, force); err != nil {
|
||||
stats, err := syncTargetWithSkillsStats(name, target, cfg, discoveredSkills, dryRun, force)
|
||||
if err != nil {
|
||||
ui.Error("%s: %v", name, err)
|
||||
failedTargets++
|
||||
}
|
||||
totals.linked += stats.linked
|
||||
totals.local += stats.local
|
||||
totals.updated += stats.updated
|
||||
totals.pruned += stats.pruned
|
||||
}
|
||||
|
||||
var syncErr error
|
||||
if failedTargets > 0 {
|
||||
syncErr = fmt.Errorf("some targets failed to sync")
|
||||
}
|
||||
|
||||
// Phase 3: Summary
|
||||
ui.SyncSummary(ui.SyncStats{
|
||||
Targets: len(cfg.Targets),
|
||||
Linked: totals.linked,
|
||||
Local: totals.local,
|
||||
Updated: totals.updated,
|
||||
Pruned: totals.pruned,
|
||||
Duration: time.Since(start),
|
||||
})
|
||||
|
||||
// Opportunistic cleanup of expired trash items
|
||||
if !dryRun {
|
||||
if n, _ := trash.Cleanup(trash.TrashDir(), 0); n > 0 {
|
||||
@@ -179,19 +206,66 @@ func syncTarget(name string, target config.TargetConfig, cfg *config.Config, dry
|
||||
}
|
||||
}
|
||||
|
||||
func syncTargetWithSkills(name string, target config.TargetConfig, cfg *config.Config, skills []sync.DiscoveredSkill, dryRun, force bool) error {
|
||||
_, err := syncTargetWithSkillsStats(name, target, cfg, skills, dryRun, force)
|
||||
return err
|
||||
}
|
||||
|
||||
func syncTargetWithSkillsStats(name string, target config.TargetConfig, cfg *config.Config, skills []sync.DiscoveredSkill, dryRun, force bool) (syncModeStats, error) {
|
||||
mode := target.Mode
|
||||
if mode == "" {
|
||||
mode = cfg.Mode
|
||||
}
|
||||
if mode == "" {
|
||||
mode = "merge"
|
||||
}
|
||||
|
||||
switch mode {
|
||||
case "merge":
|
||||
return syncMergeModeWithSkills(name, target, cfg.Source, skills, dryRun, force)
|
||||
case "copy":
|
||||
return syncCopyModeWithSkills(name, target, cfg.Source, skills, dryRun, force)
|
||||
default:
|
||||
err := syncSymlinkMode(name, target, cfg.Source, dryRun, force)
|
||||
return syncModeStats{}, err
|
||||
}
|
||||
}
|
||||
|
||||
func syncMergeMode(name string, target config.TargetConfig, source string, dryRun, force bool) error {
|
||||
result, err := sync.SyncTargetMerge(name, target, source, dryRun, force)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Prune orphan links (skills that no longer exist in source)
|
||||
pruneResult, pruneErr := sync.PruneOrphanLinks(target.Path, source, target.Include, target.Exclude, name, dryRun, force)
|
||||
if pruneErr != nil {
|
||||
ui.Warning("%s: prune failed: %v", name, pruneErr)
|
||||
}
|
||||
|
||||
// Report results
|
||||
reportMergeResult(name, target, result, pruneResult)
|
||||
return nil
|
||||
}
|
||||
|
||||
func syncMergeModeWithSkills(name string, target config.TargetConfig, source string, skills []sync.DiscoveredSkill, dryRun, force bool) (syncModeStats, error) {
|
||||
result, err := sync.SyncTargetMergeWithSkills(name, target, skills, dryRun, force)
|
||||
if err != nil {
|
||||
return syncModeStats{}, err
|
||||
}
|
||||
|
||||
pruneResult, pruneErr := sync.PruneOrphanLinksWithSkills(sync.PruneOptions{
|
||||
TargetPath: target.Path, SourcePath: source, Skills: skills,
|
||||
Include: target.Include, Exclude: target.Exclude, TargetName: name,
|
||||
DryRun: dryRun, Force: force,
|
||||
})
|
||||
if pruneErr != nil {
|
||||
ui.Warning("%s: prune failed: %v", name, pruneErr)
|
||||
}
|
||||
|
||||
reportMergeResult(name, target, result, pruneResult)
|
||||
return mergeStats(result, pruneResult), nil
|
||||
}
|
||||
|
||||
func reportMergeResult(name string, target config.TargetConfig, result *sync.MergeResult, pruneResult *sync.PruneResult) {
|
||||
linkedCount := len(result.Linked)
|
||||
updatedCount := len(result.Updated)
|
||||
skippedCount := len(result.Skipped)
|
||||
@@ -210,7 +284,6 @@ func syncMergeMode(name string, target config.TargetConfig, source string, dryRu
|
||||
ui.Success("%s: merged (no skills)", name)
|
||||
}
|
||||
|
||||
// Show filter summary (omit empty, human-readable)
|
||||
if len(target.Include) > 0 {
|
||||
ui.Info(" include: %s", strings.Join(target.Include, ", "))
|
||||
}
|
||||
@@ -218,14 +291,11 @@ func syncMergeMode(name string, target config.TargetConfig, source string, dryRu
|
||||
ui.Info(" exclude: %s", strings.Join(target.Exclude, ", "))
|
||||
}
|
||||
|
||||
// Show prune warnings
|
||||
if pruneResult != nil {
|
||||
for _, warn := range pruneResult.Warnings {
|
||||
ui.Warning(" %s", warn)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func syncCopyMode(name string, target config.TargetConfig, source string, dryRun, force bool) error {
|
||||
@@ -234,13 +304,64 @@ func syncCopyMode(name string, target config.TargetConfig, source string, dryRun
|
||||
return err
|
||||
}
|
||||
|
||||
// Prune orphan copies
|
||||
pruneResult, pruneErr := sync.PruneOrphanCopies(target.Path, source, target.Include, target.Exclude, name, dryRun)
|
||||
if pruneErr != nil {
|
||||
ui.Warning("%s: prune failed: %v", name, pruneErr)
|
||||
}
|
||||
|
||||
// Report results
|
||||
reportCopyResult(name, target, result, pruneResult)
|
||||
return nil
|
||||
}
|
||||
|
||||
func syncCopyModeWithSkills(name string, target config.TargetConfig, source string, skills []sync.DiscoveredSkill, dryRun, force bool) (syncModeStats, error) {
|
||||
// Copy mode is slow (checksum + file copy per skill) — show a spinner with progress
|
||||
spinner := ui.StartSpinner(fmt.Sprintf("%s: copying skills", name))
|
||||
onProgress := func(cur, total int, skill string) {
|
||||
spinner.Update(fmt.Sprintf("%s: %d/%d %s", name, cur, total, skill))
|
||||
}
|
||||
|
||||
result, err := sync.SyncTargetCopyWithSkills(name, target, skills, dryRun, force, onProgress)
|
||||
if err != nil {
|
||||
spinner.Fail(fmt.Sprintf("%s: copy failed", name))
|
||||
return syncModeStats{}, err
|
||||
}
|
||||
spinner.Stop()
|
||||
|
||||
pruneResult, pruneErr := sync.PruneOrphanCopiesWithSkills(target.Path, skills, target.Include, target.Exclude, name, dryRun)
|
||||
if pruneErr != nil {
|
||||
ui.Warning("%s: prune failed: %v", name, pruneErr)
|
||||
}
|
||||
|
||||
reportCopyResult(name, target, result, pruneResult)
|
||||
return copyStats(result, pruneResult), nil
|
||||
}
|
||||
|
||||
func mergeStats(result *sync.MergeResult, prune *sync.PruneResult) syncModeStats {
|
||||
s := syncModeStats{
|
||||
linked: len(result.Linked),
|
||||
local: len(result.Skipped),
|
||||
updated: len(result.Updated),
|
||||
}
|
||||
if prune != nil {
|
||||
s.pruned = len(prune.Removed)
|
||||
s.local += len(prune.LocalDirs)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func copyStats(result *sync.CopyResult, prune *sync.PruneResult) syncModeStats {
|
||||
s := syncModeStats{
|
||||
linked: len(result.Copied),
|
||||
local: len(result.Skipped),
|
||||
updated: len(result.Updated),
|
||||
}
|
||||
if prune != nil {
|
||||
s.pruned = len(prune.Removed)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func reportCopyResult(name string, target config.TargetConfig, result *sync.CopyResult, pruneResult *sync.PruneResult) {
|
||||
copiedCount := len(result.Copied)
|
||||
updatedCount := len(result.Updated)
|
||||
skippedCount := len(result.Skipped)
|
||||
@@ -258,7 +379,6 @@ func syncCopyMode(name string, target config.TargetConfig, source string, dryRun
|
||||
ui.Success("%s: copied (no skills)", name)
|
||||
}
|
||||
|
||||
// Show filter summary
|
||||
if len(target.Include) > 0 {
|
||||
ui.Info(" include: %s", strings.Join(target.Include, ", "))
|
||||
}
|
||||
@@ -266,14 +386,11 @@ func syncCopyMode(name string, target config.TargetConfig, source string, dryRun
|
||||
ui.Info(" exclude: %s", strings.Join(target.Exclude, ", "))
|
||||
}
|
||||
|
||||
// Show prune warnings
|
||||
if pruneResult != nil {
|
||||
for _, warn := range pruneResult.Warnings {
|
||||
ui.Warning(" %s", warn)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func reportCollisions(skills []sync.DiscoveredSkill, targets map[string]config.TargetConfig) {
|
||||
@@ -296,12 +413,18 @@ func reportCollisions(skills []sync.DiscoveredSkill, targets map[string]config.T
|
||||
ui.Info("Rename one in SKILL.md or adjust include/exclude filters")
|
||||
fmt.Println()
|
||||
} else {
|
||||
// Global collision exists but filters isolate them — informational
|
||||
ui.Info("Duplicate skill names exist but are isolated by target filters:")
|
||||
for _, c := range global {
|
||||
ui.Info(" '%s' (%d definitions)", c.Name, len(c.Paths))
|
||||
// Global collision exists but filters isolate them — dim list
|
||||
const maxShow = 50
|
||||
fmt.Printf("\n%s%d duplicate skill names (isolated by target filters)%s\n",
|
||||
ui.Gray, len(global), ui.Reset)
|
||||
fmt.Println(ui.Gray + "─────────────────────────────────────────" + ui.Reset)
|
||||
for i, c := range global {
|
||||
if i >= maxShow {
|
||||
fmt.Printf("%s ... and %d more%s\n", ui.Gray, len(global)-maxShow, ui.Reset)
|
||||
break
|
||||
}
|
||||
fmt.Printf("%s '%s' (%d definitions)%s\n", ui.Gray, c.Name, len(c.Paths), ui.Reset)
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@ package main
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"skillshare/internal/config"
|
||||
"skillshare/internal/sync"
|
||||
@@ -11,6 +12,7 @@ import (
|
||||
)
|
||||
|
||||
func cmdSyncProject(root string, dryRun, force bool) (syncLogStats, error) {
|
||||
start := time.Now()
|
||||
stats := syncLogStats{
|
||||
DryRun: dryRun,
|
||||
Force: force,
|
||||
@@ -33,17 +35,24 @@ func cmdSyncProject(root string, dryRun, force bool) (syncLogStats, error) {
|
||||
return stats, fmt.Errorf("source directory does not exist: %s", runtime.sourcePath)
|
||||
}
|
||||
|
||||
// Phase 1: Discovery — spinner
|
||||
spinner := ui.StartSpinner("Discovering skills")
|
||||
discoveredSkills, discoverErr := sync.DiscoverSourceSkills(runtime.sourcePath)
|
||||
if discoverErr == nil {
|
||||
reportCollisions(discoveredSkills, runtime.targets)
|
||||
if discoverErr != nil {
|
||||
spinner.Fail("Discovery failed")
|
||||
return stats, discoverErr
|
||||
}
|
||||
spinner.Success(fmt.Sprintf("Discovered %d skills", len(discoveredSkills)))
|
||||
reportCollisions(discoveredSkills, runtime.targets)
|
||||
|
||||
// Phase 2: Per-target sync
|
||||
ui.Header("Syncing skills (project)")
|
||||
if dryRun {
|
||||
ui.Warning("Dry run mode - no changes will be made")
|
||||
}
|
||||
|
||||
failedTargets := 0
|
||||
var totals syncModeStats
|
||||
for _, entry := range runtime.config.Targets {
|
||||
name := entry.Name
|
||||
target, ok := runtime.targets[name]
|
||||
@@ -58,21 +67,37 @@ func cmdSyncProject(root string, dryRun, force bool) (syncLogStats, error) {
|
||||
mode = "merge"
|
||||
}
|
||||
|
||||
var s syncModeStats
|
||||
var syncErr error
|
||||
switch mode {
|
||||
case "symlink":
|
||||
syncErr = syncSymlinkMode(name, target, runtime.sourcePath, dryRun, force)
|
||||
case "copy":
|
||||
syncErr = syncCopyMode(name, target, runtime.sourcePath, dryRun, force)
|
||||
s, syncErr = syncCopyModeWithSkills(name, target, runtime.sourcePath, discoveredSkills, dryRun, force)
|
||||
default:
|
||||
syncErr = syncMergeMode(name, target, runtime.sourcePath, dryRun, force)
|
||||
s, syncErr = syncMergeModeWithSkills(name, target, runtime.sourcePath, discoveredSkills, dryRun, force)
|
||||
}
|
||||
if syncErr != nil {
|
||||
ui.Error("%s: %v", name, syncErr)
|
||||
failedTargets++
|
||||
}
|
||||
totals.linked += s.linked
|
||||
totals.local += s.local
|
||||
totals.updated += s.updated
|
||||
totals.pruned += s.pruned
|
||||
}
|
||||
stats.Failed = failedTargets
|
||||
|
||||
// Phase 3: Summary
|
||||
ui.SyncSummary(ui.SyncStats{
|
||||
Targets: len(runtime.config.Targets),
|
||||
Linked: totals.linked,
|
||||
Local: totals.local,
|
||||
Updated: totals.updated,
|
||||
Pruned: totals.pruned,
|
||||
Duration: time.Since(start),
|
||||
})
|
||||
|
||||
if failedTargets > 0 {
|
||||
return stats, fmt.Errorf("some targets failed to sync")
|
||||
}
|
||||
|
||||
@@ -218,6 +218,9 @@ func (s *Server) handlePull(w http.ResponseWriter, r *http.Request) {
|
||||
globalMode = "merge"
|
||||
}
|
||||
|
||||
// Discover skills once for all targets
|
||||
allSkills, discoverErr := ssync.DiscoverSourceSkills(src)
|
||||
|
||||
for name, target := range s.cfg.Targets {
|
||||
mode := target.Mode
|
||||
if mode == "" {
|
||||
@@ -232,18 +235,38 @@ func (s *Server) handlePull(w http.ResponseWriter, r *http.Request) {
|
||||
Pruned: make([]string, 0),
|
||||
}
|
||||
|
||||
if mode == "merge" {
|
||||
mergeResult, err := ssync.SyncTargetMerge(name, target, src, false, false)
|
||||
if discoverErr != nil {
|
||||
resp.SyncResults = append(resp.SyncResults, res)
|
||||
continue
|
||||
}
|
||||
|
||||
switch mode {
|
||||
case "merge":
|
||||
mergeResult, err := ssync.SyncTargetMergeWithSkills(name, target, allSkills, false, false)
|
||||
if err == nil {
|
||||
res.Linked = mergeResult.Linked
|
||||
res.Updated = mergeResult.Updated
|
||||
res.Skipped = mergeResult.Skipped
|
||||
}
|
||||
pruneResult, err := ssync.PruneOrphanLinks(target.Path, src, target.Include, target.Exclude, name, false, false)
|
||||
pruneResult, err := ssync.PruneOrphanLinksWithSkills(ssync.PruneOptions{
|
||||
TargetPath: target.Path, SourcePath: src, Skills: allSkills,
|
||||
Include: target.Include, Exclude: target.Exclude, TargetName: name,
|
||||
})
|
||||
if err == nil {
|
||||
res.Pruned = pruneResult.Removed
|
||||
}
|
||||
} else {
|
||||
case "copy":
|
||||
copyResult, err := ssync.SyncTargetCopyWithSkills(name, target, allSkills, false, false, nil)
|
||||
if err == nil {
|
||||
res.Linked = copyResult.Copied
|
||||
res.Updated = copyResult.Updated
|
||||
res.Skipped = copyResult.Skipped
|
||||
}
|
||||
pruneResult, err := ssync.PruneOrphanCopiesWithSkills(target.Path, allSkills, target.Include, target.Exclude, name, false)
|
||||
if err == nil {
|
||||
res.Pruned = pruneResult.Removed
|
||||
}
|
||||
default:
|
||||
ssync.SyncTarget(name, target, src, false)
|
||||
res.Linked = []string{"(symlink mode)"}
|
||||
}
|
||||
|
||||
@@ -37,6 +37,13 @@ func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
|
||||
globalMode = "merge"
|
||||
}
|
||||
|
||||
// Discover skills once for all targets
|
||||
allSkills, err := ssync.DiscoverSourceSkills(s.cfg.Source)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
results := make([]syncTargetResult, 0)
|
||||
|
||||
for name, target := range s.cfg.Targets {
|
||||
@@ -64,7 +71,7 @@ func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
switch mode {
|
||||
case "merge":
|
||||
mergeResult, err := ssync.SyncTargetMerge(name, target, s.cfg.Source, body.DryRun, body.Force)
|
||||
mergeResult, err := ssync.SyncTargetMergeWithSkills(name, target, allSkills, body.DryRun, body.Force)
|
||||
if err != nil {
|
||||
s.writeOpsLog("sync", "error", start, syncErrArgs, err.Error())
|
||||
writeError(w, http.StatusInternalServerError, "sync failed for "+name+": "+err.Error())
|
||||
@@ -74,13 +81,17 @@ func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
|
||||
res.Updated = mergeResult.Updated
|
||||
res.Skipped = mergeResult.Skipped
|
||||
|
||||
pruneResult, err := ssync.PruneOrphanLinks(target.Path, s.cfg.Source, target.Include, target.Exclude, name, body.DryRun, body.Force)
|
||||
pruneResult, err := ssync.PruneOrphanLinksWithSkills(ssync.PruneOptions{
|
||||
TargetPath: target.Path, SourcePath: s.cfg.Source, Skills: allSkills,
|
||||
Include: target.Include, Exclude: target.Exclude, TargetName: name,
|
||||
DryRun: body.DryRun, Force: body.Force,
|
||||
})
|
||||
if err == nil {
|
||||
res.Pruned = pruneResult.Removed
|
||||
}
|
||||
|
||||
case "copy":
|
||||
copyResult, err := ssync.SyncTargetCopy(name, target, s.cfg.Source, body.DryRun, body.Force)
|
||||
copyResult, err := ssync.SyncTargetCopyWithSkills(name, target, allSkills, body.DryRun, body.Force, nil)
|
||||
if err != nil {
|
||||
s.writeOpsLog("sync", "error", start, syncErrArgs, err.Error())
|
||||
writeError(w, http.StatusInternalServerError, "sync failed for "+name+": "+err.Error())
|
||||
@@ -90,7 +101,7 @@ func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
|
||||
res.Updated = copyResult.Updated
|
||||
res.Skipped = copyResult.Skipped
|
||||
|
||||
pruneResult, err := ssync.PruneOrphanCopies(target.Path, s.cfg.Source, target.Include, target.Exclude, name, body.DryRun)
|
||||
pruneResult, err := ssync.PruneOrphanCopiesWithSkills(target.Path, allSkills, target.Include, target.Exclude, name, body.DryRun)
|
||||
if err == nil {
|
||||
res.Pruned = pruneResult.Removed
|
||||
}
|
||||
|
||||
+26
-12
@@ -23,6 +23,16 @@ type CopyResult struct {
|
||||
// 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, dryRun, force, nil)
|
||||
}
|
||||
|
||||
// SyncTargetCopyWithSkills is like SyncTargetCopy but accepts pre-discovered skills
|
||||
// and an optional progress callback for per-skill UI updates.
|
||||
func SyncTargetCopyWithSkills(name string, target config.TargetConfig, allSkills []DiscoveredSkill, dryRun, force bool, onProgress func(current, total int, skill string)) (*CopyResult, error) {
|
||||
result := &CopyResult{}
|
||||
|
||||
// If target is currently a symlink (symlink mode), remove it to convert
|
||||
@@ -44,12 +54,8 @@ func SyncTargetCopy(name string, target config.TargetConfig, sourcePath string,
|
||||
}
|
||||
}
|
||||
|
||||
// Discover and filter source skills
|
||||
discoveredSkills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills: %w", err)
|
||||
}
|
||||
discoveredSkills, err = FilterSkills(discoveredSkills, target.Include, target.Exclude)
|
||||
// Filter skills for this target
|
||||
discoveredSkills, err := FilterSkills(allSkills, target.Include, target.Exclude)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to apply filters for target %s: %w", name, err)
|
||||
}
|
||||
@@ -61,7 +67,11 @@ func SyncTargetCopy(name string, target config.TargetConfig, sourcePath string,
|
||||
return nil, fmt.Errorf("failed to read manifest: %w", err)
|
||||
}
|
||||
|
||||
for _, skill := range discoveredSkills {
|
||||
for i, skill := range discoveredSkills {
|
||||
if onProgress != nil {
|
||||
onProgress(i+1, len(discoveredSkills), skill.FlatName)
|
||||
}
|
||||
|
||||
targetSkillPath := filepath.Join(target.Path, skill.FlatName)
|
||||
|
||||
// Compute source checksum
|
||||
@@ -165,6 +175,15 @@ func SyncTargetCopy(name string, target config.TargetConfig, sourcePath string,
|
||||
|
||||
// PruneOrphanCopies removes managed copies that no longer exist in source.
|
||||
func PruneOrphanCopies(targetPath, sourcePath string, include, exclude []string, targetName 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, dryRun)
|
||||
}
|
||||
|
||||
// PruneOrphanCopiesWithSkills is like PruneOrphanCopies but accepts pre-discovered skills.
|
||||
func PruneOrphanCopiesWithSkills(targetPath string, allSourceSkills []DiscoveredSkill, include, exclude []string, targetName string, dryRun bool) (*PruneResult, error) {
|
||||
result := &PruneResult{}
|
||||
|
||||
manifest, err := ReadManifest(targetPath)
|
||||
@@ -172,11 +191,6 @@ func PruneOrphanCopies(targetPath, sourcePath string, include, exclude []string,
|
||||
return nil, fmt.Errorf("failed to read manifest: %w", err)
|
||||
}
|
||||
|
||||
// Discover current source skills
|
||||
allSourceSkills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills for pruning: %w", err)
|
||||
}
|
||||
managedSkills, err := FilterSkills(allSourceSkills, include, exclude)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to apply filters for pruning: %w", err)
|
||||
|
||||
+51
-11
@@ -403,6 +403,16 @@ type MergeResult struct {
|
||||
// Supports nested skills: source path "personal/writing/email" becomes target symlink "personal__writing__email"
|
||||
// If force is true, local copies will be replaced with symlinks.
|
||||
func SyncTargetMerge(name string, target config.TargetConfig, sourcePath string, dryRun, force bool) (*MergeResult, error) {
|
||||
skills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills: %w", err)
|
||||
}
|
||||
return SyncTargetMergeWithSkills(name, target, skills, dryRun, force)
|
||||
}
|
||||
|
||||
// SyncTargetMergeWithSkills is like SyncTargetMerge but accepts pre-discovered skills,
|
||||
// avoiding redundant filesystem walks when syncing multiple targets.
|
||||
func SyncTargetMergeWithSkills(name string, target config.TargetConfig, allSkills []DiscoveredSkill, dryRun, force bool) (*MergeResult, error) {
|
||||
result := &MergeResult{}
|
||||
|
||||
// Check if target is currently a symlink/junction (symlink mode) - need to convert to merge mode
|
||||
@@ -425,12 +435,8 @@ func SyncTargetMerge(name string, target config.TargetConfig, sourcePath string,
|
||||
}
|
||||
}
|
||||
|
||||
// Discover all skills recursively from source
|
||||
discoveredSkills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills: %w", err)
|
||||
}
|
||||
discoveredSkills, err = FilterSkills(discoveredSkills, target.Include, target.Exclude)
|
||||
// Filter skills for this target
|
||||
discoveredSkills, err := FilterSkills(allSkills, target.Include, target.Exclude)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to apply filters for target %s: %w", name, err)
|
||||
}
|
||||
@@ -526,23 +532,57 @@ type PruneResult struct {
|
||||
LocalDirs []string // User-created directories not managed by skillshare
|
||||
}
|
||||
|
||||
// PruneOptions holds parameters for PruneOrphanLinks / PruneOrphanCopies.
|
||||
type PruneOptions struct {
|
||||
TargetPath string
|
||||
SourcePath string
|
||||
Skills []DiscoveredSkill // pre-discovered; if nil, will be discovered from SourcePath
|
||||
Include []string
|
||||
Exclude []string
|
||||
TargetName string
|
||||
DryRun bool
|
||||
Force bool
|
||||
}
|
||||
|
||||
// PruneOrphanLinks removes target entries that are no longer managed by sync.
|
||||
// This includes:
|
||||
// 1. Source-linked entries excluded by include/exclude filters (remove from target)
|
||||
// 2. Orphan links/directories that no longer exist in source
|
||||
// 3. Unknown local directories (kept with warning)
|
||||
func PruneOrphanLinks(targetPath, sourcePath string, include, exclude []string, targetName string, dryRun, force bool) (*PruneResult, error) {
|
||||
allSourceSkills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills for pruning: %w", err)
|
||||
}
|
||||
return PruneOrphanLinksWithSkills(PruneOptions{
|
||||
TargetPath: targetPath,
|
||||
SourcePath: sourcePath,
|
||||
Skills: allSourceSkills,
|
||||
Include: include,
|
||||
Exclude: exclude,
|
||||
TargetName: targetName,
|
||||
DryRun: dryRun,
|
||||
Force: force,
|
||||
})
|
||||
}
|
||||
|
||||
// PruneOrphanLinksWithSkills is like PruneOrphanLinks but accepts pre-discovered skills
|
||||
// via PruneOptions, avoiding redundant filesystem walks.
|
||||
func PruneOrphanLinksWithSkills(opts PruneOptions) (*PruneResult, error) {
|
||||
targetPath := opts.TargetPath
|
||||
sourcePath := opts.SourcePath
|
||||
allSourceSkills := opts.Skills
|
||||
include := opts.Include
|
||||
exclude := opts.Exclude
|
||||
targetName := opts.TargetName
|
||||
dryRun := opts.DryRun
|
||||
force := opts.Force
|
||||
result := &PruneResult{}
|
||||
|
||||
// Read manifest for managed-directory detection (may be empty/absent)
|
||||
manifest, _ := ReadManifest(targetPath)
|
||||
manifestChanged := false
|
||||
|
||||
// Discover all skills from source, then filter to target-managed skills.
|
||||
allSourceSkills, err := DiscoverSourceSkills(sourcePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to discover skills for pruning: %w", err)
|
||||
}
|
||||
managedSkills, err := FilterSkills(allSourceSkills, include, exclude)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to apply filters for pruning: %w", err)
|
||||
|
||||
+11
-45
@@ -422,67 +422,33 @@ func UpdateNotification(currentVersion, latestVersion string) {
|
||||
box.Println(content)
|
||||
}
|
||||
|
||||
// SyncSummary prints a beautiful sync summary box
|
||||
// SyncSummary prints a sync summary line.
|
||||
func SyncSummary(stats SyncStats) {
|
||||
fmt.Println() // spacing
|
||||
|
||||
if !IsTTY() {
|
||||
fmt.Printf("\n─── Sync Complete ───\n")
|
||||
fmt.Printf(" Targets: %d Linked: %d Local: %d Updated: %d Pruned: %d\n",
|
||||
fmt.Printf("Sync complete: %d targets, %d linked, %d local, %d updated, %d pruned",
|
||||
stats.Targets, stats.Linked, stats.Local, stats.Updated, stats.Pruned)
|
||||
if stats.Duration > 0 {
|
||||
fmt.Printf(" Duration: %.1fs\n", stats.Duration.Seconds())
|
||||
fmt.Printf(" (%.1fs)", stats.Duration.Seconds())
|
||||
}
|
||||
fmt.Println()
|
||||
return
|
||||
}
|
||||
|
||||
// Build stats line with colors
|
||||
statsLine := fmt.Sprintf(
|
||||
" %s targets %s linked %s local %s updated %s pruned",
|
||||
line := fmt.Sprintf(
|
||||
"%s %s targets %s linked %s local %s updated %s pruned",
|
||||
pterm.Green("✓ Sync complete"),
|
||||
pterm.Cyan(fmt.Sprint(stats.Targets)),
|
||||
pterm.Green(fmt.Sprint(stats.Linked)),
|
||||
pterm.Blue(fmt.Sprint(stats.Local)),
|
||||
pterm.Yellow(fmt.Sprint(stats.Updated)),
|
||||
pterm.Gray(fmt.Sprint(stats.Pruned)),
|
||||
)
|
||||
|
||||
var durationLine string
|
||||
if stats.Duration > 0 {
|
||||
durationLine = fmt.Sprintf(" Completed in %s", pterm.Gray(fmt.Sprintf("%.1fs", stats.Duration.Seconds())))
|
||||
line += fmt.Sprintf(" %s", pterm.Gray(fmt.Sprintf("(%.1fs)", stats.Duration.Seconds())))
|
||||
}
|
||||
|
||||
// Build content with proper padding
|
||||
lines := []string{"", statsLine}
|
||||
if durationLine != "" {
|
||||
lines = append(lines, durationLine)
|
||||
}
|
||||
lines = append(lines, "")
|
||||
|
||||
// Find max display width
|
||||
maxLen := 0
|
||||
for _, line := range lines {
|
||||
w := displayWidth(line)
|
||||
if w > maxLen {
|
||||
maxLen = w
|
||||
}
|
||||
}
|
||||
|
||||
// Pad lines
|
||||
var content strings.Builder
|
||||
for i, line := range lines {
|
||||
padded := line
|
||||
w := displayWidth(line)
|
||||
if w < maxLen {
|
||||
padded = line + strings.Repeat(" ", maxLen-w)
|
||||
}
|
||||
content.WriteString(padded)
|
||||
if i < len(lines)-1 {
|
||||
content.WriteString("\n")
|
||||
}
|
||||
}
|
||||
|
||||
box := pterm.DefaultBox.
|
||||
WithTitle(pterm.Green("✓ Sync Complete")).
|
||||
WithBoxStyle(pterm.NewStyle(pterm.FgGreen))
|
||||
box.Println(content.String())
|
||||
fmt.Println(line)
|
||||
}
|
||||
|
||||
// SyncStats holds statistics for sync summary
|
||||
|
||||
@@ -461,7 +461,7 @@ targets:
|
||||
result.AssertSuccess(t)
|
||||
result.AssertOutputContains(t, "Operation Log Summary")
|
||||
result.AssertOutputContains(t, "sync")
|
||||
result.AssertOutputContains(t, "Success rate")
|
||||
result.AssertOutputContains(t, "OK:")
|
||||
}
|
||||
|
||||
func TestLog_CheckCreatesEntry(t *testing.T) {
|
||||
|
||||
Reference in New Issue
Block a user