agent-toolkit-cli 1.11.0__py3-none-win_amd64.whl

agent_toolkit/cli/uninstall.py

@@ -0,0 +1,166 @@
+"""
+uninstall — Remove agent-toolkit profile files recorded in install receipts.
+
+Usage:
+    agent-toolkit uninstall [options]
+
+Options:
+    --tools <list>   Comma-separated tools to uninstall (default: all with receipts)
+    --dry-run        Show what would be removed without deleting files
+    --rollback       Alias for uninstall (removes toolkit-owned files from receipt)
+    --help           Show this help message
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from agent_toolkit.installer import tracking
+from agent_toolkit.installer.receipt import InstallReceipt
+
+_VALID_TOOLS = ("claude-code", "cursor", "opencode", "copilot", "windsurf", "pi")
+_TOOL_RECEIPT_TARGETS = {
+    "claude-code": "claude-code",
+    "cursor": "cursor",
+    "opencode": "opencode",
+    "copilot": "copilot",
+    "windsurf": "windsurf",
+    "pi": "pi",
+}
+
+
+def _info(msg: str) -> None:
+    print(f"  [info]  {msg}")
+
+
+def _ok(msg: str) -> None:
+    print(f"  ✓  {msg}")
+
+
+def _skip(msg: str) -> None:
+    print(f"  -  {msg}")
+
+
+def _dry(msg: str) -> None:
+    print(f"  [dry]   {msg}")
+
+
+def _err(msg: str) -> None:
+    print(f"  ✗  {msg}", file=sys.stderr)
+
+
+def _parse_args(args: list[str]) -> tuple[list[str], bool, bool] | None:
+    dry_run = False
+    requested = ""
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg in ("-h", "--help"):
+            print(__doc__)
+            return None
+        if arg in ("--dry-run",):
+            dry_run = True
+        elif arg in ("--rollback",):
+            dry_run = False  # rollback is uninstall with side effects
+        elif arg == "--tools":
+            if i + 1 >= len(args):
+                _err("--tools requires an argument")
+                return None
+            requested = args[i + 1]
+            i += 1
+        else:
+            _err(f"Unknown option: {arg}")
+            return None
+        i += 1
+
+    if requested:
+        tools = [t.strip() for t in requested.split(",") if t.strip()]
+    else:
+        tools = []
+    return tools, dry_run, True
+
+
+def _discover_tools(receipt_dir: Path) -> list[str]:
+    found: list[str] = []
+    if not receipt_dir.is_dir():
+        return found
+    for path in sorted(receipt_dir.glob(f"*-{tracking.PRODUCT}.json")):
+        target = path.name[: -len(f"-{tracking.PRODUCT}.json")]
+        for tool, receipt_target in _TOOL_RECEIPT_TARGETS.items():
+            if receipt_target == target and tool not in found:
+                found.append(tool)
+    return found
+
+
+def _uninstall_tool(tool: str, *, dry_run: bool, receipt_dir: Path) -> bool:
+    target = _TOOL_RECEIPT_TARGETS.get(tool)
+    if target is None:
+        _err(f"Unknown tool: {tool}")
+        return False
+
+    receipt = InstallReceipt.load(target, tracking.PRODUCT, receipt_dir)
+    if receipt is None:
+        _skip(f"No receipt for {tool} — nothing to uninstall")
+        return True
+
+    _info(f"Uninstalling {tool} ({len(receipt.artifacts)} artifact(s) from receipt)")
+    removed = 0
+    for entry in receipt.artifacts:
+        if entry.ownership != "created":
+            _skip(f"Skipping non-owned file ({entry.ownership}): {entry.path}")
+            continue
+        path = Path(entry.path)
+        if not path.exists():
+            _skip(f"Already absent: {path}")
+            continue
+        if dry_run:
+            _dry(f"Would remove: {path}")
+        else:
+            try:
+                path.unlink()
+                _ok(f"Removed: {path}")
+            except OSError as exc:
+                _err(f"Failed to remove {path}: {exc}")
+                return False
+        removed += 1
+
+    if not dry_run:
+        receipt_path = receipt_dir / f"{target}-{tracking.PRODUCT}.json"
+        if receipt_path.exists():
+            receipt_path.unlink()
+            _ok(f"Removed receipt: {receipt_path}")
+
+    _info(f"{tool}: processed {removed} owned file(s)")
+    return True
+
+
+def cmd_uninstall(args: list[str]) -> int:
+    parsed = _parse_args(args)
+    if parsed is None:
+        return 0 if any(a in ("-h", "--help") for a in args) else 2
+    tools, dry_run, _ = parsed
+
+    rdir = tracking.receipt_dir()
+    if not tools:
+        tools = _discover_tools(rdir)
+        if not tools:
+            _err("No install receipts found. Nothing to uninstall.")
+            return 1
+
+    print()
+    print("agent-toolkit uninstall")
+    if dry_run:
+        _info("DRY RUN — no files will be deleted")
+
+    failed: list[str] = []
+    for tool in tools:
+        if tool not in _VALID_TOOLS:
+            _err(f"Unknown tool: {tool}")
+            failed.append(tool)
+            continue
+        if not _uninstall_tool(tool, dry_run=dry_run, receipt_dir=rdir):
+            failed.append(tool)
+
+    print()
+    return 1 if failed else 0

agent_toolkit/cli/update.py

@@ -0,0 +1,298 @@
+"""
+update — Refresh installed profiles from toolkit data.
+
+Usage:
+    agent-toolkit update [options]
+
+Options:
+    --tools <list>   Comma-separated tools to update (default: auto-detect installed)
+    --check          Dry-run — show what would change without writing files
+    --pin <version>  Download capability data from a specific release before updating
+    --help           Show this help message
+
+Examples:
+    agent-toolkit update
+    agent-toolkit update --tools cursor,opencode
+    agent-toolkit update --check
+    agent-toolkit update --pin 1.1.0
+"""
+
+from __future__ import annotations
+
+import hashlib
+import shutil
+import sys
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from agent_toolkit._paths import reset_toolkit_root, toolkit_root
+from agent_toolkit.cli.install import (
+    _VALID_TOOLS,
+    _detect_claude_code,
+    _detect_cursor,
+    _detect_opencode,
+    _detect_pi,
+    _detect_windsurf,
+    _windsurf_config_dir,
+)
+
+_PARSE_HELP = object()
+_PARSE_ERROR = object()
+
+
+@dataclass
+class FileMapping:
+    src: Path
+    dst: Path
+
+
+@dataclass
+class ToolUpdatePlan:
+    tool: str
+    changed: list[Path] = field(default_factory=list)
+    added: list[Path] = field(default_factory=list)
+    up_to_date: list[Path] = field(default_factory=list)
+
+
+def _file_hash(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _iter_files(root: Path) -> Iterator[Path]:
+    if not root.is_dir():
+        return
+    for path in sorted(root.rglob("*")):
+        if path.is_file():
+            yield path
+
+
+def _mappings_for_tool(tool: str, data_root: Path, home: Path) -> list[FileMapping]:
+    mappings: list[FileMapping] = []
+
+    if tool == "claude-code":
+        src = data_root / "profiles" / "claude-code"
+        if src.is_dir():
+            claude = src / "CLAUDE.md"
+            if claude.is_file():
+                mappings.append(FileMapping(claude, home / ".claude" / "CLAUDE.md"))
+            agents = src / "agents"
+            if agents.is_dir():
+                for f in _iter_files(agents):
+                    rel = f.relative_to(agents)
+                    mappings.append(FileMapping(f, home / ".claude" / "agents" / rel))
+
+    elif tool == "cursor":
+        src = data_root / "profiles" / "cursor" / "rules"
+        if src.is_dir():
+            for f in _iter_files(src):
+                rel = f.relative_to(src)
+                mappings.append(FileMapping(f, home / ".cursor" / "rules" / rel))
+
+    elif tool == "opencode":
+        src = data_root / "profiles" / "opencode"
+        cfg = src / "opencode.json"
+        if cfg.is_file():
+            mappings.append(FileMapping(cfg, home / ".config" / "opencode" / "opencode.json"))
+        agents = src / "agents"
+        if agents.is_dir():
+            for f in _iter_files(agents):
+                rel = f.relative_to(agents)
+                mappings.append(FileMapping(f, home / ".config" / "opencode" / "agents" / rel))
+
+    elif tool == "windsurf":
+        src = data_root / "profiles" / "windsurf"
+        config_dir = _windsurf_config_dir()
+        for sub in ("rules", "memories"):
+            sub_src = src / sub
+            if sub_src.is_dir():
+                for f in _iter_files(sub_src):
+                    rel = f.relative_to(sub_src)
+                    mappings.append(FileMapping(f, config_dir / sub / rel))
+
+    elif tool == "pi":
+        src = data_root / "profiles" / "pi" / "skills"
+        if src.is_dir():
+            for f in _iter_files(src):
+                rel = f.relative_to(src)
+                mappings.append(FileMapping(f, home / ".pi" / "agent" / "skills" / rel))
+
+    return mappings
+
+
+def _plan_tool_update(tool: str, data_root: Path, home: Path) -> ToolUpdatePlan | None:
+    mappings = _mappings_for_tool(tool, data_root, home)
+    if not mappings:
+        return None
+
+    plan = ToolUpdatePlan(tool=tool)
+    for mapping in mappings:
+        if not mapping.src.is_file():
+            continue
+        src_hash = _file_hash(mapping.src)
+        if mapping.dst.is_file():
+            if _file_hash(mapping.dst) == src_hash:
+                plan.up_to_date.append(mapping.dst)
+            else:
+                plan.changed.append(mapping.dst)
+        else:
+            plan.added.append(mapping.dst)
+    return plan
+
+
+def _detect_installed_tools() -> list[str]:
+    detectors: list[tuple[str, Callable[[], bool]]] = [
+        ("claude-code", _detect_claude_code),
+        ("cursor", _detect_cursor),
+        ("opencode", _detect_opencode),
+        ("windsurf", _detect_windsurf),
+        ("pi", _detect_pi),
+    ]
+    return [name for name, fn in detectors if fn()]
+
+
+def _apply_plan(plan: ToolUpdatePlan, data_root: Path, home: Path, *, check_only: bool) -> int:
+    updated = 0
+    mappings = _mappings_for_tool(plan.tool, data_root, home)
+    targets = {m.dst for m in mappings if m.dst in plan.changed or m.dst in plan.added}
+
+    for mapping in mappings:
+        if mapping.dst not in targets:
+            continue
+        rel = mapping.dst.relative_to(home) if mapping.dst.is_relative_to(home) else mapping.dst
+        if check_only:
+            print(f"  ~ would update: ~/{rel}")
+            updated += 1
+            continue
+        mapping.dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(mapping.src, mapping.dst)
+        print(f"  ✓ updated: ~/{rel}")
+        updated += 1
+    return updated
+
+
+def _parse_args(args: list[str]):
+    tools: list[str] = []
+    check_only = False
+    pin: str | None = None
+    requested = ""
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg in ("-h", "--help"):
+            print(__doc__)
+            return _PARSE_HELP
+        if arg == "--check":
+            check_only = True
+        elif arg == "--tools":
+            if i + 1 >= len(args):
+                print("  ✗  --tools requires an argument", file=sys.stderr)
+                return _PARSE_ERROR
+            requested = args[i + 1]
+            i += 1
+        elif arg == "--pin":
+            if i + 1 >= len(args):
+                print("  ✗  --pin requires an argument", file=sys.stderr)
+                return _PARSE_ERROR
+            pin = args[i + 1]
+            i += 1
+        else:
+            print(f"  ✗  Unknown option: {arg}", file=sys.stderr)
+            return _PARSE_ERROR
+        i += 1
+
+    if requested:
+        tools = [t.strip() for t in requested.split(",") if t.strip()]
+    return tools, check_only, pin
+
+
+def cmd_update(args: list[str]) -> int:
+    """Refresh installed profiles from toolkit data."""
+    result = _parse_args(args)
+    if result is _PARSE_HELP:
+        return 0
+    if result is _PARSE_ERROR:
+        return 2
+
+    tools, check_only, pin = result
+
+    print()
+    print("agent-toolkit update")
+
+    # Refresh capability data cache when pinned or stale
+    if pin:
+        from agent_toolkit.data_sync import download_data
+
+        reset_toolkit_root()
+        try:
+            download_data(pin, force=True)
+        except RuntimeError as exc:
+            print(f"  ✗  {exc}", file=sys.stderr)
+            return 1
+    else:
+        from agent_toolkit import __version__
+        from agent_toolkit._paths import _offline_mode
+        from agent_toolkit.data_sync import cached_version, download_data
+
+        cv = cached_version()
+        if cv is None or cv.lstrip("v") != __version__.lstrip("v"):
+            if _offline_mode():
+                print("  ⚠  Data refresh skipped: offline mode (AGENT_TOOLKIT_OFFLINE)")
+            else:
+                try:
+                    download_data(__version__, force=True, quiet=check_only)
+                    reset_toolkit_root()
+                except (RuntimeError, OSError) as exc:
+                    print(f"  ⚠  Data refresh skipped: {exc}")
+
+    try:
+        data_root = toolkit_root()
+    except EnvironmentError as exc:
+        print(f"  ✗  {exc}", file=sys.stderr)
+        return 1
+
+    print(f"  Data: {data_root}")
+    if check_only:
+        print("  [check] Dry run — no files will be written")
+
+    if not tools:
+        tools = _detect_installed_tools()
+        if not tools:
+            print("  ⚠  No installed tools detected. Use --tools to specify targets.")
+            return 1
+        print(f"  Tools: {', '.join(tools)}")
+
+    home = Path.home()
+    total_changes = 0
+    any_errors = False
+
+    for tool in tools:
+        if tool not in _VALID_TOOLS:
+            print(f"  ⚠  Unknown tool: {tool}")
+            any_errors = True
+            continue
+
+        plan = _plan_tool_update(tool, data_root, home)
+        if plan is None:
+            print(f"  ⚠  No profile data for: {tool}")
+            continue
+
+        pending = len(plan.changed) + len(plan.added)
+        if pending == 0:
+            print(f"  ✓ {tool}: up to date ({len(plan.up_to_date)} files)")
+            continue
+
+        print(f"  → {tool}: {len(plan.changed)} changed, {len(plan.added)} new")
+        total_changes += _apply_plan(plan, data_root, home, check_only=check_only)
+
+    print()
+    if check_only:
+        print(f"  {total_changes} file(s) would be updated")
+        return 1 if total_changes else 0
+
+    if total_changes:
+        print(f"  Updated {total_changes} file(s)")
+    else:
+        print("  All profiles up to date")
+    return 1 if any_errors else 0