package sync import ( "fmt" "io" "os" "path/filepath" "skillshare/internal/config" "skillshare/internal/utils" ) // 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 if info.Mode()&os.ModeSymlink != 0 { link, err := os.Readlink(targetPath) if err != nil { return StatusUnknown } // Check if symlink points to our source absLink := link if !filepath.IsAbs(link) { absLink = filepath.Join(filepath.Dir(targetPath), link) } absSource, _ := filepath.Abs(sourcePath) absLink, _ = filepath.Abs(absLink) if 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 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 symlink if err := os.Symlink(sourcePath, targetPath); err != nil { return fmt.Errorf("failed to create symlink: %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, _ := os.Readlink(target.Path) 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 func SyncTargetMerge(name string, target config.TargetConfig, sourcePath string, dryRun bool) (*MergeResult, error) { result := &MergeResult{} // Check if target is currently a symlink (symlink mode) - need to convert to merge mode info, err := os.Lstat(target.Path) if err == nil && info.Mode()&os.ModeSymlink != 0 { // 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) } } // Read skills from source sourceEntries, err := os.ReadDir(sourcePath) if err != nil { return nil, fmt.Errorf("failed to read source directory: %w", err) } for _, entry := range sourceEntries { // Skip hidden files/directories if utils.IsHidden(entry.Name()) { continue } // Only process directories (skills are directories) if !entry.IsDir() { continue } skillName := entry.Name() sourceSkillPath := filepath.Join(sourcePath, skillName) targetSkillPath := filepath.Join(target.Path, skillName) // Check if skill exists in target targetInfo, err := os.Lstat(targetSkillPath) if err == nil { // Something exists at target path if targetInfo.Mode()&os.ModeSymlink != 0 { // It's a symlink - check if it points to source link, _ := os.Readlink(targetSkillPath) absLink, _ := filepath.Abs(link) absSource, _ := filepath.Abs(sourceSkillPath) if absLink == absSource { // Already correctly linked result.Linked = append(result.Linked, skillName) continue } // Symlink points elsewhere - broken or wrong if dryRun { fmt.Printf("[dry-run] Would fix symlink: %s\n", skillName) } else { os.Remove(targetSkillPath) if err := os.Symlink(sourceSkillPath, targetSkillPath); err != nil { return nil, fmt.Errorf("failed to create symlink for %s: %w", skillName, err) } } result.Updated = append(result.Updated, skillName) } else { // It's a real directory - skip (preserve local skill) result.Skipped = append(result.Skipped, skillName) } } else if os.IsNotExist(err) { // Doesn't exist - create symlink if dryRun { fmt.Printf("[dry-run] Would create symlink: %s -> %s\n", targetSkillPath, sourceSkillPath) } else { if err := os.Symlink(sourceSkillPath, targetSkillPath); err != nil { return nil, fmt.Errorf("failed to create symlink for %s: %w", skillName, err) } } result.Linked = append(result.Linked, skillName) } else { return nil, fmt.Errorf("failed to check target skill %s: %w", skillName, err) } } return result, nil } // 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 to source, it's using symlink mode not merge if info.Mode()&os.ModeSymlink != 0 { link, _ := os.Readlink(targetPath) absLink, _ := filepath.Abs(link) absSource, _ := filepath.Abs(sourcePath) if 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 } if !entry.IsDir() && entry.Type()&os.ModeSymlink == 0 { continue } skillPath := filepath.Join(targetPath, entry.Name()) info, err := os.Lstat(skillPath) if err != nil { continue } if info.Mode()&os.ModeSymlink != 0 { // It's a symlink - check if it points to source link, _ := os.Readlink(skillPath) if filepath.Dir(link) == sourcePath || filepath.Dir(filepath.Join(filepath.Dir(skillPath), link)) == sourcePath { linkedCount++ } else { localCount++ } } else { localCount++ } } if linkedCount > 0 { return StatusMerged, linkedCount, localCount } return StatusHasFiles, 0, localCount }