canopy-cli 3.1.0__py3-none-any.whl

canopy/actions/bootstrap.py

@@ -0,0 +1,249 @@
+"""``canopy worktree bootstrap`` — env files, deps, IDE workspace (M6).
+
+Three optional steps, gated per repo + per invocation:
+
+  1. **Env file copy** — per-repo ``env_files`` lists files (relative to
+     repo root) to copy from the main checkout into the worktree.
+  2. **Dependency install** — per-repo ``install_cmd`` runs once in the
+     worktree directory (e.g. ``uv sync`` / ``pnpm install``).
+  3. **IDE workspace file** — workspace-level ``ide = "vscode"`` writes
+     ``.canopy/workspaces/<feature>.code-workspace`` listing every
+     worktree dir for the feature.
+
+Each step is **off by default**. When the relevant config exists, the
+caller must pass ``bootstrap=True`` (or set ``bootstrap_default = true``
+in ``[workspace]``).
+
+Failure of any step doesn't roll back the worktree — the worktree is
+still valid. The caller can re-run ``canopy worktree bootstrap`` to
+retry just the failed step.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Iterable
+
+from ..workspace.workspace import Workspace
+from .aliases import resolve_feature
+from .errors import BlockerError
+from .ide_workspace import render_code_workspace
+
+ALLOWED_STEPS = ("env", "deps", "ide")
+
+
+def bootstrap_feature(
+    workspace: Workspace,
+    feature: str,
+    *,
+    force: bool = False,
+    steps: Iterable[str] | None = None,
+) -> dict[str, Any]:
+    """Run all three steps for every repo in a feature.
+
+    Args:
+        workspace: loaded workspace.
+        feature: feature alias.
+        force: overwrite existing destination env files.
+        steps: subset of {"env", "deps", "ide"} to run; default = all.
+
+    Returns ``{feature, results: {<repo>: {env, deps}}, ide}``.
+    Per-step result shape::
+
+        env  → {status: "ok"|"skipped"|"missing_source", files_copied: [...]}
+        deps → {status: "ok"|"failed"|"skipped", exit_code, duration_ms,
+                stderr_tail?}
+        ide  → {status: "ok"|"skipped"|"no_ide_configured", path?}
+    """
+    feature_name = resolve_feature(workspace, feature)
+    chosen_steps = _validate_steps(steps)
+    worktree_paths = _resolve_worktree_paths(workspace, feature_name)
+
+    if not worktree_paths:
+        raise BlockerError(
+            code="no_worktrees",
+            what=f"feature '{feature_name}' has no worktree paths recorded",
+        )
+
+    results: dict[str, dict[str, Any]] = {}
+    for repo_name, worktree_path in worktree_paths.items():
+        results[repo_name] = bootstrap_repo(
+            workspace, feature_name, repo_name, worktree_path,
+            force=force, steps=chosen_steps,
+        )
+
+    ide_result: dict[str, Any]
+    if "ide" in chosen_steps and workspace.config.ide and workspace.config.ide != "none":
+        ide_result = _write_ide_workspace(workspace, feature_name, worktree_paths)
+    else:
+        ide_result = {"status": "no_ide_configured"} if "ide" in chosen_steps else {"status": "skipped"}
+
+    return {
+        "feature": feature_name,
+        "results": results,
+        "ide": ide_result,
+    }
+
+
+def bootstrap_repo(
+    workspace: Workspace,
+    feature_name: str,
+    repo_name: str,
+    worktree_path: Path,
+    *,
+    force: bool = False,
+    steps: Iterable[str] = ALLOWED_STEPS,
+) -> dict[str, Any]:
+    """Run env-copy + deps-install for a single repo's worktree."""
+    chosen = set(steps)
+    state = workspace.get_repo(repo_name)
+    main_path = state.abs_path
+    repo_config = state.config
+
+    env_result: dict[str, Any] = {"status": "skipped", "files_copied": []}
+    if "env" in chosen:
+        if repo_config.env_files:
+            env_result = _copy_env_files(
+                repo_config.env_files, main_path, worktree_path, force=force,
+            )
+        else:
+            env_result = {"status": "skipped", "files_copied": [],
+                           "reason": "no env_files configured"}
+
+    deps_result: dict[str, Any] = {"status": "skipped"}
+    if "deps" in chosen:
+        if repo_config.install_cmd:
+            deps_result = _run_install(repo_config.install_cmd, worktree_path)
+        else:
+            deps_result = {"status": "skipped", "reason": "no install_cmd configured"}
+
+    return {"env": env_result, "deps": deps_result}
+
+
+# ── step 1: env-file copy ──────────────────────────────────────────────
+
+def _copy_env_files(
+    env_files: list[str],
+    src_dir: Path,
+    dst_dir: Path,
+    *,
+    force: bool,
+) -> dict[str, Any]:
+    """Copy each file relative to ``src_dir`` into ``dst_dir``.
+
+    Missing source files surface as ``missing_source`` per file but
+    don't block the others. Existing destinations are skipped unless
+    ``force=True``.
+    """
+    copied: list[str] = []
+    skipped: list[str] = []
+    missing: list[str] = []
+    for rel in env_files:
+        src = src_dir / rel
+        dst = dst_dir / rel
+        if not src.exists():
+            missing.append(rel)
+            continue
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        if dst.exists() and not force:
+            skipped.append(rel)
+            continue
+        shutil.copy2(src, dst)
+        copied.append(rel)
+
+    if missing and not copied and not skipped:
+        status = "missing_source"
+    elif copied or skipped:
+        status = "ok"
+    else:
+        status = "skipped"
+
+    out: dict[str, Any] = {
+        "status": status,
+        "files_copied": copied,
+    }
+    if skipped:
+        out["files_skipped"] = skipped
+    if missing:
+        out["files_missing"] = missing
+    return out
+
+
+# ── step 2: dep install ────────────────────────────────────────────────
+
+def _run_install(install_cmd: str, worktree_path: Path) -> dict[str, Any]:
+    """Run ``install_cmd`` in ``worktree_path`` and capture exit + duration."""
+    import time
+    start = time.monotonic()
+    proc = subprocess.run(
+        install_cmd, shell=True, cwd=worktree_path,
+        capture_output=True, text=True,
+    )
+    duration_ms = int((time.monotonic() - start) * 1000)
+    out: dict[str, Any] = {
+        "status": "ok" if proc.returncode == 0 else "failed",
+        "exit_code": proc.returncode,
+        "duration_ms": duration_ms,
+    }
+    if proc.returncode != 0:
+        # Tail the last few lines of stderr — full output would balloon
+        # the JSON return for the dashboard. Caller can rerun manually
+        # for full output if needed.
+        tail = "\n".join(proc.stderr.splitlines()[-10:])
+        out["stderr_tail"] = tail
+    return out
+
+
+# ── step 3: IDE workspace file ─────────────────────────────────────────
+
+def _write_ide_workspace(
+    workspace: Workspace,
+    feature_name: str,
+    worktree_paths: dict[str, Path],
+) -> dict[str, Any]:
+    """Write ``.canopy/workspaces/<feature>.code-workspace`` atomically."""
+    if workspace.config.ide != "vscode":
+        return {"status": "skipped",
+                "reason": f"ide={workspace.config.ide!r} not supported (vscode only in v1)"}
+    ws_dir = workspace.config.root / ".canopy" / "workspaces"
+    ws_dir.mkdir(parents=True, exist_ok=True)
+    out_path = ws_dir / f"{feature_name}.code-workspace"
+    body = render_code_workspace(workspace, feature_name, worktree_paths)
+    tmp = out_path.with_suffix(out_path.suffix + ".tmp")
+    tmp.write_text(body)
+    tmp.replace(out_path)
+    return {"status": "ok", "path": str(out_path)}
+
+
+# ── helpers ────────────────────────────────────────────────────────────
+
+def _validate_steps(steps: Iterable[str] | None) -> set[str]:
+    if steps is None:
+        return set(ALLOWED_STEPS)
+    chosen = set(steps)
+    bad = chosen - set(ALLOWED_STEPS)
+    if bad:
+        raise BlockerError(
+            code="unknown_bootstrap_step",
+            what=f"unknown step(s): {sorted(bad)}",
+            expected={"allowed_steps": list(ALLOWED_STEPS)},
+        )
+    return chosen
+
+
+def _resolve_worktree_paths(
+    workspace: Workspace, feature_name: str,
+) -> dict[str, Path]:
+    """Pull recorded worktree paths from features.json."""
+    import json
+    path = workspace.config.root / ".canopy" / "features.json"
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text("utf-8"))
+    except (OSError, ValueError):
+        return {}
+    entry = data.get(feature_name) or {}
+    raw = entry.get("worktree_paths") or {}
+    return {repo: Path(p) for repo, p in raw.items() if p}

