devvy 0.1.0__py3-none-any.whl

cli/ui/__init__.py

@@ -0,0 +1,55 @@
+"""cli.ui — public API re-exports.
+
+All callers that do ``from cli.ui import <symbol>`` continue to work
+unchanged after the module was split into sub-modules.
+"""
+
+from cli.ui.rendering import (
+    _TERMINAL_STATES,
+    _STATE_COLOURS,
+    _fmt_dt,
+    _format_elapsed,
+    _infer_section_title,
+    _LOG_SECTION_PATTERNS,
+    _pid_alive,
+    _print_outcome,
+    console,
+    err_console,
+    pid_status_text,
+    print_resume_banner,
+    print_run_banner,
+    print_status_panel,
+    ProgressTracker,
+    render_logs,
+    state_text,
+)
+from cli.ui.picker import (
+    pick_model,
+    _plain_model_prompt,
+    _rich_picker,
+)
+
+__all__ = [
+    # rendering
+    "_TERMINAL_STATES",
+    "_STATE_COLOURS",
+    "_fmt_dt",
+    "_format_elapsed",
+    "_infer_section_title",
+    "_LOG_SECTION_PATTERNS",
+    "_pid_alive",
+    "_print_outcome",
+    "console",
+    "err_console",
+    "pid_status_text",
+    "print_resume_banner",
+    "print_run_banner",
+    "print_status_panel",
+    "ProgressTracker",
+    "render_logs",
+    "state_text",
+    # picker
+    "pick_model",
+    "_plain_model_prompt",
+    "_rich_picker",
+]

cli/ui/picker.py

