sync

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = ["pyyaml"]
# ///
"""Sync skills, agents and commands to local AI tool config directories."""

import filecmp
import os
import shutil
import subprocess
import sys
from pathlib import Path

import yaml

REPO_DIR = Path(__file__).resolve().parent
CONFIG_FILE = REPO_DIR / "sync.yaml"
EXAMPLE_FILE = REPO_DIR / "sync.yaml.example"

# Content types synced. Each is a subdirectory of the same name inside
# every source root (this repo, plus any `sources:` entries in sync.yaml).
CONTENT_TYPES = ("skills", "agents", "commands")

TYPE_LETTER = {"skills": "s", "agents": "a", "commands": "c"}


USAGE = """\
Usage:
  ./sync                          # configured full sync (uses sync.yaml targets)
  ./sync pick --to PATH           # interactive multi-select copy into PATH/<type>/
  ./sync preset NAME --to PATH    # copy a named bundle into PATH/<type>/

Flags (any mode):
  --dry-run    preview only
  --force      overwrite without prompting

PATH is the base — items land in PATH/skills/<name>, PATH/agents/<name>, etc.
"""


def load_config() -> dict:
    if not CONFIG_FILE.exists():
        print(f"No sync.yaml found. Copy the example to get started:")
        print(f"  cp {EXAMPLE_FILE.name} {CONFIG_FILE.name}")
        sys.exit(1)
    with open(CONFIG_FILE) as f:
        return yaml.safe_load(f)


def load_config_optional() -> dict:
    """Like load_config, but an absent sync.yaml just means defaults."""
    if not CONFIG_FILE.exists():
        return {}
    with open(CONFIG_FILE) as f:
        return yaml.safe_load(f) or {}


def expand_path(p: str) -> Path:
    return Path(os.path.expanduser(p))


def source_roots(config: dict) -> list[Path]:
    """This repo first, then any extra `sources:` roots from sync.yaml."""
    roots = [REPO_DIR]
    for entry in config.get("sources") or []:
        root = expand_path(entry)
        if not root.is_dir():
            print(f"⚠  source '{entry}' not found — skipping")
            continue
        roots.append(root)
    return roots


def collect_items(config: dict) -> dict[str, dict[str, Path]]:
    """Map content type -> {name: source path} across all source roots.

    The first root to provide a name wins (so this repo's own copy beats
    an external source's); shadowed duplicates are reported so collisions
    stay visible.
    """
    items: dict[str, dict[str, Path]] = {ct: {} for ct in CONTENT_TYPES}
    for root in source_roots(config):
        for content_type in CONTENT_TYPES:
            subdir = root / content_type
            if not subdir.is_dir():
                continue
            for item in sorted(subdir.iterdir()):
                if item.name.startswith("."):
                    continue
                existing = items[content_type].get(item.name)
                if existing is not None:
                    print(
                        f"⚠  {content_type}/{item.name}: using {existing}, "
                        f"ignoring the copy in {root}"
                    )
                    continue
                items[content_type][item.name] = item
    return items


def newest_mtime(path: Path) -> float:
    """Return the newest mtime of a file or any file within a directory."""
    if path.is_file():
        return path.stat().st_mtime
    if path.is_dir():
        mtimes = [f.stat().st_mtime for f in path.rglob("*") if f.is_file()]
        return max(mtimes) if mtimes else 0
    return 0


def show_diff(src: Path, dest: Path) -> None:
    """Show a diff between source and destination."""
    try:
        result = subprocess.run(
            ["diff", "-ru", str(src), str(dest)],
            capture_output=True,
            text=True,
        )
        print(result.stdout if result.stdout else "  (no text differences)")
    except FileNotFoundError:
        print("  (diff not available)")


def ask_user(prompt: str, src: Path | None = None, dest: Path | None = None) -> bool:
    """Prompt the user. Returns True to overwrite, False to skip. Ctrl-C exits."""
    while True:
        try:
            hint = "[y/N/d]" if src else "[y/N]"
            answer = input(f"  {prompt} {hint} ").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print("\nAborted.")
            sys.exit(130)

        if answer in ("d", "diff") and src and dest:
            show_diff(src, dest)
            continue

        return answer in ("y", "yes")


def ignored_names(config: dict, global_config: dict, content_type: str) -> set[str]:
    """Build the set of ignored names for a content type (global + per-target)."""
    global_ignores = global_config.get("ignore", {}).get(content_type, []) or []
    target_ignores = config.get("ignore", {}).get(content_type, []) or []
    return set(global_ignores) | set(target_ignores)