canopy/actions/bot_resolutions.py

@@ -0,0 +1,123 @@
+"""Persistent log of bot review-comments addressed by canopy commits (M3).
+
+State file: ``<workspace_root>/.canopy/state/bot_resolutions.json``
+
+Schema (an append-only mapping; each key is a stringified GitHub comment ID)::
+
+    {
+      "123456": {
+        "feature": "sin-6-cache-stats",
+        "repo": "test-api",
+        "commit_sha": "abc123de",
+        "addressed_at": "2026-05-02T17:30:00Z",
+        "comment_title": "rename hit_rate to cache_hit_rate",
+        "comment_url": "https://github.com/owner/repo/pull/142#discussion_r123456"
+      }
+    }
+
+Written by ``commit --address``; read by the ``bot_comments_status`` rollup
+and by ``feature_state`` to subtract resolved bot comments from the
+actionable count surfaced in the agent dashboard.
+
+Writes are atomic (temp file + ``os.replace``) so concurrent record calls
+across worktrees don't corrupt the file.
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+_STATE_DIR = ".canopy/state"
+_STATE_FILE = "bot_resolutions.json"
+
+
+def _state_path(workspace_root: Path) -> Path:
+    return workspace_root / _STATE_DIR / _STATE_FILE
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def load_resolutions(workspace_root: Path) -> dict[str, dict[str, Any]]:
+    """Read the resolution log. Returns an empty dict when no file exists."""
+    path = _state_path(workspace_root)
+    if not path.exists():
+        return {}
+    try:
+        with open(path, "r") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def is_resolved(workspace_root: Path, comment_id: str | int) -> bool:
+    """True iff this comment id is in the resolution log."""
+    return str(comment_id) in load_resolutions(workspace_root)
+
+
+def resolutions_for_feature(
+    workspace_root: Path, feature: str,
+) -> dict[str, dict[str, Any]]:
+    """Filter the log to entries tagged with this feature name."""
+    return {
+        cid: entry
+        for cid, entry in load_resolutions(workspace_root).items()
+        if entry.get("feature") == feature
+    }
+
+
+def record_resolution(
+    workspace_root: Path,
+    *,
+    comment_id: str | int,
+    feature: str,
+    repo: str,
+    commit_sha: str,
+    comment_title: str,
+    comment_url: str = "",
+    addressed_at: str | None = None,
+) -> dict[str, Any]:
+    """Append a resolution entry. Last-write-wins on duplicate comment_id.
+
+    Returns the entry written. Creates the state directory if missing.
+    """
+    path = _state_path(workspace_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing = load_resolutions(workspace_root)
+    entry = {
+        "feature": feature,
+        "repo": repo,
+        "commit_sha": commit_sha,
+        "addressed_at": addressed_at or _now_iso(),
+        "comment_title": comment_title,
+        "comment_url": comment_url,
+    }
+    existing[str(comment_id)] = entry
+    _atomic_write(path, existing)
+    return entry
+
+
+def _atomic_write(path: Path, data: dict) -> None:
+    """Write JSON atomically: tmp file in same dir, then os.replace."""
+    fd, tmp = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=str(path.parent),
+    )
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=2, sort_keys=True)
+            f.write("\n")
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except FileNotFoundError:
+            pass
+        raise

canopy/actions/bot_status.py

@@ -0,0 +1,133 @@
+"""Per-feature bot-comment rollup (M3).
+
+Composes the live actionable bot threads (from ``feature_state._per_repo_facts``)
+with the persistent resolution log (``bot_resolutions.json``) into a single
+``{feature, repos: {<repo>: {pr_number, total, resolved, unresolved, threads}},
+all_resolved}`` shape that the CLI / MCP / dashboard share.
+
+A "bot comment" here means an actionable thread whose author was classified as
+a bot per ``feature_state._is_bot_comment`` (GitHub-typed bot AND, when
+``review_bots`` is set in canopy.toml augments, substring-matching the
+configured list).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from . import slots as slots_mod
+from .aliases import repos_for_feature, resolve_feature
+from .bot_resolutions import resolutions_for_feature
+from .errors import BlockerError, FixAction
+from .feature_state import _per_repo_facts, resolve_repo_paths
+from ..workspace.workspace import Workspace
+
+
+def bot_comments_status(
+    workspace: Workspace,
+    feature: str | None = None,
+) -> dict[str, Any]:
+    """Build the rollup. Falls back to the canonical feature when ``feature`` is None."""
+    feature_name = _resolve_feature_name(workspace, feature)
+    repo_branches = repos_for_feature(workspace, feature_name)
+    if not repo_branches:
+        raise BlockerError(
+            code="empty_feature",
+            what=f"feature '{feature_name}' has no associated repos",
+        )
+
+    repo_paths, _has_wt = resolve_repo_paths(workspace, feature_name, repo_branches)
+    facts = _per_repo_facts(workspace, feature_name, repo_branches, repo_paths)
+    resolutions = resolutions_for_feature(workspace.config.root, feature_name)
+
+    repos_out: dict[str, dict[str, Any]] = {}
+    all_resolved = True
+    any_bot_comment_seen = False
+
+    for repo_name, repo_facts in facts.items():
+        pr = repo_facts.get("pr") or {}
+        bot_threads = repo_facts.get("actionable_bot_threads", [])
+        # Resolution entries scoped to this repo (so we report a sensible
+        # `resolved` count per PR even when other repos have their own).
+        repo_resolutions = {
+            cid: entry
+            for cid, entry in resolutions.items()
+            if entry.get("repo") == repo_name
+        }
+        unresolved_threads = [
+            _thread_summary(t, resolved=False, resolution=None) for t in bot_threads
+        ]
+        resolved_threads = [
+            _resolved_summary(cid, entry)
+            for cid, entry in sorted(repo_resolutions.items())
+        ]
+        threads = resolved_threads + unresolved_threads
+
+        total = len(threads)
+        if total > 0:
+            any_bot_comment_seen = True
+        if unresolved_threads:
+            all_resolved = False
+
+        repos_out[repo_name] = {
+            "pr_number": pr.get("number"),
+            "pr_url": pr.get("url", ""),
+            "total": total,
+            "resolved": len(resolved_threads),
+            "unresolved": len(unresolved_threads),
+            "threads": threads,
+        }
+
+    return {
+        "feature": feature_name,
+        "repos": repos_out,
+        "all_resolved": all_resolved if any_bot_comment_seen else True,
+        "any_bot_comments": any_bot_comment_seen,
+    }
+
+
+def _resolve_feature_name(workspace: Workspace, feature: str | None) -> str:
+    if feature:
+        return resolve_feature(workspace, feature)
+    state = slots_mod.read_state(workspace)
+    if state is None or state.canonical is None:
+        raise BlockerError(
+            code="no_canonical_feature",
+            what="no active feature; pass --feature or run `canopy switch <name>` first",
+            fix_actions=[
+                FixAction(action="switch", args={}, safe=False,
+                          preview="canopy switch <feature> sets the canonical slot"),
+            ],
+        )
+    return state.canonical.feature
+
+
+def _thread_summary(
+    thread: dict, *, resolved: bool, resolution: dict | None,
+) -> dict[str, Any]:
+    out = {
+        "id": thread.get("id"),
+        "author": thread.get("author", ""),
+        "path": thread.get("path", ""),
+        "line": thread.get("line", 0),
+        "url": thread.get("url", ""),
+        "body_preview": (thread.get("body") or "").splitlines()[0][:120] if thread.get("body") else "",
+        "resolved": resolved,
+    }
+    if resolution:
+        out["resolved_by_commit"] = resolution.get("commit_sha", "")
+        out["addressed_at"] = resolution.get("addressed_at", "")
+    return out
+
+
+def _resolved_summary(comment_id: str, entry: dict) -> dict[str, Any]:
+    return {
+        "id": comment_id,
+        "author": "",
+        "path": "",
+        "line": 0,
+        "url": entry.get("comment_url", ""),
+        "body_preview": entry.get("comment_title", ""),
+        "resolved": True,
+        "resolved_by_commit": entry.get("commit_sha", ""),
+        "addressed_at": entry.get("addressed_at", ""),
+    }