@@ -0,0 +1,179 @@
+"""Interactive model picker for the devvy init command.
+
+Falls back to a plain numbered prompt in non-TTY environments (e.g. CI,
+CliRunner tests).  In a real terminal, renders an inline arrow-key picker
+using raw ANSI escape codes.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from cli.ui.rendering import console
+
+
+def pick_model(choices: list[str], default: str) -> str:
+    """
+    Interactive arrow-key model picker rendered with rich.
+
+    Falls back to a plain input() prompt if the terminal is not a TTY
+    or if raw-mode setup fails.
+
+    Returns the selected model string.
+    """
+    if not sys.stdin.isatty():
+        return _plain_model_prompt(choices, default)
+
+    try:
+        return _rich_picker(choices, default)
+    except Exception:
+        return _plain_model_prompt(choices, default)
+
+
+def _plain_model_prompt(choices: list[str], default: str) -> str:
+    """Simple numbered fallback for non-TTY environments."""
+    console.print("\n[bold]Available models:[/bold]")
+    for i, c in enumerate(choices, 1):
+        marker = " [bold cyan]←[/bold cyan]" if c == default else ""
+        console.print(f"  [dim]{i:2}.[/dim] {c}{marker}")
+    raw = input(f"\nModel number or name [{default}]: ").strip()
+    if not raw:
+        return default
+    if raw.isdigit():
+        idx = int(raw) - 1
+        if 0 <= idx < len(choices):
+            return choices[idx]
+    if raw in choices:
+        return raw
+    return default
+
+
+def _rich_picker(choices: list[str], default: str) -> str:
+    """
+    Inline arrow-key model picker using raw terminal input.
+
+    Renders directly to the terminal using ANSI escape codes — no rich.live.Live,
+    which is unreliable when content height changes or approaches terminal height.
+
+    Keys: ↑/k  move up, ↓/j  move down, Home, End, Enter to confirm.
+    """
+    import os
+    import termios
+    import tty
+
+    selected = choices.index(default) if default in choices else 0
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+
+    # ANSI helpers
+    HIDE_CURSOR = "\033[?25l"
+    SHOW_CURSOR = "\033[?25h"
+    CLEAR_LINE = "\033[2K"
+    UP = "\033[{n}A"
+    BOL = "\r"  # beginning of line
+
+    def _visible_rows() -> int:
+        try:
+            term_rows = os.get_terminal_size().lines
+        except OSError:
+            term_rows = 24
+        # Reserve rows for: header (3 lines) + 2 indicator lines + 1 bottom blank
+        return min(len(choices), max(1, term_rows - 8))
+
+    def _build_lines(selected_idx: int) -> list[str]:
+        """Return the list of plain strings (no Rich markup) to render."""
+        visible = _visible_rows()
+        start = max(0, selected_idx - visible // 2)
+        end = min(len(choices), start + visible)
+        start = max(0, end - visible)  # clamp near bottom
+
+        out: list[str] = []
+        out.append("")
+        out.append("  Select opencode model  (↑/↓ to move, Enter to confirm)")
+        out.append("")
+
+        if start > 0:
+            out.append(f"    ↑ {start} more above")
+
+        for idx in range(start, end):
+            label = choices[idx]
+            if idx == selected_idx:
+                # Bold + reverse video (works in every terminal)
+                out.append(f"  \033[1;7m ▶  {label} \033[0m")
+            else:
+                out.append(f"  \033[2m   {label}\033[0m")
+
+        below = len(choices) - end
+        if below > 0:
+            out.append(f"    ↓ {below} more below")
+
+        out.append("")
+        return out
+
+    # Track how many lines we've printed so we can erase and redraw in place.
+    last_line_count = 0
+
+    def _draw(selected_idx: int) -> None:
+        nonlocal last_line_count
+        lines = _build_lines(selected_idx)
+
+        out_parts: list[str] = []
+
+        # Move cursor up to the first line of the previous render, then
+        # overwrite every line in place.
+        if last_line_count > 0:
+            out_parts.append(UP.format(n=last_line_count - 1))
+
+        for i, line in enumerate(lines):
+            out_parts.append(BOL)
+            out_parts.append(CLEAR_LINE)
+            out_parts.append(line)
+            if i < len(lines) - 1:
+                out_parts.append("\n")
+
+        sys.stdout.write("".join(out_parts))
+        sys.stdout.flush()
+        last_line_count = len(lines)
+
+    try:
+        sys.stdout.write(HIDE_CURSOR)
+        sys.stdout.flush()
+        tty.setraw(fd)
+
+        _draw(selected)
+
+        while True:
+            ch = sys.stdin.read(1)
+
+            if ch in ("\r", "\n"):
+                break
+            elif ch == "\x1b":
+                seq = sys.stdin.read(2)
+                if seq == "[A":  # Up arrow
+                    selected = max(0, selected - 1)
+                elif seq == "[B":  # Down arrow
+                    selected = min(len(choices) - 1, selected + 1)
+                elif seq == "[H":  # Home
+                    selected = 0
+                elif seq == "[F":  # End
+                    selected = len(choices) - 1
+                else:
+                    continue
+            elif ch in ("k", "K"):
+                selected = max(0, selected - 1)
+            elif ch in ("j", "J"):
+                selected = min(len(choices) - 1, selected + 1)
+            elif ch == "\x03":  # Ctrl-C
+                raise KeyboardInterrupt
+            else:
+                continue
+
+            _draw(selected)
+
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        sys.stdout.write(SHOW_CURSOR + "\n")
+        sys.stdout.flush()
+
+    return choices[selected]

cli/ui/rendering.py

@@ -0,0 +1,350 @@
+"""Terminal rendering helpers — banners, progress tracking, status panels,
+and log rendering.  All output goes through the shared ``console`` and
+``err_console`` instances defined here.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+
+from cli.fsm import TicketState
+
+if TYPE_CHECKING:
+    from cli.models import GraphContext, Ticket
+
+# stdout console — primary output
+console = Console()
+
+# stderr console — errors / warnings only
+err_console = Console(stderr=True)
+
+# Terminal states — derived from the FSM so there's a single source of truth.
+_TERMINAL_STATES = {s.value for s in TicketState if s.is_terminal}
+
+# Human-readable labels with leading emoji/symbol handled at render time.
+_STATE_COLOURS = {
+    "RECEIVED": "yellow",
+    "PREPARE_ENV": "yellow",
+    "PLAN": "yellow",
+    "IMPLEMENT": "yellow",
+    "VALIDATE": "yellow",
+    "CREATE_PR": "yellow",
+    "WAIT_FOR_REVIEW": "cyan",
+    "RESPOND_TO_REVIEW": "yellow",
+    "MERGED": "green",
+    "FAILED": "red",
+}
+
+
+def state_text(state: str) -> Text:
+    """Return a rich Text object for a state label with colour + symbol."""
+    colour = _STATE_COLOURS.get(state, "white")
+    if state == "MERGED":
+        symbol = "✓"
+    elif state == "FAILED":
+        symbol = "✗"
+    elif state == "WAIT_FOR_REVIEW":
+        symbol = "◷"
+    else:
+        symbol = "●"
+    return Text(f"{symbol} {state}", style=f"bold {colour}")
+
+
+def pid_status_text(pid: int | None, state: str) -> Text:
+    """Return a rich Text badge describing the live/crashed/idle run status.
+
+    Logic:
+    - Terminal state → empty (no process badge needed).
+    - Non-terminal + pid set + process alive  → "Running (pid <n>)"
+    - Non-terminal + pid set + process dead   → "Crashed  (pid <n>)"
+    - Non-terminal + pid is None              → "Idle / resumable"
+    """
+    terminal_states = {s.value for s in TicketState if s.is_terminal}
+    if state in terminal_states:
+        return Text("")
+
+    if pid is not None:
+        alive = _pid_alive(pid)
+        if alive:
+            return Text(f"Running (pid {pid})", style="bold green")
+        else:
+            return Text(f"Crashed  (pid {pid})", style="bold red")
+
+    return Text("Idle / resumable", style="dim yellow")
+
+
+def _pid_alive(pid: int) -> bool:
+    """Return True if a process with *pid* is currently running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # Process exists but we don't own it — treat as alive.
+        return True
+
+
+def print_run_banner(ticket_id: str, title: str, repo_url: str) -> None:
+    """Print the styled ticket start banner."""
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+    table.add_row("[dim]title[/dim]", title)
+    table.add_row("[dim]repo[/dim]", repo_url)
+    table.add_row("[dim]id[/dim]", f"[dim]{ticket_id}[/dim]")
+    console.print(
+        Panel(table, title="[bold]devvy[/bold]", border_style="blue", padding=(1, 2))
+    )
+
+
+def print_resume_banner(
+    ticket_id: str, title: str, state: str, branch: str | None, pr_number: int | None
+) -> None:
+    """Print the styled resume banner."""
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+    table.add_row("[dim]title[/dim]", title)
+    table.add_row("[dim]state[/dim]", state_text(state))
+    table.add_row("[dim]branch[/dim]", branch or "[dim]—[/dim]")
+    table.add_row("[dim]pr[/dim]", str(pr_number) if pr_number else "[dim]—[/dim]")
+    table.add_row("[dim]id[/dim]", f"[dim]{ticket_id}[/dim]")
+    console.print(
+        Panel(
+            table,
+            title="[bold]devvy resume[/bold]",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
+
+
+class ProgressTracker:
+    """
+    Tracks FSM state transitions and renders spinner lines to the console.
+
+    Usage
+    -----
+    Create an instance, pass ``tracker.on_state_change`` as the
+    ``status_callback`` to ``Orchestrator.run()``, then call
+    ``tracker.finish()`` after the orchestrator returns.
+
+    The tracker starts an internal timer when the first state fires, then
+    for every subsequent state it prints a "completed" line for the previous
+    state (with elapsed time) and starts a new live spinner line.
+    """
+
+    # States we label differently while they're in-progress
+    _SPINNER_LABELS: dict[str, str] = {
+        "WAIT_FOR_REVIEW": "Waiting for PR review…",
+        "PLAN": "Planning…",
+        "IMPLEMENT": "Implementing…",
+        "VALIDATE": "Running validation…",
+        "PREPARE_ENV": "Preparing environment…",
+        "CREATE_PR": "Creating PR…",
+        "RESPOND_TO_REVIEW": "Responding to review…",
+        "RECEIVED": "Received…",
+        "MERGED": "Merging…",
+        "FAILED": "Failing…",
+    }
+
+    def __init__(self) -> None:
+        self._current_state: str | None = None
+        self._state_start: float = 0.0
+
+    def on_state_change(self, state: str) -> None:
+        """Called by the orchestrator when it enters a new state."""
+        now = time.monotonic()
+
+        # Print completed line for previous state
+        if self._current_state is not None:
+            elapsed = now - self._state_start
+            self._print_completed(self._current_state, elapsed)
+
+        self._current_state = state
+        self._state_start = now
+
+        # Print "in progress" line for the new state (non-spinner, since we're
+        # in a sync callback called from async context — live rendering would
+        # require a Live context, which we can't hold across async boundaries
+        # without threading).  Instead we print a simple "started" line and
+        # let the completed line show the elapsed time when it fires next.
+        if state not in _TERMINAL_STATES:
+            colour = _STATE_COLOURS.get(state, "white")
+            label = self._SPINNER_LABELS.get(state, state)
+            console.print(
+                f"  [bold {colour}]→[/bold {colour}]  [bold]{state}[/bold]  [dim]{label}[/dim]"
+            )
+
+    def finish(self, ticket: "Ticket") -> None:
+        """
+        Call after ``orchestrator.run()`` returns.  Closes out the last
+        state line and prints the final outcome panel.
+        """
+        now = time.monotonic()
+        if (
+            self._current_state is not None
+            and self._current_state not in _TERMINAL_STATES
+        ):
+            elapsed = now - self._state_start
+            self._print_completed(self._current_state, elapsed)
+
+        _print_outcome(ticket)
+
+    @staticmethod
+    def _print_completed(state: str, elapsed: float) -> None:
+        colour = _STATE_COLOURS.get(state, "white")
+        elapsed_str = _format_elapsed(elapsed)
+        console.print(
+            f"  [bold {colour}]✓[/bold {colour}]  [bold]{state}[/bold]"
+            f"  [dim]{elapsed_str}[/dim]"
+        )
+
+
+def _format_elapsed(seconds: float) -> str:
+    """Format a duration in seconds as '3s' or '1m 14s'."""
+    s = int(seconds)
+    if s < 60:
+        return f"{s}s"
+    m, s = divmod(s, 60)
+    return f"{m}m {s}s"
+
+
+def _print_outcome(ticket: "Ticket") -> None:
+    """Print the final merged / failed outcome panel."""
+    if ticket.state == "MERGED":
+        msg = Text("✓  PR merged successfully.", style="bold green")
+        console.print(Panel(msg, border_style="green", padding=(0, 2)))
+    else:
+        error = ticket.error_message or "unknown error"
+        msg = Text(f"✗  Failed: {error}", style="bold red")
+        console.print(Panel(msg, border_style="red", padding=(0, 2)))
+
+
+_DATETIME_FMT = "%d %b %Y, %H:%M UTC"
+
+
+def _fmt_dt(dt: datetime | None) -> str:
+    if dt is None:
+        return "—"
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt.strftime(_DATETIME_FMT)
+
+
+def print_status_panel(ticket: "Ticket", ctx: "GraphContext | None") -> None:
+    """Render the ticket status as a rich Panel."""
+    table = Table.grid(padding=(0, 2))
+    table.add_column(style="bold dim", min_width=10)
+    table.add_column()
+
+    table.add_row("id", f"[dim]{ticket.id}[/dim]")
+    table.add_row("title", ticket.title)
+    table.add_row("state", state_text(ticket.state))
+
+    # Process liveness badge — only meaningful for non-terminal tickets.
+    worker_pid = ctx.worker_pid if ctx else None
+    process_badge = pid_status_text(worker_pid, ticket.state)
+    if process_badge.plain:
+        table.add_row("process", process_badge)
+
+    table.add_row("branch", ticket.branch_name or "[dim]—[/dim]")
+    table.add_row("pr", str(ctx.pr_number) if ctx and ctx.pr_number else "[dim]—[/dim]")
+    table.add_row("retries", str(ctx.retry_count if ctx else 0))
+    table.add_row("created", _fmt_dt(ticket.created_at))
+    table.add_row("updated", _fmt_dt(ticket.updated_at))
+
+    if ticket.error_message:
+        table.add_row("error", f"[bold red]{ticket.error_message}[/bold red]")
+
+    # Panel border colour reflects terminal state
+    border = (
+        "green"
+        if ticket.state == "MERGED"
+        else "red"
+        if ticket.state == "FAILED"
+        else "cyan"
+        if ticket.state == "WAIT_FOR_REVIEW"
+        else "yellow"
+    )
+    title_text = Text(f"ticket · {ticket.id[:8]}", style="bold")
+    console.print(Panel(table, title=title_text, border_style=border, padding=(1, 2)))
+
+
+# Maps log message prefixes to a human-readable section title.
+# Matched in order — first match wins.
+_LOG_SECTION_PATTERNS: list[tuple[str, str]] = [
+    (r"Workspace:", "PREPARE_ENV"),
+    (r"Plan \(session", "PLAN"),
+    (r"Implementation:", "IMPLEMENT"),
+    (r"Validation:", "VALIDATE"),
+    (r"Self-fix:", "VALIDATE · self-fix"),
+    (r"PR description generated", "CREATE_PR · PR description"),
+    (r"PR #\d+ created:", "CREATE_PR"),
+    (r"Waiting for PR review", "WAIT_FOR_REVIEW"),
+    (r"ADO poll error:", "WAIT_FOR_REVIEW · error"),
+    (r"Review response:", "RESPOND_TO_REVIEW"),
+    (r"Posted reply to thread", "RESPOND_TO_REVIEW · reply"),
+    (r"Failed to post reply", "RESPOND_TO_REVIEW · error"),
+    (r"Ticket complete", "MERGED"),
+]
+
+
+def _infer_section_title(message: str) -> str:
+    for pattern, title in _LOG_SECTION_PATTERNS:
+        if re.match(pattern, message.lstrip()):
+            return title
+    return "LOG"
+
+
+def render_logs(log_text: str) -> None:
+    """Parse raw log blob and render as structured sections with rich rules."""
+    if not log_text.strip():
+        console.print("[dim]No logs yet.[/dim]")
+        return
+
+    # Split on lines that start with an ISO timestamp bracket, e.g.
+    # [2026-02-28T10:45:00.000000+00:00] message…
+    entry_re = re.compile(
+        r"^\[(\d{4}-\d{2}-\d{2}T[\d:.+\-]+)\] (.+)", re.DOTALL | re.MULTILINE
+    )
+
+    # We'll use findall for clarity.
+    entries = entry_re.findall(log_text)
+
+    if not entries:
+        # Fallback: just print the raw blob
+        console.print(log_text)
+        return
+
+    for ts_str, message in entries:
+        # Parse and reformat the timestamp
+        try:
+            dt = datetime.fromisoformat(ts_str)
+            ts_display = dt.strftime("%d %b %H:%M UTC")
+        except ValueError:
+            ts_display = ts_str
+
+        section_title = _infer_section_title(message)
+        colour = _STATE_COLOURS.get(section_title.split(" ")[0], "blue")
+
+        console.print(
+            Rule(
+                f"[bold {colour}]{section_title}[/bold {colour}]"
+                f"  [dim]{ts_display}[/dim]",
+                style="dim",
+            )
+        )
+        console.print(message.strip())
+        console.print()