canopy-cli 3.1.0__py3-none-any.whl

canopy/cli/render.py

@@ -0,0 +1,98 @@
+"""CLI rendering for action errors and results.
+
+Mirrors the structured shape from canopy.actions.errors so the human-facing
+output and the agent-facing JSON describe the same thing. The renderer
+accepts either a live ``ActionError`` instance or a serialized ``dict``
+(useful when the source is an MCP response).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+
+from ..actions.errors import ActionError
+from .ui import console as default_console
+
+
+_STATUS_GLYPH = {"blocked": "✗", "failed": "✗"}
+_STATUS_LABEL = {"blocked": "blocked", "failed": "failed"}
+
+
+def render_blocker(
+    err: ActionError | dict[str, Any],
+    *,
+    action: str | None = None,
+    console: Console | None = None,
+) -> None:
+    """Render a structured error to the console.
+
+    Args:
+        err: an ``ActionError`` or a ``to_dict()``-shaped dict.
+        action: name of the action that produced the error (e.g., ``"ship"``).
+            Used for the header line. Optional but recommended.
+        console: rich Console to write to. Defaults to canopy's themed one.
+    """
+    out = console or default_console
+    payload = err.to_dict() if isinstance(err, ActionError) else dict(err)
+
+    status = payload.get("status", "failed")
+    code = payload.get("code", "unknown")
+    what = payload.get("what", "")
+    glyph = _STATUS_GLYPH.get(status, "✗")
+    label = _STATUS_LABEL.get(status, status)
+    head = f"{action or 'action'} {label}: {what}" if what else f"{action or 'action'} {label}: {code}"
+
+    out.print()
+    out.print(f"  [error]{glyph}[/] {head}  [muted]({code})[/]")
+
+    expected = payload.get("expected")
+    actual = payload.get("actual")
+    if expected is not None or actual is not None:
+        out.print()
+        if expected is not None:
+            out.print(f"    [muted]expected:[/]  {_fmt_value(expected)}")
+        if actual is not None:
+            out.print(f"    [muted]actual:  [/]  {_fmt_value(actual)}")
+
+    fix_actions = payload.get("fix_actions") or []
+    if fix_actions:
+        out.print()
+        out.print("    [header]fix:[/]")
+        for fa in fix_actions:
+            label_parts = [f"canopy {fa['action']}"]
+            args = fa.get("args") or {}
+            for k, v in args.items():
+                if k == "feature":
+                    label_parts.append(str(v))
+                elif isinstance(v, bool) and v:
+                    label_parts.append(f"--{k}")
+                elif not isinstance(v, bool):
+                    label_parts.append(f"--{k} {v}")
+            cmd = " ".join(label_parts)
+            tag = "[muted](safe)[/]" if fa.get("safe") else "[warning](needs review)[/]"
+            out.print(f"      [info]{cmd}[/]  {tag}")
+            preview = fa.get("preview")
+            if preview:
+                out.print(f"        [muted]{preview}[/]")
+
+    details = payload.get("details") or {}
+    if details:
+        out.print()
+        out.print("    [muted]details:[/]")
+        for k, v in details.items():
+            out.print(f"      [muted]{k}:[/] {_fmt_value(v)}")
+    out.print()
+
+
+def _fmt_value(v: Any) -> str:
+    """Render a value compactly. Dicts inline as key=value pairs, lists as commas."""
+    if isinstance(v, dict):
+        if not v:
+            return "{}"
+        return ", ".join(f"{k}={_fmt_value(val)}" for k, val in v.items())
+    if isinstance(v, (list, tuple)):
+        if not v:
+            return "[]"
+        return ", ".join(_fmt_value(x) for x in v)
+    return str(v)

canopy/cli/ui.py

@@ -0,0 +1,150 @@
+"""
+Rich CLI UI helpers for canopy.
+
+Provides consistent styling, spinners, and formatting across all commands.
+All human-readable output goes through these helpers. --json output bypasses them.
+"""
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Generator
+
+from rich.console import Console
+from rich.theme import Theme
+from rich.tree import Tree
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.spinner import Spinner
+from rich.live import Live
+from rich.status import Status
+
+# ── Theme ────────────────────────────────────────────────────────────────
+
+CANOPY_THEME = Theme({
+    "header":    "bold",                    # weight, not color — let default-fg shine
+    "subheader": "bold dim",
+    "repo":      "bold",
+    "branch":    "color(180)",              # muted khaki
+    "feature":   "bold color(218)",         # soft pink — primary accent
+    "path":      "color(245)",              # warm grey
+    "dirty":     "color(218)",              # soft pink (dirty ≠ error)
+    "clean":     "dim",
+    "ahead":     "color(151)",              # sage
+    "behind":    "color(174)",              # dusty rose
+    "info":      "dim",
+    "success":   "color(151)",              # sage
+    "warning":   "color(218)",              # soft pink
+    "error":     "bold color(174)",         # dusty rose
+    "muted":     "color(244)",              # warm grey, slightly darker
+    "linear":    "color(146)",              # muted lavender
+})
+
+console = Console(theme=CANOPY_THEME)
+
+
+# ── Symbols ──────────────────────────────────────────────────────────────
+
+SYM_CHECK = "✓"
+SYM_CROSS = "✗"
+SYM_DOT = "●"
+SYM_ARROW = "→"
+SYM_TREE = "├──"
+SYM_TREE_LAST = "└──"
+SYM_BRANCH = "⎇"
+SYM_DIRTY = "◌"
+SYM_CLEAN = "◉"
+SYM_LINK = "↗"
+
+
+# ── Spinners ─────────────────────────────────────────────────────────────
+
+@contextmanager
+def spinner(message: str) -> Generator[Status, None, None]:
+    """Show a spinner while work is in progress."""
+    with console.status(f"[info]{message}[/]", spinner="dots") as status:
+        yield status
+
+
+# ── Formatters ───────────────────────────────────────────────────────────
+
+def status_badge(dirty: bool, dirty_count: int = 0) -> str:
+    """Format a dirty/clean status badge."""
+    if dirty:
+        label = f"{dirty_count} dirty" if dirty_count else "dirty"
+        return f"[dirty]{SYM_DIRTY} {label}[/]"
+    return f"[clean]{SYM_CLEAN} clean[/]"
+
+
+def divergence_str(ahead: int = 0, behind: int = 0) -> str:
+    """Format ahead/behind as colored arrows."""
+    parts = []
+    if ahead:
+        parts.append(f"[ahead]↑{ahead}[/]")
+    if behind:
+        parts.append(f"[behind]↓{behind}[/]")
+    return " ".join(parts)
+
+
+def repo_line(name: str, branch: str = "", dirty: bool = False,
+              dirty_count: int = 0, ahead: int = 0, behind: int = 0,
+              path: str = "") -> Text:
+    """Build a formatted line for a repo entry."""
+    text = Text()
+    text.append(f"  {name}", style="repo")
+    if branch:
+        text.append(f"  {SYM_BRANCH} ", style="muted")
+        text.append(branch, style="branch")
+
+    parts = []
+    if dirty:
+        label = f"{dirty_count} dirty" if dirty_count else "dirty"
+        parts.append(f"[dirty]{label}[/]")
+    if ahead:
+        parts.append(f"[ahead]+{ahead}[/]")
+    if behind:
+        parts.append(f"[behind]-{behind}[/]")
+    if parts:
+        text.append("  ")
+        # Can't use rich markup inside Text.append, so use plain
+        text.append("(", style="muted")
+        for i, p in enumerate(parts):
+            if "dirty" in p:
+                text.append(p.replace("[dirty]", "").replace("[/]", ""), style="dirty")
+            elif "+" in p:
+                text.append(p.replace("[ahead]", "").replace("[/]", ""), style="ahead")
+            elif "-" in p:
+                text.append(p.replace("[behind]", "").replace("[/]", ""), style="behind")
+            if i < len(parts) - 1:
+                text.append(", ", style="muted")
+        text.append(")", style="muted")
+
+    if path:
+        text.append(f"\n    {path}", style="path")
+    return text
+
+
+def section_header(title: str) -> None:
+    """Print a section header."""
+    console.print()
+    console.print(f"  [header]{title}[/]")
+
+
+def print_success(message: str) -> None:
+    """Print a success message with checkmark."""
+    console.print(f"  [success]{SYM_CHECK}[/] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"  [warning]![/] {message}")
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"  [error]{SYM_CROSS}[/] {message}")
+
+
+def separator() -> None:
+    """Print a dim separator line."""
+    console.print(f"  [muted]{'─' * 52}[/]")

canopy/features/__init__.py

@@ -0,0 +1,2 @@
+"""Feature lane coordination."""
+from .coordinator import FeatureLane, FeatureCoordinator