refactorai-cli 0.7.19__tar.gz → 0.7.22__tar.gz

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.19
+Version: 0.7.22
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.7.19"
+version = "0.7.22"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli/__init__.py

@@ -5,4 +5,4 @@ the shared `refactor_core` pipeline from a project folder while staying
 authenticated to the hosted platform via a developer key.
 """
 
-__version__ = "0.7.19"
+__version__ = "0.7.22"

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli/commands/run_cmds.py

@@ -3329,28 +3329,16 @@ def review(
     sandbox_ctx = None
 
     try:
-        # Two orthogonal axes (docs/46): where the engine runs vs. where tests
-        # run. ``local_byok`` / ``local_managed`` use the remote (server) engine
-        # while verifying locally in the sandbox, so sandbox setup keys off
-        # verification location, and engine routing keys off engine location.
+        # Engine routing keys off engine location (docs/46). Review is *read-only*
+        # analysis: it produces findings / refactor requests and never executes
+        # verification (tests) locally. The container sandbox exists for that
+        # verification during ``code`` / ``refactor``, so provisioning + preflighting
+        # it here only added container start + ``exec`` probe latency (and could hang
+        # on the container runtime) for zero effect on the review result — the old
+        # ``sandbox_ctx`` was consumed solely to print a preflight warning. Sandbox
+        # readiness is therefore enforced lazily, when code is actually applied; use
+        # ``refactor sandbox start`` to validate the toolchain ahead of time.
         engine_remote = _engine_is_remote(constitution)
-        verify_local = _verify_local(constitution)
-        if _sandbox_enabled(project_config):
-            if verify_local:
-                sandbox_ctx = _ensure_sandbox_ready(
-                    project_root=project_root,
-                    project_config=project_config,
-                    stage="review",
-                    auto_approve_install=False,
-                    no_install=False,
-                    continue_on_preflight_failure=True,
-                )
-            else:
-                variant = _execution_variant(constitution)
-                console.print(
-                    f"[dim]review: sandbox.enabled is ignored in "
-                    f"{variant} variant (verification runs in the cloud).[/dim]"
-                )
         if engine_remote:
             artifact = _cloud_inference(
                 stage="review",

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli/commands/watch_cmds.py

@@ -14,8 +14,10 @@ headless). The heavy lifting (state machine, rendering, review parsing) lives in
 from __future__ import annotations
 
 import contextlib
+import inspect
 import json
 import os
+import re
 import select
 import subprocess
 import sys
@@ -461,6 +463,53 @@ def _report_refactor_requests(project_root: Path) -> None:
         pass
 
 
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+# Map the review's stable stdout milestones to short, live sub-step labels shown
+# on the reviewing node. Ordered: first match wins. Kept tolerant (substring /
+# simple regex) so minor wording changes degrade to "no update" rather than
+# crashing. Each entry is (compiled pattern, formatter(match) -> label).
+_PROGRESS_PATTERNS: list[tuple[re.Pattern[str], Callable[[re.Match[str]], str]]] = [
+    (re.compile(r"batch\s+(\d+)\s*/\s*(\d+)", re.I), lambda m: f"reviewing batch {m.group(1)}/{m.group(2)}"),
+    (re.compile(r"split into\s+(\d+)\s+batch", re.I), lambda m: f"planning {m.group(1)} batch(es)"),
+    (re.compile(r"sandbox ready", re.I), lambda m: "sandbox ready"),
+    (re.compile(r"ensuring sandbox|sandbox:", re.I), lambda m: "preparing sandbox"),
+    (re.compile(r"review scope", re.I), lambda m: "resolving scope"),
+    (re.compile(r"security baseline", re.I), lambda m: "security scan"),
+    (re.compile(r"Created\s+\d+\s+refactor request", re.I), lambda m: "creating requests"),
+    (re.compile(r"\bgate:\s*", re.I), lambda m: "finalizing gate"),
+    (re.compile(r"\bindex", re.I), lambda m: "indexing files"),
+]
+
+
+def _summarize_progress(line: str) -> str:
+    """Reduce one raw review stdout line to a short sub-step label, or ``""``.
+
+    Returns ``""`` for lines that carry no useful milestone so the caller can
+    skip a redundant repaint.
+    """
+    text = _ANSI_RE.sub("", line or "").strip()
+    if not text:
+        return ""
+    for pattern, fmt in _PROGRESS_PATTERNS:
+        match = pattern.search(text)
+        if match:
+            return fmt(match)
+    return ""
+
+
+def _runner_supports_on_progress(runner: ReviewRunner) -> bool:
+    """True when ``runner.run`` accepts an ``on_progress`` keyword.
+
+    Lets streaming be opt-in per runner so simple/test runners with the older
+    signature keep working unchanged.
+    """
+    try:
+        return "on_progress" in inspect.signature(runner.run).parameters
+    except (TypeError, ValueError):
+        return False
+
+
 def process_pending(
     project_root: Path,
     state: WatchState,
@@ -500,11 +549,27 @@ def process_pending(
             on_update(state)
         _report_node(project_root, node)
         intent = intent_for(node.sha) if intent_for else None
-        outcome = runner.run(
-            sha=node.sha,
-            intent=intent,
-            yes_full_project=(node.scope_mode == "full"),
-        )
+        run_kwargs: dict = {
+            "sha": node.sha,
+            "intent": intent,
+            "yes_full_project": (node.scope_mode == "full"),
+        }
+        # Stream live sub-steps into the reviewing node when the runner supports
+        # it, so a long review shows batch-by-batch progress instead of a static
+        # "analyzing..." spinner that looks hung.
+        if _runner_supports_on_progress(runner):
+            reviewing_sha = node.sha
+
+            def _on_progress(line: str, _sha: str = reviewing_sha) -> None:
+                label = _summarize_progress(line)
+                if not label:
+                    return
+                state.set_substep(_sha, label)
+                if on_update:
+                    on_update(state)
+
+            run_kwargs["on_progress"] = _on_progress
+        outcome = runner.run(**run_kwargs)
         if outcome.run_id:
             outcome.rr_preview = _preview_for_run(project_root, outcome.run_id)
         state.apply_outcome(node.sha, outcome)

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli/review_runner.py

@@ -14,12 +14,15 @@ machine without spawning a subprocess or needing the engine.
 
 from __future__ import annotations
 
+import contextlib
 import os
 import re
+import signal
 import subprocess
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Protocol
+from typing import Callable, Protocol
 
 _ANSI = re.compile(r"\x1b\[[0-9;]*m")
 _SCOPE_COUNTS = re.compile(r"(\d+)\s+changed\s*\+\s*(\d+)\s+associated")
@@ -58,6 +61,7 @@ class ReviewRunner(Protocol):
         sha: str,
         intent: str | None = None,
         yes_full_project: bool = False,
+        on_progress: Callable[[str], None] | None = None,
     ) -> ReviewOutcome: ...
 
 
@@ -123,6 +127,7 @@ class SubprocessReviewRunner:
         sha: str,
         intent: str | None = None,
         yes_full_project: bool = False,
+        on_progress: Callable[[str], None] | None = None,
     ) -> ReviewOutcome:
         cmd = [self.executable, "review", "--commit", sha, *self.extra_args]
         if intent and intent.strip():
@@ -132,23 +137,70 @@ class SubprocessReviewRunner:
             # non-interactive confirmation so the loop never blocks on a hidden prompt.
             cmd.append("--yes-full-project")
         # Wide, non-interactive output so rich does not wrap the status lines the
-        # parser depends on.
-        env = dict(os.environ, COLUMNS="200", NO_COLOR="1")
+        # parser depends on. ``PYTHONUNBUFFERED`` forces line-buffered child output
+        # so progress lines reach us (and the terminal UI) live instead of only at
+        # process exit -- the difference between a spinner that looks hung and one
+        # that shows real sub-steps.
+        env = dict(os.environ, COLUMNS="200", NO_COLOR="1", PYTHONUNBUFFERED="1")
         try:
-            proc = subprocess.run(
+            proc = subprocess.Popen(  # noqa: S603 - fixed argv, no shell
                 cmd,
                 cwd=str(self.project_root),
-                capture_output=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
                 text=True,
-                timeout=self.timeout,
+                bufsize=1,
                 env=env,
+                # New session/process group so the timeout can kill the whole tree
+                # (review spawns grandchildren, e.g. the sandbox runtime). Killing
+                # only the direct child would leave a grandchild holding the stdout
+                # pipe open, so the streaming read loop would block until it exits
+                # and the timeout would not take effect promptly.
+                start_new_session=True,
             )
         except FileNotFoundError:
             return ReviewOutcome(sha=sha, error=f"'{self.executable}' not found on PATH")
-        except subprocess.TimeoutExpired:
-            return ReviewOutcome(sha=sha, error=f"review timed out after {int(self.timeout)}s")
         except Exception as exc:  # never let a review failure crash the terminal
             return ReviewOutcome(sha=sha, error=f"review invocation failed: {exc}")
 
-        combined = (proc.stdout or "") + "\n" + (proc.stderr or "")
-        return parse_review_output(sha, combined, proc.returncode)
+        def _kill_tree() -> None:
+            """Kill the child and all of its descendants (best-effort)."""
+            with contextlib.suppress(Exception):
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            with contextlib.suppress(Exception):
+                proc.kill()
+
+        # Enforce the overall timeout even while streaming: a watchdog kills the
+        # process group at the deadline (the streaming read loop then unblocks
+        # because every pipe write-end is closed).
+        done = threading.Event()
+        timed_out = threading.Event()
+
+        def _watchdog() -> None:
+            if not done.wait(self.timeout):
+                timed_out.set()
+                _kill_tree()
+
+        watchdog = threading.Thread(target=_watchdog, name="review-timeout", daemon=True)
+        watchdog.start()
+
+        lines: list[str] = []
+        try:
+            if proc.stdout is not None:
+                for raw in proc.stdout:
+                    lines.append(raw)
+                    if on_progress is not None:
+                        # A progress-callback error must never abort the review.
+                        with contextlib.suppress(Exception):
+                            on_progress(raw.rstrip("\n"))
+            proc.wait()
+        except Exception as exc:  # never let a streaming/read error crash the terminal
+            done.set()
+            _kill_tree()
+            return ReviewOutcome(sha=sha, error=f"review invocation failed: {exc}")
+        finally:
+            done.set()
+
+        if timed_out.is_set():
+            return ReviewOutcome(sha=sha, error=f"review timed out after {int(self.timeout)}s")
+        return parse_review_output(sha, "".join(lines), proc.returncode or 0)

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli/watch_state.py

@@ -43,6 +43,10 @@ PHASE_FINALIZE = "finalize"
 PHASE_DONE = "done"
 PHASE_NONE = "none"
 
+# Cap the live sub-step trail so a long review never overflows the node block.
+# Older steps scroll off the top (the checklist keeps the most recent progress).
+_MAX_SUBSTEPS = 6
+
 
 @dataclass
 class RRCommit:
@@ -121,6 +125,13 @@ class CommitNode:
     intent_summary: str = ""
     run_id: str = ""
     error: str = ""
+    # Live sub-step trail while REVIEWING, oldest first (e.g. "resolving scope",
+    # "reviewing batch 2/5", "security scan"). Rendered as a Cursor-style
+    # checklist: completed steps ticked, the last one spinning. Volatile UI-only
+    # detail; not part of the persisted node contract. ``substep`` mirrors the
+    # current (last) step for the compact single-line status fallback.
+    substep: str = ""
+    substeps: list[str] = field(default_factory=list)
     finalize: "FinalizeInfo | None" = None
 
     @property
@@ -271,6 +282,25 @@ class WatchState:
         node = self._nodes.get(sha)
         if node:
             node.state = REVIEWING
+            node.substep = ""
+            node.substeps = []
+
+    def set_substep(self, sha: str, label: str) -> None:
+        """Append a new live sub-step to a reviewing node's trail (UI-only).
+
+        Consecutive duplicates are collapsed and the trail is capped at
+        :data:`_MAX_SUBSTEPS` (oldest scroll off). No-op unless the node is
+        currently ``REVIEWING`` so a stale progress line can never mutate a
+        finished node.
+        """
+        node = self._nodes.get(sha)
+        if not (node and node.state == REVIEWING):
+            return
+        if not node.substeps or node.substeps[-1] != label:
+            node.substeps.append(label)
+            if len(node.substeps) > _MAX_SUBSTEPS:
+                node.substeps = node.substeps[-_MAX_SUBSTEPS:]
+        node.substep = label
 
     def requeue(self, sha: str) -> None:
         """Reset a node to ``queued`` so the next pass re-reviews it (post-resolve)."""
@@ -282,6 +312,8 @@ class WatchState:
             node.rr_count = 0
             node.rr_preview = []
             node.error = ""
+            node.substep = ""
+            node.substeps = []
             node.finalize = None
             self.forced_review.discard(sha)
 
@@ -443,7 +475,8 @@ def _status_line(node: CommitNode) -> str:
     if node.state == REVIEWING:
         scope = f" ({node.changed} files)" if node.changed else ""
         spinner = _spinner_frame()
-        return f"[cyan]{spinner}[/cyan] [dim]analyzing changed+associated{scope}...[/dim]"
+        detail = node.substep or "analyzing changed+associated"
+        return f"[cyan]{spinner}[/cyan] [dim]{detail}{scope}...[/dim]"
     if node.state == ERROR:
         return f"[red]review error:[/red] {node.error or 'unknown'}"
     # reviewed
@@ -538,10 +571,29 @@ def _render_review_view(state: WatchState, *, now: datetime | None = None, width
         row2 = Text.from_markup(f"[cyan]|[/cyan]    [yellow]{node.short_sha}[/yellow]  ")
         row2.append(node.subject or "(no subject)")
         node_lines.append(row2)
-        # Row 3: pipe + status.
-        row3 = Text.from_markup("[cyan]|[/cyan]    ")
-        row3.append_text(Text.from_markup(_status_line(node)))
-        node_lines.append(row3)
+        # Row 3: while reviewing, render a Cursor-style checklist of sub-steps
+        # (completed steps ticked, the current one spinning) so progress reads as
+        # advancing work instead of a single overwritten line. Falls back to the
+        # compact status line before the first step arrives / for other states.
+        if node.state == REVIEWING and node.substeps:
+            spinner = _spinner_frame(now)
+            last = len(node.substeps) - 1
+            for idx, label in enumerate(node.substeps):
+                row = Text.from_markup("[cyan]|[/cyan]    ")
+                if idx == last:
+                    row.append_text(Text.from_markup(f"[cyan]{spinner}[/cyan] "))
+                    row.append(label)
+                    if node.changed:
+                        row.append(f" ({node.changed} files)", style="dim")
+                    row.append(" …", style="dim")
+                else:
+                    row.append_text(Text.from_markup("[green]✓[/green] "))
+                    row.append(label, style="dim")
+                node_lines.append(row)
+        else:
+            row3 = Text.from_markup("[cyan]|[/cyan]    ")
+            row3.append_text(Text.from_markup(_status_line(node)))
+            node_lines.append(row3)
         if node.state == REVIEWED and node.rr_preview:
             for item in node.rr_preview:
                 req = Text.from_markup("[cyan]|[/cyan]      ")

{refactorai_cli-0.7.19 → refactorai_cli-0.7.22}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.19
+Version: 0.7.22
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown