canopy-cli 3.1.0__py3-none-any.whl

canopy/git/hooks.py

@@ -0,0 +1,173 @@
+"""Install, uninstall, and read canopy git hooks.
+
+Canopy installs a post-checkout hook in every managed repo and worktree so
+it has real-time ground truth of HEAD per repo without polling. The hook
+writes to .canopy/state/heads.json under the workspace root.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import stat
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+_HOOK_NAME = "post-checkout"
+_CHAINED_NAME = "post-checkout.canopy-chained"
+_MARKER = "__CANOPY_HOOK_MARKER__"
+_TEMPLATE_PATH = Path(__file__).parent / "templates" / "post-checkout.py"
+
+
+@dataclass
+class InstallResult:
+    repo: str
+    path: str
+    action: str  # "installed", "reinstalled", "chained_existing"
+
+
+def install_hook(repo_path: Path, repo_name: str, workspace_root: Path) -> InstallResult:
+    """Install the canopy post-checkout hook in a repo or linked worktree.
+
+    If a user hook already exists, it's moved to ``post-checkout.canopy-chained``
+    and invoked after the canopy hook runs. If a previous canopy hook is
+    present, it's replaced.
+    """
+    hooks_dir = resolve_hooks_dir(repo_path)
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    hook_path = hooks_dir / _HOOK_NAME
+
+    template = _TEMPLATE_PATH.read_text()
+    rendered = template.replace(
+        '"__CANOPY_REPO__"', json.dumps(repo_name),
+    ).replace(
+        '"__CANOPY_WORKSPACE_ROOT__"', json.dumps(str(workspace_root.resolve())),
+    )
+
+    action = "installed"
+    if hook_path.exists():
+        existing = hook_path.read_text()
+        if _MARKER in existing:
+            action = "reinstalled"
+        else:
+            chained = hooks_dir / _CHAINED_NAME
+            if chained.exists():
+                chained.unlink()
+            shutil.move(str(hook_path), str(chained))
+            _make_executable(chained)
+            action = "chained_existing"
+
+    hook_path.write_text(rendered)
+    _make_executable(hook_path)
+
+    return InstallResult(repo=repo_name, path=str(hook_path), action=action)
+
+
+@dataclass
+class UninstallResult:
+    repo: str
+    action: str  # "uninstalled", "uninstalled_and_restored", "skipped", "not_installed"
+    reason: str | None = None
+
+
+def uninstall_hook(repo_path: Path, repo_name: str) -> UninstallResult:
+    """Remove the canopy hook; restore any chained user hook."""
+    hooks_dir = resolve_hooks_dir(repo_path)
+    hook_path = hooks_dir / _HOOK_NAME
+    chained = hooks_dir / _CHAINED_NAME
+
+    if not hook_path.exists():
+        return UninstallResult(repo=repo_name, action="not_installed")
+
+    if _MARKER not in hook_path.read_text():
+        return UninstallResult(
+            repo=repo_name, action="skipped",
+            reason="hook exists but is not a canopy hook",
+        )
+
+    hook_path.unlink()
+    if chained.exists():
+        shutil.move(str(chained), str(hook_path))
+        _make_executable(hook_path)
+        return UninstallResult(repo=repo_name, action="uninstalled_and_restored")
+    return UninstallResult(repo=repo_name, action="uninstalled")
+
+
+def hook_status(repo_path: Path) -> dict:
+    """Inspect current hook state for a repo."""
+    hooks_dir = resolve_hooks_dir(repo_path)
+    hook_path = hooks_dir / _HOOK_NAME
+    chained = hooks_dir / _CHAINED_NAME
+
+    if not hook_path.exists():
+        return {"installed": False, "hook_path": str(hook_path)}
+
+    content = hook_path.read_text()
+    return {
+        "installed": _MARKER in content,
+        "foreign_hook": _MARKER not in content,
+        "chained_present": chained.exists(),
+        "hook_path": str(hook_path),
+    }
+
+
+def read_heads_state(workspace_root: Path) -> dict:
+    """Return ``{repo_name: {branch, sha, prev_sha, ts}}`` from the state file."""
+    path = workspace_root / ".canopy" / "state" / "heads.json"
+    try:
+        return json.loads(path.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def resolve_hooks_dir(repo_path: Path) -> Path:
+    """Resolve the ``hooks`` dir git actually uses for this repo / worktree.
+
+    Resolution order:
+      1. ``core.hooksPath`` if set in the repo's config (e.g., Husky uses
+         ``.husky/_``). Relative paths resolve against the repo root.
+         Without this we'd install a hook git would never run.
+      2. For a linked worktree, follow ``.git`` (file) → worktree gitdir →
+         ``commondir`` → main ``.git/hooks``. Hooks are shared across all
+         worktrees of a repo by default.
+      3. Otherwise ``<repo>/.git/hooks``.
+    """
+    custom = _get_core_hooks_path(repo_path)
+    if custom is not None:
+        return custom
+
+    git_path = repo_path / ".git"
+    if git_path.is_file():
+        contents = git_path.read_text().strip()
+        if contents.startswith("gitdir:"):
+            worktree_gitdir = Path(contents.split(":", 1)[1].strip())
+            if not worktree_gitdir.is_absolute():
+                worktree_gitdir = (repo_path / worktree_gitdir).resolve()
+            commondir_file = worktree_gitdir / "commondir"
+            if commondir_file.is_file():
+                common = Path(commondir_file.read_text().strip())
+                if not common.is_absolute():
+                    common = (worktree_gitdir / common).resolve()
+                return common / "hooks"
+            return worktree_gitdir / "hooks"
+    return git_path / "hooks"
+
+
+def _get_core_hooks_path(repo_path: Path) -> Path | None:
+    """Read ``core.hooksPath`` from the repo's config. Returns None if unset."""
+    result = subprocess.run(
+        ["git", "config", "--get", "core.hooksPath"],
+        cwd=repo_path, capture_output=True, text=True, check=False,
+    )
+    value = result.stdout.strip()
+    if result.returncode != 0 or not value:
+        return None
+    p = Path(value)
+    if not p.is_absolute():
+        p = (repo_path / p).resolve()
+    return p
+
+
+def _make_executable(path: Path) -> None:
+    mode = path.stat().st_mode
+    path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)

