From b3b7bcf0fc6514ef4b20a780adef60f5724c7935 Mon Sep 17 00:00:00 2001 From: Willie Date: Wed, 14 Jan 2026 18:09:36 +0800 Subject: [PATCH] feat: initial release of skillshare Share skills across AI CLI tools (Claude Code, Codex, Cursor, Gemini, OpenCode) with a single source directory and symlinks. Commands: - init: Initialize with source directory, auto-detect CLI tools - sync: Migrate existing skills and create symlinks - status: Show target status - target: Manage targets (add/remove/list) --- .github/workflows/release.yaml | 31 +++ .github/workflows/test.yaml | 25 +++ .gitignore | 17 ++ .goreleaser.yaml | 53 +++++ LICENSE | 21 ++ README.md | 151 ++++++++++++++ cmd/skillshare/main.go | 355 +++++++++++++++++++++++++++++++++ go.mod | 5 + go.sum | 4 + internal/config/config.go | 98 +++++++++ internal/sync/sync.go | 238 ++++++++++++++++++++++ internal/ui/ui.go | 60 ++++++ 12 files changed, 1058 insertions(+) create mode 100644 .github/workflows/release.yaml create mode 100644 .github/workflows/test.yaml create mode 100644 .gitignore create mode 100644 .goreleaser.yaml create mode 100644 LICENSE create mode 100644 README.md create mode 100644 cmd/skillshare/main.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/config/config.go create mode 100644 internal/sync/sync.go create mode 100644 internal/ui/ui.go diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 000000000..1e960b5be --- /dev/null +++ b/.github/workflows/release.yaml @@ -0,0 +1,31 @@ +name: Release + +on: + push: + tags: + - "v*" + +permissions: + contents: write + +jobs: + release: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: "1.23" + + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v6 + with: + version: latest + args: release --clean + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml new file mode 100644 index 000000000..b803e834e --- /dev/null +++ b/.github/workflows/test.yaml @@ -0,0 +1,25 @@ +name: Test + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + test: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: "1.23" + + - name: Build + run: go build -v ./... + + - name: Test + run: go test -v ./... diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..15465014c --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Binary +/skillshare +/dist/ + +# OS +.DS_Store +Thumbs.db + +# IDE +.idea/ +.vscode/ +*.swp +*.swo + +# Test +coverage.out +.claude/ diff --git a/.goreleaser.yaml b/.goreleaser.yaml new file mode 100644 index 000000000..4532e8f64 --- /dev/null +++ b/.goreleaser.yaml @@ -0,0 +1,53 @@ +version: 2 + +project_name: skillshare + +before: + hooks: + - go mod tidy + +builds: + - main: ./cmd/skillshare + binary: skillshare + env: + - CGO_ENABLED=0 + goos: + - linux + - darwin + - windows + goarch: + - amd64 + - arm64 + ldflags: + - -s -w -X main.version={{.Version}} + +archives: + - format: tar.gz + name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}" + format_overrides: + - goos: windows + format: zip + +checksum: + name_template: "checksums.txt" + +changelog: + sort: asc + filters: + exclude: + - "^docs:" + - "^test:" + - "^ci:" + +brews: + - repository: + owner: runkids + name: homebrew-tap + directory: Formula + homepage: https://github.com/runkids/skillshare + description: Share skills across AI CLI tools + license: MIT + install: | + bin.install "skillshare" + test: | + system "#{bin}/skillshare", "version" diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..24eefc7ac --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 runkids + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 000000000..3a31042a3 --- /dev/null +++ b/README.md @@ -0,0 +1,151 @@ +# skillshare + +Share skills across AI CLI tools (Claude Code, Codex CLI, Cursor, Gemini CLI, OpenCode). + +## The Problem + +Each AI CLI tool has its own skills directory: + +``` +~/.claude/skills/ +~/.codex/skills/ +~/.cursor/skills/ +~/.gemini/antigravity/skills/ +~/.config/opencode/skills/ +``` + +Keeping them in sync manually is tedious. + +## The Solution + +`skillshare` maintains a single source directory and symlinks it to all CLI tools: + +``` +~/.skills/ <- Your skills live here (single source of truth) + ├── my-skill/ + └── another-skill/ + +~/.claude/skills -> ~/.skills (symlink) +~/.codex/skills -> ~/.skills (symlink) +~/.cursor/skills -> ~/.skills (symlink) +... +``` + +## Installation + +### Using Go + +```bash +go install github.com/runkids/skillshare/cmd/skillshare@latest +``` + +### Using Homebrew (macOS/Linux) + +```bash +brew install runkids/tap/skillshare +``` + +### Download Binary + +Download from [Releases](https://github.com/runkids/skillshare/releases). + +## Quick Start + +```bash +# 1. Initialize with default source directory (~/.skills) +skillshare init + +# 2. Check detected targets +skillshare status + +# 3. Sync (migrate existing skills + create symlinks) +skillshare sync +``` + +## Usage + +### Initialize + +```bash +# Use default source (~/.skills) +skillshare init + +# Or specify custom source +skillshare init --source ~/my-skills +``` + +This will: +- Create the source directory +- Detect installed CLI tools +- Create config at `~/.config/skillshare/config.yaml` + +### Sync + +```bash +# Preview what will happen +skillshare sync --dry-run + +# Actually sync +skillshare sync +``` + +On first sync, existing skills are **migrated** to the source directory, then symlinks are created. + +### Status + +```bash +skillshare status +``` + +Shows: +- Source directory and skill count +- Each target's status (linked, has files, not exist, conflict) + +### Manage Targets + +```bash +# List targets +skillshare target list + +# Add custom target +skillshare target add myapp ~/.myapp/skills + +# Remove target +skillshare target remove myapp +``` + +## Configuration + +Config file: `~/.config/skillshare/config.yaml` + +```yaml +source: ~/.skills +mode: symlink +targets: + claude: + path: ~/.claude/skills + codex: + path: ~/.codex/skills + cursor: + path: ~/.cursor/skills + gemini: + path: ~/.gemini/antigravity/skills + opencode: + path: ~/.config/opencode/skills +ignore: + - "**/.DS_Store" + - "**/.git/**" +``` + +## How It Works + +1. **init**: Detects CLI tools and creates config +2. **sync**: + - If target has files → migrate to source, then symlink + - If target is empty/missing → just create symlink + - If already linked → skip +3. **status**: Check symlink health + +## License + +MIT diff --git a/cmd/skillshare/main.go b/cmd/skillshare/main.go new file mode 100644 index 000000000..3b4e242fd --- /dev/null +++ b/cmd/skillshare/main.go @@ -0,0 +1,355 @@ +package main + +import ( + "fmt" + "os" + "path/filepath" + + "github.com/runkids/skillshare/internal/config" + "github.com/runkids/skillshare/internal/sync" + "github.com/runkids/skillshare/internal/ui" +) + +var version = "dev" + +func main() { + if len(os.Args) < 2 { + printUsage() + os.Exit(1) + } + + cmd := os.Args[1] + args := os.Args[2:] + + var err error + switch cmd { + case "init": + err = cmdInit(args) + case "sync": + err = cmdSync(args) + case "status": + err = cmdStatus(args) + case "target": + err = cmdTarget(args) + case "version", "-v", "--version": + fmt.Printf("skillshare %s\n", version) + case "help", "-h", "--help": + printUsage() + default: + ui.Error("Unknown command: %s", cmd) + printUsage() + os.Exit(1) + } + + if err != nil { + ui.Error("%v", err) + os.Exit(1) + } +} + +func printUsage() { + fmt.Println(`skillshare - Share skills across AI CLI tools + +Usage: + skillshare [options] + +Commands: + init [--source PATH] Initialize skillshare with a source directory + sync [--dry-run] [--force] Sync skills to all targets + status Show status of all targets + target add Add a target + target remove Remove a target + target list List all targets + version Show version + help Show this help + +Examples: + skillshare init --source ~/.skills + skillshare target add claude ~/.claude/skills + skillshare sync + skillshare status`) +} + +func cmdInit(args []string) error { + home, _ := os.UserHomeDir() + sourcePath := filepath.Join(home, ".skills") // Default source + + // Parse args + for i := 0; i < len(args); i++ { + switch args[i] { + case "--source", "-s": + if i+1 >= len(args) { + return fmt.Errorf("--source requires a path argument") + } + sourcePath = args[i+1] + i++ + } + } + + // Expand ~ in path + if len(sourcePath) > 0 && sourcePath[0] == '~' { + sourcePath = filepath.Join(home, sourcePath[1:]) + } + + // Check if already initialized + if _, err := os.Stat(config.ConfigPath()); err == nil { + return fmt.Errorf("already initialized. Config at: %s", config.ConfigPath()) + } + + // Create source directory + if err := os.MkdirAll(sourcePath, 0755); err != nil { + return fmt.Errorf("failed to create source directory: %w", err) + } + + // Detect existing targets + ui.Header("Detecting CLI skills directories") + defaultTargets := config.DefaultTargets() + targets := make(map[string]config.TargetConfig) + + for name, target := range defaultTargets { + if info, err := os.Stat(target.Path); err == nil { + if info.IsDir() { + targets[name] = target + ui.Success("Found: %s (%s)", name, target.Path) + } + } else { + // Check if parent exists (CLI is installed but no skills yet) + parent := filepath.Dir(target.Path) + if _, err := os.Stat(parent); err == nil { + targets[name] = target + ui.Info("Available: %s (%s)", name, target.Path) + } + } + } + + if len(targets) == 0 { + ui.Warning("No CLI skills directories detected. You can add targets manually.") + } + + // Create config + cfg := &config.Config{ + Source: sourcePath, + Mode: "symlink", + Targets: targets, + Ignore: []string{ + "**/.DS_Store", + "**/.git/**", + }, + } + + if err := cfg.Save(); err != nil { + return err + } + + ui.Header("Initialized successfully") + ui.Success("Source: %s", sourcePath) + ui.Success("Config: %s", config.ConfigPath()) + ui.Info("Run 'skillshare sync' to sync your skills") + + return nil +} + +func cmdSync(args []string) error { + dryRun := false + force := false + + for _, arg := range args { + switch arg { + case "--dry-run", "-n": + dryRun = true + case "--force", "-f": + force = true + } + } + + cfg, err := config.Load() + if err != nil { + return err + } + + // Ensure source exists + if _, err := os.Stat(cfg.Source); os.IsNotExist(err) { + return fmt.Errorf("source directory does not exist: %s", cfg.Source) + } + + ui.Header("Syncing skills") + if dryRun { + ui.Warning("Dry run mode - no changes will be made") + } + + hasError := false + for name, target := range cfg.Targets { + status := sync.CheckStatus(target.Path, cfg.Source) + + // Handle conflicts + if status == sync.StatusConflict && !force { + link, _ := os.Readlink(target.Path) + ui.Error("%s: conflict - symlink points to %s (use --force to override)", name, link) + hasError = true + continue + } + + if status == sync.StatusConflict && force { + if !dryRun { + os.Remove(target.Path) + } + } + + if err := sync.SyncTarget(name, target, cfg.Source, dryRun); err != nil { + ui.Error("%s: %v", name, err) + hasError = true + continue + } + + switch status { + case sync.StatusLinked: + ui.Success("%s: already linked", name) + case sync.StatusNotExist: + ui.Success("%s: symlink created", name) + case sync.StatusHasFiles: + ui.Success("%s: files migrated and linked", name) + case sync.StatusBroken: + ui.Success("%s: broken link fixed", name) + case sync.StatusConflict: + ui.Success("%s: conflict resolved (forced)", name) + } + } + + if hasError { + return fmt.Errorf("some targets failed to sync") + } + + return nil +} + +func cmdStatus(args []string) error { + cfg, err := config.Load() + if err != nil { + return err + } + + ui.Header("Source") + if info, err := os.Stat(cfg.Source); err == nil { + entries, _ := os.ReadDir(cfg.Source) + skillCount := 0 + for _, e := range entries { + if e.IsDir() && e.Name()[0] != '.' { + skillCount++ + } + } + ui.Success("%s (%d skills, %s)", cfg.Source, skillCount, info.ModTime().Format("2006-01-02 15:04")) + } else { + ui.Error("%s (not found)", cfg.Source) + } + + ui.Header("Targets") + for name, target := range cfg.Targets { + status := sync.CheckStatus(target.Path, cfg.Source) + detail := target.Path + + switch status { + case sync.StatusConflict: + link, _ := os.Readlink(target.Path) + detail = fmt.Sprintf("%s -> %s", target.Path, link) + } + + ui.Status(name, status.String(), detail) + } + + return nil +} + +func cmdTarget(args []string) error { + if len(args) < 1 { + return fmt.Errorf("usage: skillshare target [args]") + } + + subcmd := args[0] + subargs := args[1:] + + switch subcmd { + case "add": + return targetAdd(subargs) + case "remove", "rm": + return targetRemove(subargs) + case "list", "ls": + return targetList() + default: + return fmt.Errorf("unknown target subcommand: %s", subcmd) + } +} + +func targetAdd(args []string) error { + if len(args) < 2 { + return fmt.Errorf("usage: skillshare target add ") + } + + name := args[0] + path := args[1] + + // Expand ~ + if len(path) > 0 && path[0] == '~' { + home, _ := os.UserHomeDir() + path = filepath.Join(home, path[1:]) + } + + cfg, err := config.Load() + if err != nil { + return err + } + + if _, exists := cfg.Targets[name]; exists { + return fmt.Errorf("target '%s' already exists", name) + } + + cfg.Targets[name] = config.TargetConfig{Path: path} + if err := cfg.Save(); err != nil { + return err + } + + ui.Success("Added target: %s -> %s", name, path) + return nil +} + +func targetRemove(args []string) error { + if len(args) < 1 { + return fmt.Errorf("usage: skillshare target remove ") + } + + name := args[0] + + cfg, err := config.Load() + if err != nil { + return err + } + + if _, exists := cfg.Targets[name]; !exists { + return fmt.Errorf("target '%s' not found", name) + } + + delete(cfg.Targets, name) + if err := cfg.Save(); err != nil { + return err + } + + ui.Success("Removed target: %s", name) + return nil +} + +func targetList() error { + cfg, err := config.Load() + if err != nil { + return err + } + + ui.Header("Configured Targets") + for name, target := range cfg.Targets { + mode := target.Mode + if mode == "" { + mode = "symlink" + } + fmt.Printf(" %-12s %s (%s)\n", name, target.Path, mode) + } + + return nil +} diff --git a/go.mod b/go.mod new file mode 100644 index 000000000..da560a32c --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module github.com/runkids/skillshare + +go 1.25.5 + +require gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum new file mode 100644 index 000000000..a62c313c5 --- /dev/null +++ b/go.sum @@ -0,0 +1,4 @@ +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 000000000..2f5a84f3b --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,98 @@ +package config + +import ( + "fmt" + "os" + "path/filepath" + + "gopkg.in/yaml.v3" +) + +// TargetConfig holds configuration for a single target +type TargetConfig struct { + Path string `yaml:"path"` + Mode string `yaml:"mode,omitempty"` // symlink (default), copy +} + +// Config holds the application configuration +type Config struct { + Source string `yaml:"source"` + Mode string `yaml:"mode,omitempty"` // default mode: symlink + Targets map[string]TargetConfig `yaml:"targets"` + Ignore []string `yaml:"ignore,omitempty"` +} + +// DefaultTargets returns the well-known CLI skills directories +func DefaultTargets() map[string]TargetConfig { + home, _ := os.UserHomeDir() + return map[string]TargetConfig{ + "claude": {Path: filepath.Join(home, ".claude", "skills")}, + "codex": {Path: filepath.Join(home, ".codex", "skills")}, + "cursor": {Path: filepath.Join(home, ".cursor", "skills")}, + "gemini": {Path: filepath.Join(home, ".gemini", "antigravity", "skills")}, + "opencode": {Path: filepath.Join(home, ".config", "opencode", "skills")}, + } +} + +// ConfigPath returns the default config file path +func ConfigPath() string { + home, _ := os.UserHomeDir() + return filepath.Join(home, ".config", "skillshare", "config.yaml") +} + +// Load reads the config from the default location +func Load() (*Config, error) { + path := ConfigPath() + data, err := os.ReadFile(path) + if err != nil { + if os.IsNotExist(err) { + return nil, fmt.Errorf("config not found: run 'skillshare init' first") + } + return nil, fmt.Errorf("failed to read config: %w", err) + } + + var cfg Config + if err := yaml.Unmarshal(data, &cfg); err != nil { + return nil, fmt.Errorf("failed to parse config: %w", err) + } + + // Expand ~ in paths + cfg.Source = expandPath(cfg.Source) + for name, target := range cfg.Targets { + target.Path = expandPath(target.Path) + cfg.Targets[name] = target + } + + return &cfg, nil +} + +// Save writes the config to the default location +func (c *Config) Save() error { + path := ConfigPath() + + // Ensure directory exists + dir := filepath.Dir(path) + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("failed to create config directory: %w", err) + } + + data, err := yaml.Marshal(c) + if err != nil { + return fmt.Errorf("failed to marshal config: %w", err) + } + + if err := os.WriteFile(path, data, 0644); err != nil { + return fmt.Errorf("failed to write config: %w", err) + } + + return nil +} + +// expandPath expands ~ to home directory +func expandPath(path string) string { + if len(path) > 0 && path[0] == '~' { + home, _ := os.UserHomeDir() + return filepath.Join(home, path[1:]) + } + return path +} diff --git a/internal/sync/sync.go b/internal/sync/sync.go new file mode 100644 index 000000000..2d1e39d62 --- /dev/null +++ b/internal/sync/sync.go @@ -0,0 +1,238 @@ +package sync + +import ( + "fmt" + "io" + "os" + "path/filepath" + + "github.com/runkids/skillshare/internal/config" +) + +// 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 +) + +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" + 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 +} diff --git a/internal/ui/ui.go b/internal/ui/ui.go new file mode 100644 index 000000000..bf7f636ec --- /dev/null +++ b/internal/ui/ui.go @@ -0,0 +1,60 @@ +package ui + +import ( + "fmt" +) + +// Colors for terminal output +const ( + Reset = "\033[0m" + Red = "\033[31m" + Green = "\033[32m" + Yellow = "\033[33m" + Blue = "\033[34m" + Magenta = "\033[35m" + Cyan = "\033[36m" + Gray = "\033[90m" +) + +// Success prints a success message +func Success(format string, args ...interface{}) { + fmt.Printf(Green+"✓ "+Reset+format+"\n", args...) +} + +// Error prints an error message +func Error(format string, args ...interface{}) { + fmt.Printf(Red+"✗ "+Reset+format+"\n", args...) +} + +// Warning prints a warning message +func Warning(format string, args ...interface{}) { + fmt.Printf(Yellow+"! "+Reset+format+"\n", args...) +} + +// Info prints an info message +func Info(format string, args ...interface{}) { + fmt.Printf(Cyan+"→ "+Reset+format+"\n", args...) +} + +// Status prints a status line +func Status(name, status, detail string) { + statusColor := Gray + switch status { + case "linked": + statusColor = Green + case "not exist": + statusColor = Yellow + case "has files": + statusColor = Blue + case "conflict", "broken": + statusColor = Red + } + + fmt.Printf(" %-12s %s%-12s%s %s\n", name, statusColor, status, Reset, Gray+detail+Reset) +} + +// Header prints a section header +func Header(text string) { + fmt.Printf("\n%s%s%s\n", Cyan, text, Reset) + fmt.Println(Gray + "─────────────────────────────────────────" + Reset) +}