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

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

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

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

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

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

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

@@ -1795,9 +1795,21 @@ def _install_plan_for_missing_binary(
     plan: list[str] = []
     if pkg_cmd:
         plan.append(pkg_cmd)
-    # Dependency restore after toolchain install (best effort).
+    # Dependency restore after toolchain install. Use the SAME lockfile-aware
+    # installer as the cloud/managed path (single source of truth in
+    # ``cloud_rr._node_install_command``) so sandbox preflight never rewrites a
+    # committed lockfile: ``npm ci`` / ``yarn install --immutable`` /
+    # ``pnpm install --frozen-lockfile`` when a lockfile is present, falling back
+    # to ``npm install`` only for a lockfile-less project. Historically this path
+    # hardcoded ``npm install``, which regenerated ``package-lock.json`` /
+    # ``yarn.lock`` in the mounted tree and left the working tree dirty (blocking
+    # the refactor-branch flow); unifying on the lockfile-aware command removes
+    # that divergence at the source.
     if (project_root / "package.json").is_file():
-        plan.append("npm install")
+        from refactorai_cli.cloud_rr import _node_install_command
+
+        _, node_install_cmd = _node_install_command(project_root)
+        plan.append(node_install_cmd)
     elif (project_root / "requirements.txt").is_file():
         plan.append("pip install -r requirements.txt")
     return plan
@@ -3329,28 +3341,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.20 → refactorai_cli-0.7.23}/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,9 +125,13 @@ 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.
+    # 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
@@ -275,16 +283,24 @@ class WatchState:
         if node:
             node.state = REVIEWING
             node.substep = ""
+            node.substeps = []
 
     def set_substep(self, sha: str, label: str) -> None:
-        """Update the live sub-step label for a reviewing node (UI-only).
+        """Append a new live sub-step to a reviewing node's trail (UI-only).
 
-        No-op unless the node is currently ``REVIEWING`` so a stale progress line
-        can never overwrite a finished node's status.
+        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 node and node.state == REVIEWING:
-            node.substep = label
+        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)."""
@@ -297,6 +313,7 @@ class WatchState:
             node.rr_preview = []
             node.error = ""
             node.substep = ""
+            node.substeps = []
             node.finalize = None
             self.forced_review.discard(sha)
 
@@ -554,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.20 → refactorai_cli-0.7.23}/refactorai_cli.egg-info/PKG-INFO

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