def _sync_file(src: Path, dest: Path, force: bool = False) -> str:
    """Sync a single file. Returns a status string."""
    if dest.exists():
        # Identical files need no action; differing files may contain local edits.
        if filecmp.cmp(src, dest, shallow=False):
            return "unchanged"

        if not force:
            print(f"  ⚠  {dest} differs from source")
            if not ask_user("Overwrite with source version?", src, dest):
                return "skipped (destination differs)"

    dest.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(src, dest)
    return "synced"


def sync_item(src: Path, dest: Path, force: bool = False) -> str:
    """Sync a single file or directory. Returns a status string."""
    if not src.exists():
        return "missing"

    if src.is_file():
        return _sync_file(src, dest, force)

    # For directories, merge by syncing each source file individually
    # (preserves any user-added files in the destination)
    statuses = []
    for src_file in sorted(src.rglob("*")):
        if not src_file.is_file():
            continue
        dest_file = dest / src_file.relative_to(src)
        statuses.append(_sync_file(src_file, dest_file, force))

    if not statuses:
        return "unchanged"
    if any("skipped" in s for s in statuses):
        if any(s == "synced" for s in statuses):
            return "partially synced (some files skipped)"
        return "skipped (destination differs)"
    if any(s == "synced" for s in statuses):
        return "synced"
    return "unchanged"


def sync_target(
    name: str,
    config: dict,
    global_config: dict,
    items: dict[str, dict[str, Path]],
    skipped: list,
    force: bool = False,
) -> None:
    print(f"\n📁 {name}")

    for content_type in CONTENT_TYPES:
        dest_base_str = config.get(content_type)
        if not dest_base_str:
            continue

        dest_base = expand_path(dest_base_str)
        dest_base.mkdir(parents=True, exist_ok=True)

        ignores = ignored_names(config, global_config, content_type)
        for item_name, src in sorted(items[content_type].items()):
            if item_name in ignores:
                print(f"  ⊘ {content_type}/{item_name} → ignored")
                continue
            dest = dest_base / item_name
            status = sync_item(src, dest, force=force)
            if status == "unchanged":
                print(f"  → {content_type}/{item_name} unchanged")
                continue
            icon = "✓" if status == "synced" else "⊘"
            print(f"  {icon} {content_type}/{item_name} → {status}")
            if "skipped" in status:
                skipped.append((dest, src))


def apply_picks(
    chosen: list[tuple[str, str, Path]],
    to: Path,
    force: bool,
    dry_run: bool = False,
) -> None:
    if not chosen:
        print("Nothing to copy.")
        return

    if dry_run:
        print(f"\nDry run — would copy {len(chosen)} item(s) to {to}:\n")
        for ct, name, _ in chosen:
            dest = to / ct / name
            exists = "exists" if dest.exists() else "new"
            print(f"  {ct}/{name} → {dest} ({exists})")
        return

    print(f"\nCopying {len(chosen)} item(s) to {to}:\n")
    skipped: list[tuple[Path, Path]] = []
    for ct, name, src in chosen:
        dest = to / ct / name
        status = sync_item(src, dest, force=force)
        icon = "✓" if status == "synced" else ("→" if status == "unchanged" else "⊘")
        print(f"  {icon} {ct}/{name} → {status}")
        if "skipped" in status:
            skipped.append((dest, src))

    if skipped:
        print("\n⚠  Skipped (destination differs from source):")
        for dest, src in skipped:
            print(f"  {dest}")
            print(f"    ← repo: {src}")

    print("\nDone.")


FZF_PREVIEW = (
    "if [ -d {2} ]; then "
    "cat {2}/SKILL.md 2>/dev/null | head -80; "
    "else cat {2} 2>/dev/null | head -80; fi"
)