canopy/git/multi.py

@@ -0,0 +1,435 @@
+"""
+Cross-repo Git operations.
+
+Calls git.repo functions across multiple repos in a workspace.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ..workspace.workspace import Workspace, RepoState
+from . import repo as git
+
+
+def workspace_status(workspace: Workspace) -> list[RepoState]:
+    """Refresh and return enriched state for all repos."""
+    workspace.refresh()
+    return workspace.repos
+
+
+def create_branch_all(
+    workspace: Workspace,
+    branch: str,
+    repos: list[str] | None = None,
+) -> dict[str, bool | str]:
+    """Create a branch in all (or specified) repos.
+
+    Returns:
+        {repo_name: True} on success, {repo_name: error_message} on failure.
+    """
+    results: dict[str, bool | str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        try:
+            if git.branch_exists(state.abs_path, branch):
+                results[state.config.name] = True  # already exists
+            else:
+                git.create_branch(state.abs_path, branch)
+                results[state.config.name] = True
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def checkout_all(
+    workspace: Workspace,
+    branch: str,
+    repos: list[str] | None = None,
+) -> dict[str, bool | str]:
+    """Checkout a branch in all (or specified) repos.
+
+    Returns:
+        {repo_name: True} on success, {repo_name: error_message} on failure.
+    """
+    results: dict[str, bool | str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        try:
+            if not git.branch_exists(state.abs_path, branch):
+                results[state.config.name] = f"branch '{branch}' does not exist"
+                continue
+            git.checkout(state.abs_path, branch)
+            results[state.config.name] = True
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def cross_repo_diff(workspace: Workspace, feature: str) -> dict:
+    """Aggregate diff across all repos for a feature branch vs default.
+
+    Returns:
+        {
+            repo_name: {
+                files_changed, insertions, deletions,
+                changed_files, has_branch
+            }
+        }
+    """
+    result = {}
+
+    for state in workspace.repos:
+        base = state.config.default_branch
+        repo_name = state.config.name
+
+        if not git.branch_exists(state.abs_path, feature):
+            result[repo_name] = {
+                "has_branch": False,
+                "files_changed": 0,
+                "insertions": 0,
+                "deletions": 0,
+                "changed_files": [],
+            }
+            continue
+
+        try:
+            stat = git.diff_stat(state.abs_path, base, feature)
+            files = git.changed_files(state.abs_path, feature, base)
+            result[repo_name] = {
+                "has_branch": True,
+                "files_changed": stat["files_changed"],
+                "insertions": stat["insertions"],
+                "deletions": stat["deletions"],
+                "changed_files": files,
+            }
+        except git.GitError as e:
+            result[repo_name] = {
+                "has_branch": True,
+                "error": str(e),
+                "files_changed": 0,
+                "insertions": 0,
+                "deletions": 0,
+                "changed_files": [],
+            }
+
+    return result
+
+
+def find_type_overlaps(workspace: Workspace, feature: str) -> list[dict]:
+    """Find files with similar names changed across multiple repos.
+
+    Looks for potential shared type/interface conflicts where, e.g.,
+    api/src/models.py and ui/src/types.ts both change user-related types.
+
+    Returns:
+        [{file_pattern, repos: [repo_names], files: [{repo, path}]}]
+    """
+    # Collect changed file basenames per repo
+    file_map: dict[str, list[dict]] = {}
+
+    for state in workspace.repos:
+        base = state.config.default_branch
+        if not git.branch_exists(state.abs_path, feature):
+            continue
+        try:
+            files = git.changed_files(state.abs_path, feature, base)
+        except git.GitError:
+            continue
+
+        for f in files:
+            basename = os.path.splitext(os.path.basename(f))[0].lower()
+            # Normalize common type-related names
+            file_map.setdefault(basename, []).append({
+                "repo": state.config.name,
+                "path": f,
+            })
+
+    # Filter to basenames that appear in 2+ repos
+    overlaps = []
+    for basename, entries in file_map.items():
+        repos = {e["repo"] for e in entries}
+        if len(repos) >= 2:
+            overlaps.append({
+                "file_pattern": basename,
+                "repos": sorted(repos),
+                "files": entries,
+            })
+
+    return overlaps
+
+
+def sync_all(
+    workspace: Workspace,
+    strategy: str = "rebase",
+) -> dict[str, str]:
+    """Pull default branch and rebase/merge feature branches.
+
+    Returns:
+        {repo_name: "ok" | error_message}
+    """
+    results: dict[str, str] = {}
+
+    for state in workspace.repos:
+        try:
+            base = state.config.default_branch
+            current = git.current_branch(state.abs_path)
+
+            # First, update the default branch
+            git.checkout(state.abs_path, base)
+            git.pull_rebase(state.abs_path)
+
+            # If we were on a feature branch, rebase it
+            if current != base and current != "(detached)":
+                git.checkout(state.abs_path, current)
+                if strategy == "rebase":
+                    git._run(["rebase", base], cwd=state.abs_path)
+                else:
+                    git._run(["merge", base], cwd=state.abs_path)
+
+            results[state.config.name] = "ok"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+            # Try to recover: abort rebase if in progress
+            try:
+                git._run_ok(["rebase", "--abort"], cwd=state.abs_path)
+            except Exception:
+                pass
+
+    return results
+
+
+def stash_save_all(
+    workspace: Workspace,
+    message: str = "",
+    repos: list[str] | None = None,
+    include_untracked: bool = False,
+) -> dict[str, str]:
+    """Stash uncommitted changes across repos.
+
+    Returns:
+        {repo_name: "stashed" | "clean" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        try:
+            stashed = git.stash_save(
+                state.abs_path, message, include_untracked=include_untracked,
+            )
+            results[state.config.name] = "stashed" if stashed else "clean"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def stash_pop_all(
+    workspace: Workspace,
+    index: int = 0,
+    repos: list[str] | None = None,
+) -> dict[str, str]:
+    """Pop stash across repos.
+
+    Returns:
+        {repo_name: "ok" | "no stash" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        stashes = git.stash_list(state.abs_path)
+        if not stashes:
+            results[state.config.name] = "no stash"
+            continue
+        try:
+            git.stash_pop(state.abs_path, index)
+            results[state.config.name] = "ok"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def stash_list_all(workspace: Workspace) -> dict[str, list[dict]]:
+    """List stashes across all repos.
+
+    Returns:
+        {repo_name: [{index, ref, message}, ...]}
+    """
+    results: dict[str, list[dict]] = {}
+
+    for state in workspace.repos:
+        stashes = git.stash_list(state.abs_path)
+        if stashes:
+            results[state.config.name] = stashes
+
+    return results
+
+
+def stash_drop_all(
+    workspace: Workspace,
+    index: int = 0,
+    repos: list[str] | None = None,
+) -> dict[str, str]:
+    """Drop stash entry across repos.
+
+    Returns:
+        {repo_name: "ok" | "no stash" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        stashes = git.stash_list(state.abs_path)
+        if not stashes:
+            results[state.config.name] = "no stash"
+            continue
+        try:
+            git.stash_drop(state.abs_path, index)
+            results[state.config.name] = "ok"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def commit_all(
+    workspace: Workspace,
+    message: str,
+    repos: list[str] | None = None,
+) -> dict[str, str]:
+    """Commit staged changes across repos with the same message.
+
+    Returns:
+        {repo_name: new_sha | "nothing to commit" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        status = git.status_porcelain(state.abs_path)
+        staged = [e for e in status if e["index_status"]]
+        if not staged:
+            results[state.config.name] = "nothing to commit"
+            continue
+        try:
+            result = git.commit(state.abs_path, message)
+            results[state.config.name] = result["sha"][:12]
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def log_all(
+    workspace: Workspace,
+    max_count: int = 20,
+    feature: str | None = None,
+) -> list[dict]:
+    """Interleaved log across repos, sorted by date.
+
+    Returns:
+        List of {repo, sha, short_sha, author, date, subject}
+    """
+    all_entries = []
+
+    for state in workspace.repos:
+        ref = feature if feature and git.branch_exists(state.abs_path, feature) else "HEAD"
+        entries = git.log_structured(state.abs_path, ref=ref, max_count=max_count)
+        for entry in entries:
+            entry["repo"] = state.config.name
+            all_entries.append(entry)
+
+    # Sort by date descending
+    all_entries.sort(key=lambda e: e["date"], reverse=True)
+    return all_entries[:max_count]
+
+
+def delete_branch_all(
+    workspace: Workspace,
+    branch: str,
+    force: bool = False,
+    repos: list[str] | None = None,
+) -> dict[str, str]:
+    """Delete a branch across repos.
+
+    Returns:
+        {repo_name: "ok" | "not found" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        if not git.branch_exists(state.abs_path, branch):
+            results[state.config.name] = "not found"
+            continue
+        # Don't delete the branch we're currently on
+        if git.current_branch(state.abs_path) == branch:
+            results[state.config.name] = "currently checked out"
+            continue
+        try:
+            git.delete_branch(state.abs_path, branch, force=force)
+            results[state.config.name] = "ok"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def rename_branch_all(
+    workspace: Workspace,
+    old_name: str,
+    new_name: str,
+    repos: list[str] | None = None,
+) -> dict[str, str]:
+    """Rename a branch across repos.
+
+    Returns:
+        {repo_name: "ok" | "not found" | error_message}
+    """
+    results: dict[str, str] = {}
+    targets = _filter_repos(workspace, repos)
+
+    for state in targets:
+        if not git.branch_exists(state.abs_path, old_name):
+            results[state.config.name] = "not found"
+            continue
+        try:
+            git.rename_branch(state.abs_path, old_name, new_name)
+            results[state.config.name] = "ok"
+        except git.GitError as e:
+            results[state.config.name] = str(e)
+
+    return results
+
+
+def branches_all(workspace: Workspace) -> dict[str, list[dict]]:
+    """List all branches across repos.
+
+    Returns:
+        {repo_name: [{name, is_current, sha, subject}, ...]}
+    """
+    results: dict[str, list[dict]] = {}
+
+    for state in workspace.repos:
+        entries = git.all_branches(state.abs_path)
+        results[state.config.name] = entries
+
+    return results
+
+
+def _filter_repos(
+    workspace: Workspace,
+    repo_names: list[str] | None,
+) -> list[RepoState]:
+    """Filter repos by name, or return all if names is None."""
+    if repo_names is None:
+        return workspace.repos
+    name_set = set(repo_names)
+    return [s for s in workspace.repos if s.config.name in name_set]