Files
skillshare/internal/sync/sync.go
T
Willie f2017a35aa feat: fix tracked repo discovery, improve naming, and unify project list
Sync discovery (DiscoverSourceSkills) was skipping all hidden directories
via utils.IsHidden(), causing skills inside .curated/ and .system/ (like
openai/skills) to be invisible after install. Now only .git is skipped,
matching the install-time discovery that was already fixed in 8ec5306.

Tracked repo naming now uses owner-repo format (e.g., _openai-skills
instead of _skills) via new Source.TrackName() method, preventing
collisions between repos that share the same basename.

Project-mode `list` command now uses recursive DiscoverSourceSkills()
instead of shallow os.ReadDir(), aligning with global list and web UI
behavior so tracked repo skills are visible everywhere.

Also includes CHANGELOG for v0.11.0, README updates, docs improvements,
and minor UI nav reorder.
2026-02-10 03:13:21 +08:00

635 lines
18 KiB
Go

package sync
import (
"fmt"
"io"
"os"
"path/filepath"
"strings"
"skillshare/internal/config"
"skillshare/internal/utils"
)
// DiscoveredSkill represents a skill found during recursive source directory scan.
type DiscoveredSkill struct {
SourcePath string // Full path: ~/.config/skillshare/skills/_team/frontend/ui
RelPath string // Relative path from source: _team/frontend/ui
FlatName string // Flat name for target: _team__frontend__ui
IsInRepo bool // Whether this skill is inside a tracked repo (_-prefixed directory)
}
// DiscoverSourceSkills recursively scans the source directory for skills.
// A skill is identified by the presence of a SKILL.md file.
// Returns all discovered skills with their metadata for syncing.
func DiscoverSourceSkills(sourcePath string) ([]DiscoveredSkill, error) {
var skills []DiscoveredSkill
err := filepath.Walk(sourcePath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return nil // Skip inaccessible paths
}
// Skip .git directory only — other hidden directories (e.g., .curated/, .system/)
// may contain skills (like openai/skills repo structure)
if info.IsDir() && info.Name() == ".git" {
return filepath.SkipDir
}
// Look for SKILL.md files
if !info.IsDir() && info.Name() == "SKILL.md" {
skillDir := filepath.Dir(path)
relPath, err := filepath.Rel(sourcePath, skillDir)
if err != nil {
return nil // Skip if we can't get relative path
}
// Skip root level (source directory itself)
if relPath == "." {
return nil
}
// Normalize path separators
relPath = strings.ReplaceAll(relPath, "\\", "/")
// Check if this skill is inside a tracked repo
isInRepo := false
parts := strings.Split(relPath, "/")
if len(parts) > 0 && utils.IsTrackedRepoDir(parts[0]) {
isInRepo = true
}
skills = append(skills, DiscoveredSkill{
SourcePath: skillDir,
RelPath: relPath,
FlatName: utils.PathToFlatName(relPath),
IsInRepo: isInRepo,
})
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to walk source directory: %w", err)
}
return skills, nil
}
// TargetStatus represents the state of a target
type TargetStatus int
const (
StatusUnknown TargetStatus = iota
StatusLinked // Target is a symlink pointing to source
StatusNotExist // Target doesn't exist
StatusHasFiles // Target exists with files (needs migration)
StatusConflict // Target is a symlink pointing elsewhere
StatusBroken // Target is a broken symlink
StatusMerged // Target uses merge mode (individual skill symlinks)
)
func (s TargetStatus) String() string {
switch s {
case StatusLinked:
return "linked"
case StatusNotExist:
return "not exist"
case StatusHasFiles:
return "has files"
case StatusConflict:
return "conflict"
case StatusBroken:
return "broken"
case StatusMerged:
return "merged"
default:
return "unknown"
}
}
// CheckStatus checks the status of a target
func CheckStatus(targetPath, sourcePath string) TargetStatus {
info, err := os.Lstat(targetPath)
if err != nil {
if os.IsNotExist(err) {
return StatusNotExist
}
return StatusUnknown
}
// Check if it's a symlink/junction
if utils.IsSymlinkOrJunction(targetPath) {
absLink, err := utils.ResolveLinkTarget(targetPath)
if err != nil {
return StatusUnknown
}
// Check if link points to our source
absSource, _ := filepath.Abs(sourcePath)
if utils.PathsEqual(absLink, absSource) {
// Verify the link is not broken
if _, err := os.Stat(targetPath); err != nil {
return StatusBroken
}
return StatusLinked
}
return StatusConflict
}
// It's a directory with files
if info.IsDir() {
return StatusHasFiles
}
return StatusUnknown
}
// MigrateToSource moves files from target to source, then creates symlink
func MigrateToSource(targetPath, sourcePath string) error {
// Ensure source parent directory exists
if err := os.MkdirAll(filepath.Dir(sourcePath), 0755); err != nil {
return fmt.Errorf("failed to create source parent: %w", err)
}
// Check if source already exists
if _, err := os.Stat(sourcePath); err == nil {
// Source exists - merge files
if err := mergeDirectories(targetPath, sourcePath); err != nil {
return fmt.Errorf("failed to merge directories: %w", err)
}
// Remove original target
if err := os.RemoveAll(targetPath); err != nil {
return fmt.Errorf("failed to remove target after merge: %w", err)
}
} else {
// Source doesn't exist - just move
if err := os.Rename(targetPath, sourcePath); err != nil {
// Cross-device? Try copy then delete
if err := copyDirectory(targetPath, sourcePath); err != nil {
return fmt.Errorf("failed to copy to source: %w", err)
}
if err := os.RemoveAll(targetPath); err != nil {
return fmt.Errorf("failed to remove original after copy: %w", err)
}
}
}
return nil
}
// CreateSymlink creates a symlink (or junction on Windows) from target to source
func CreateSymlink(targetPath, sourcePath string) error {
// Ensure target parent exists
if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
return fmt.Errorf("failed to create target parent: %w", err)
}
// Create link (uses junction on Windows, symlink on Unix)
if err := createLink(targetPath, sourcePath); err != nil {
return fmt.Errorf("failed to create link: %w", err)
}
return nil
}
// SyncTarget performs the sync operation for a single target
func SyncTarget(name string, target config.TargetConfig, sourcePath string, dryRun bool) error {
status := CheckStatus(target.Path, sourcePath)
switch status {
case StatusLinked:
// Already correct
return nil
case StatusNotExist:
if dryRun {
fmt.Printf("[dry-run] Would create symlink: %s -> %s\n", target.Path, sourcePath)
return nil
}
return CreateSymlink(target.Path, sourcePath)
case StatusHasFiles:
if dryRun {
fmt.Printf("[dry-run] Would migrate files from %s to %s, then create symlink\n", target.Path, sourcePath)
return nil
}
if err := MigrateToSource(target.Path, sourcePath); err != nil {
return err
}
return CreateSymlink(target.Path, sourcePath)
case StatusConflict:
link, err := utils.ResolveLinkTarget(target.Path)
if err != nil {
link = "(unable to resolve target)"
}
return fmt.Errorf("target is symlink to different location: %s -> %s", target.Path, link)
case StatusBroken:
if dryRun {
fmt.Printf("[dry-run] Would remove broken symlink and recreate: %s\n", target.Path)
return nil
}
os.Remove(target.Path)
return CreateSymlink(target.Path, sourcePath)
default:
return fmt.Errorf("unknown target status: %s", status)
}
}
// mergeDirectories copies files from src to dst, skipping existing files
func mergeDirectories(src, dst string) error {
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, _ := filepath.Rel(src, path)
dstPath := filepath.Join(dst, relPath)
if info.IsDir() {
return os.MkdirAll(dstPath, info.Mode())
}
// Skip if destination exists
if _, err := os.Stat(dstPath); err == nil {
fmt.Printf(" skip (exists): %s\n", relPath)
return nil
}
return copyFile(path, dstPath)
})
}
// copyDirectory copies a directory recursively
func copyDirectory(src, dst string) error {
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, _ := filepath.Rel(src, path)
dstPath := filepath.Join(dst, relPath)
if info.IsDir() {
return os.MkdirAll(dstPath, info.Mode())
}
return copyFile(path, dstPath)
})
}
// copyFile copies a single file
func copyFile(src, dst string) error {
srcFile, err := os.Open(src)
if err != nil {
return err
}
defer srcFile.Close()
srcInfo, err := srcFile.Stat()
if err != nil {
return err
}
dstFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, srcInfo.Mode())
if err != nil {
return err
}
defer dstFile.Close()
_, err = io.Copy(dstFile, srcFile)
return err
}
// MergeResult holds the result of a merge sync operation
type MergeResult struct {
Linked []string // Skills that were symlinked
Skipped []string // Skills that already exist in target (kept local)
Updated []string // Skills that had broken symlinks fixed
}
// SyncTargetMerge performs merge mode sync - creates symlinks for each skill individually
// while preserving target-specific skills.
// 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) {
result := &MergeResult{}
// Check if target is currently a symlink/junction (symlink mode) - need to convert to merge mode
info, err := os.Lstat(target.Path)
if err == nil && info != nil && utils.IsSymlinkOrJunction(target.Path) {
// Target is a symlink - remove it to convert to merge mode
if dryRun {
fmt.Printf("[dry-run] Would convert from symlink mode to merge mode: %s\n", target.Path)
} else {
if err := os.Remove(target.Path); err != nil {
return nil, fmt.Errorf("failed to remove symlink for merge conversion: %w", err)
}
}
}
// Ensure target directory exists
if !dryRun {
if err := os.MkdirAll(target.Path, 0755); err != nil {
return nil, fmt.Errorf("failed to create target directory: %w", err)
}
}
// Discover all skills recursively from source
discoveredSkills, err := DiscoverSourceSkills(sourcePath)
if err != nil {
return nil, fmt.Errorf("failed to discover skills: %w", err)
}
for _, skill := range discoveredSkills {
// Use flat name in target (e.g., "personal__writing__email")
targetSkillPath := filepath.Join(target.Path, skill.FlatName)
// Check if skill exists in target
_, err := os.Lstat(targetSkillPath)
if err == nil {
// Something exists at target path
if utils.IsSymlinkOrJunction(targetSkillPath) {
// It's a symlink/junction - check if it points to source
absLink, err := utils.ResolveLinkTarget(targetSkillPath)
if err != nil {
return nil, fmt.Errorf("failed to resolve link target for %s: %w", skill.FlatName, err)
}
absSource, _ := filepath.Abs(skill.SourcePath)
if utils.PathsEqual(absLink, absSource) {
// Already correctly linked
result.Linked = append(result.Linked, skill.FlatName)
continue
}
// Symlink points elsewhere - broken or wrong
if dryRun {
fmt.Printf("[dry-run] Would fix symlink: %s\n", skill.FlatName)
} else {
os.Remove(targetSkillPath)
if err := createLink(targetSkillPath, skill.SourcePath); err != nil {
return nil, fmt.Errorf("failed to create link for %s: %w", skill.FlatName, err)
}
}
result.Updated = append(result.Updated, skill.FlatName)
} else {
// It's a real directory
if force {
// Force: replace local copy with symlink
if dryRun {
fmt.Printf("[dry-run] Would replace local copy: %s\n", skill.FlatName)
} else {
if err := os.RemoveAll(targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to remove local copy %s: %w", skill.FlatName, err)
}
if err := createLink(targetSkillPath, skill.SourcePath); err != nil {
return nil, fmt.Errorf("failed to create link for %s: %w", skill.FlatName, err)
}
}
result.Updated = append(result.Updated, skill.FlatName)
} else {
// Preserve local skill
result.Skipped = append(result.Skipped, skill.FlatName)
}
}
} else if os.IsNotExist(err) {
// Doesn't exist - create link
if dryRun {
fmt.Printf("[dry-run] Would create link: %s -> %s\n", targetSkillPath, skill.SourcePath)
} else {
if err := createLink(targetSkillPath, skill.SourcePath); err != nil {
return nil, fmt.Errorf("failed to create link for %s: %w", skill.FlatName, err)
}
}
result.Linked = append(result.Linked, skill.FlatName)
} else {
return nil, fmt.Errorf("failed to check target skill %s: %w", skill.FlatName, err)
}
}
return result, nil
}
// PruneResult holds the result of a prune operation
type PruneResult struct {
Removed []string // Items that were removed
Warnings []string // Items that were kept with warnings
}
// PruneOrphanLinks removes orphan symlinks from target that no longer exist in source.
// Uses a three-layer safety check:
// 1. Dead symlinks pointing to source directory -> remove
// 2. Directories with __ separator or @ prefix (skillshare-managed) -> remove if orphan
// 3. Unknown directories -> keep and warn
func PruneOrphanLinks(targetPath, sourcePath string, dryRun bool) (*PruneResult, error) {
result := &PruneResult{}
// Get current valid skills from source
discoveredSkills, err := DiscoverSourceSkills(sourcePath)
if err != nil {
return nil, fmt.Errorf("failed to discover skills for pruning: %w", err)
}
// Build a set of valid flat names
validFlatNames := make(map[string]bool)
for _, skill := range discoveredSkills {
validFlatNames[skill.FlatName] = true
}
// Scan target directory
entries, err := os.ReadDir(targetPath)
if err != nil {
if os.IsNotExist(err) {
return result, nil // Target doesn't exist, nothing to prune
}
return nil, fmt.Errorf("failed to read target directory: %w", err)
}
absSource, _ := filepath.Abs(sourcePath)
for _, entry := range entries {
name := entry.Name()
// Skip hidden files
if utils.IsHidden(name) {
continue
}
entryPath := filepath.Join(targetPath, name)
info, err := os.Lstat(entryPath)
if err != nil {
continue
}
// Check if this entry is still valid
if validFlatNames[name] {
continue // Still exists in source, keep it
}
// Entry is orphan - determine if we should remove it
shouldRemove := false
reason := ""
if utils.IsSymlinkOrJunction(entryPath) {
absLink, err := utils.ResolveLinkTarget(entryPath)
if err != nil {
result.Warnings = append(result.Warnings,
fmt.Sprintf("%s: unable to resolve link target, kept", name))
continue
}
targetExists := false
if _, err := os.Stat(absLink); err == nil {
targetExists = true
}
if strings.HasPrefix(absLink, absSource+string(filepath.Separator)) {
if !targetExists {
shouldRemove = true
reason = "broken symlink to source"
} else {
shouldRemove = true
reason = "orphan symlink to source"
}
} else {
result.Warnings = append(result.Warnings,
fmt.Sprintf("%s: symlink to external location (%s), kept", name, absLink))
}
} else if info.IsDir() {
// It's a directory - check naming characteristics
// Safety check 2: Only remove if it has skillshare naming patterns
if utils.HasNestedSeparator(name) || utils.IsTrackedRepoDir(name) {
shouldRemove = true
reason = "orphan skillshare-managed directory"
} else {
// Safety check 3: Unknown directory - warn and keep
result.Warnings = append(result.Warnings,
fmt.Sprintf("%s: unknown directory (not from skillshare), kept", name))
}
}
if shouldRemove {
if dryRun {
fmt.Printf("[dry-run] Would remove %s: %s\n", reason, entryPath)
} else {
if err := os.RemoveAll(entryPath); err != nil {
result.Warnings = append(result.Warnings,
fmt.Sprintf("%s: failed to remove: %v", name, err))
continue
}
}
result.Removed = append(result.Removed, name)
}
}
return result, nil
}
// NameCollision represents a conflict where multiple skills share the same name
type NameCollision struct {
Name string // The conflicting SKILL.md name
Paths []string // All paths that have this name
}
// CheckNameCollisions detects skills with duplicate names in SKILL.md.
// Returns a list of collisions (skills that share the same name).
func CheckNameCollisions(skills []DiscoveredSkill) []NameCollision {
// Map: skill name -> list of paths
nameMap := make(map[string][]string)
for _, skill := range skills {
// Parse the actual name from SKILL.md
name, err := utils.ParseSkillName(skill.SourcePath)
if err != nil || name == "" {
continue // Skip if we can't parse or no name
}
nameMap[name] = append(nameMap[name], skill.RelPath)
}
// Find collisions (names with multiple paths)
var collisions []NameCollision
for name, paths := range nameMap {
if len(paths) > 1 {
collisions = append(collisions, NameCollision{
Name: name,
Paths: paths,
})
}
}
return collisions
}
// CheckStatusMerge checks the status of a target in merge mode
func CheckStatusMerge(targetPath, sourcePath string) (TargetStatus, int, int) {
// Returns: status, linked count, local count
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/junction to source, it's using symlink mode not merge
if utils.IsSymlinkOrJunction(targetPath) {
absLink, err := utils.ResolveLinkTarget(targetPath)
if err != nil {
return StatusUnknown, 0, 0
}
absSource, _ := filepath.Abs(sourcePath)
if utils.PathsEqual(absLink, absSource) {
return StatusLinked, 0, 0
}
return StatusConflict, 0, 0
}
if !info.IsDir() {
return StatusUnknown, 0, 0
}
// Count linked vs local skills
linkedCount := 0
localCount := 0
entries, _ := os.ReadDir(targetPath)
for _, entry := range entries {
if utils.IsHidden(entry.Name()) {
continue
}
skillPath := filepath.Join(targetPath, entry.Name())
if utils.IsSymlinkOrJunction(skillPath) {
// It's a symlink/junction - check if it points to somewhere in source
absLink, err := utils.ResolveLinkTarget(skillPath)
if err != nil {
localCount++
continue
}
absSource, _ := filepath.Abs(sourcePath)
// Check if the symlink target is within the source directory
if utils.PathHasPrefix(absLink, absSource+string(filepath.Separator)) || utils.PathsEqual(absLink, absSource) {
linkedCount++
} else {
localCount++
}
} else {
localCount++
}
}
if linkedCount > 0 {
return StatusMerged, linkedCount, localCount
}
return StatusHasFiles, 0, localCount
}