def picker_mode(
    items_map: dict[str, dict[str, Path]], to: Path, force: bool, dry_run: bool
) -> None:
    if not shutil.which("fzf"):
        print(
            "pick mode needs fzf on PATH.\n"
            "Install it (https://github.com/junegunn/fzf) "
            "or use `./sync preset NAME --to PATH` instead."
        )
        sys.exit(1)

    items = [
        (ct, name, src)
        for ct in CONTENT_TYPES
        for name, src in sorted(items_map[ct].items())
    ]
    if not items:
        print("No items found in repo or sources.")
        return

    items_by_line: dict[str, tuple[str, str, Path]] = {}
    fzf_lines: list[str] = []
    for ct, name, src in items:
        line = f"[{TYPE_LETTER[ct]}] {name}\t{src}"
        items_by_line[line] = (ct, name, src)
        fzf_lines.append(line)

    result = subprocess.run(
        [
            "fzf",
            "--multi",
            "--delimiter=\t",
            "--with-nth=1",
            "--preview", FZF_PREVIEW,
            "--preview-window=right:60%:wrap",
            "--header=Tab: select  Enter: copy  Esc: cancel",
            "--prompt=skills/agents/commands> ",
        ],
        input="\n".join(fzf_lines),
        stdout=subprocess.PIPE,
        text=True,
    )

    if result.returncode == 130 or not result.stdout.strip():
        print("Cancelled.")
        return
    if result.returncode not in (0, 1):
        print(f"fzf exited with {result.returncode}")
        return

    chosen = [items_by_line[line] for line in result.stdout.splitlines() if line in items_by_line]
    apply_picks(chosen, to, force, dry_run=dry_run)


def preset_mode(
    name: str,
    to: Path,
    force: bool,
    dry_run: bool,
    config: dict,
    items: dict[str, dict[str, Path]],
) -> None:
    presets = config.get("presets") or {}
    if name not in presets:
        available = ", ".join(sorted(presets)) or "(none defined)"
        print(f"Preset '{name}' not found. Available: {available}")
        sys.exit(1)

    preset = presets[name] or {}
    chosen: list[tuple[str, str, Path]] = []
    for ct in CONTENT_TYPES:
        names = preset.get(ct) or []
        for n in names:
            # Presets list agents/commands by bare name; the files are .md.
            key = n if n in items[ct] else f"{n}.md"
            src = items[ct].get(key)
            if src is None:
                print(
                    f"  ⚠ {ct}/{n} listed in preset '{name}' "
                    "but not found in repo or sources"
                )
                continue
            chosen.append((ct, key, src))

    apply_picks(chosen, to, force, dry_run=dry_run)


def main() -> None:
    args = sys.argv[1:]

    if "-h" in args or "--help" in args:
        print(USAGE)
        return

    force = "--force" in args
    dry_run = "--dry-run" in args
    args = [a for a in args if a not in ("--force", "--dry-run")]

    to: Path | None = None
    if "--to" in args:
        i = args.index("--to")
        if i + 1 >= len(args):
            print("--to requires a path")
            sys.exit(1)
        to = expand_path(args[i + 1])
        args = args[:i] + args[i + 2 :]

    if args and args[0] == "pick":
        if to is None:
            print("Usage: ./sync pick --to PATH")
            sys.exit(1)
        picker_mode(collect_items(load_config_optional()), to, force, dry_run)
        return

    if args and args[0] == "preset":
        if len(args) < 2 or to is None:
            print("Usage: ./sync preset NAME --to PATH")
            sys.exit(1)
        config = load_config()
        preset_mode(args[1], to, force, dry_run, config, collect_items(config))
        return

    if dry_run:
        print("Dry run — showing what would be synced:\n")
        config = load_config()
        items = collect_items(config)
        for name, target in config.get("targets", {}).items():
            if not target.get("enabled", False):
                continue
            print(f"📁 {name}")
            for content_type in CONTENT_TYPES:
                dest_str = target.get(content_type)
                if not dest_str:
                    continue
                ignores = ignored_names(target, config, content_type)
                for item_name, src in sorted(items[content_type].items()):
                    if item_name in ignores:
                        print(f"  {content_type}/{item_name} → ignored")
                        continue
                    dest = expand_path(dest_str) / item_name
                    exists = "exists" if dest.exists() else "new"
                    print(f"  {content_type}/{item_name} → {dest} ({exists})")
        return

    config = load_config()
    items = collect_items(config)
    targets = config.get("targets", {})

    if not targets:
        print("No targets defined in sync.yaml")
        sys.exit(1)

    enabled = {k: v for k, v in targets.items() if v.get("enabled", False)}
    if not enabled:
        print("No targets enabled in sync.yaml")
        sys.exit(1)

    print(f"Syncing to {len(enabled)} target(s)...")
    if force:
        print("(--force: overwriting without prompts)")

    skipped: list[tuple[Path, Path]] = []
    for name, target in enabled.items():
        sync_target(name, target, config, items, skipped, force=force)

    if skipped:
        print("\n⚠  Skipped (destination differs from source):")
        for dest, src in skipped:
            print(f"  {dest}")
            print(f"    ← repo: {src}")

    print("\nDone.")


if __name__ == "__main__":
    main()