refactorai-cli 0.7.18__tar.gz → 0.7.20__tar.gz

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/PKG-INFO

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

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/pyproject.toml

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

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/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.18"
+__version__ = "0.7.20"

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/refactorai_cli/commands/run_cmds.py

@@ -1846,8 +1846,18 @@ def _project_languages(project_root: Path) -> set[str]:
 
 
 def _required_lsp_commands(project_root: Path) -> dict[str, str]:
-    """Return required LSP command -> friendly name based on inferred languages."""
-    from refactor_core.codeintel.lsp import LSP_SERVERS
+    """Return required LSP command -> friendly name based on inferred languages.
+
+    The LSP server registry lives in the engine-only ``codeintel`` subpackage,
+    which is absent from a public client install. On such installs (every
+    server-engine variant: local_byok / local_managed / cloud_*), LSP preflight
+    is simply skipped -- it is best-effort sandbox enrichment, not required for a
+    remote-engine run -- rather than crashing the command.
+    """
+    try:
+        from refactor_core.codeintel.lsp import LSP_SERVERS
+    except ModuleNotFoundError:
+        return {}
 
     required: dict[str, str] = {}
     for language in sorted(_project_languages(project_root)):
@@ -3398,6 +3408,10 @@ def review(
         # must propagate as-is, not be re-wrapped into a generic failure.
         raise
     except Exception as exc:  # provider/transport errors should not crash the CLI
+        if os.environ.get("REFACTOR_DEBUG"):
+            import traceback
+
+            console.print("[dim]" + traceback.format_exc() + "[/dim]")
         console.print(f"[red]Review failed:[/red] {_sanitize_runtime_error_message(exc)}")
         raise typer.Exit(code=1) from exc
     finally:

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/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.18 → refactorai_cli-0.7.20}/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.18 → refactorai_cli-0.7.20}/refactorai_cli/watch_state.py

@@ -121,6 +121,9 @@ class CommitNode:
     intent_summary: str = ""
     run_id: str = ""
     error: str = ""
+    # Live sub-step label while REVIEWING (e.g. "batch 2/5", "security scan").
+    # Volatile UI-only detail; not part of the persisted node contract.
+    substep: str = ""
     finalize: "FinalizeInfo | None" = None
 
     @property
@@ -271,6 +274,17 @@ class WatchState:
         node = self._nodes.get(sha)
         if node:
             node.state = REVIEWING
+            node.substep = ""
+
+    def set_substep(self, sha: str, label: str) -> None:
+        """Update the live sub-step label for a reviewing node (UI-only).
+
+        No-op unless the node is currently ``REVIEWING`` so a stale progress line
+        can never overwrite a finished node's status.
+        """
+        node = self._nodes.get(sha)
+        if node and node.state == REVIEWING:
+            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 +296,7 @@ class WatchState:
             node.rr_count = 0
             node.rr_preview = []
             node.error = ""
+            node.substep = ""
             node.finalize = None
             self.forced_review.discard(sha)
 
@@ -443,7 +458,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

{refactorai_cli-0.7.18 → refactorai_cli-0.7.20}/refactorai_cli.egg-info/PKG-INFO

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