refactorai-cli 0.5.3__tar.gz → 0.5.6__tar.gz

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/PKG-INFO

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

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/pyproject.toml

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

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/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.5.3"
+__version__ = "0.5.6"

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/refactorai_cli/cloud_rr.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 from collections import deque
 import contextlib
 import hashlib
+import os
 import re
 import shlex
 import shutil
@@ -186,15 +187,55 @@ def _run_command_with_progress(
     return False, ("\n".join(tail))[-700:]
 
 
-def _leading_binary(command: str | None) -> str | None:
-    """Return the leading executable of a simple command, or None.
+# Splits a composite shell command into its simple segments. We intentionally
+# keep this conservative (no support for redirections/heredocs) — those don't
+# appear in generated/detected test commands.
+_COMPOSITE_SPLIT_RE = re.compile(r"&&|\|\||;|\|")
+
+# Interpreters that are functionally interchangeable for our generated test
+# commands. A host with only ``python3`` must still satisfy a ``python`` command
+# (and vice versa) instead of triggering a needless managed-runtime download.
+_INTERPRETER_ALIASES = {"python": "python3", "python3": "python"}
+
 
-    Returns None for composite/shell commands (``&&``, subshells, pipes) that
-    can't be reduced to a single binary, and for env-only prefixes.
+def _command_segments(command: str | None) -> list[str]:
+    """Split a (possibly composite) shell command into simple segments.
+
+    Splits on ``&&``/``||``/``;``/pipes, strips subshell parens, and drops pure
+    ``cd <dir>`` navigation segments so each returned segment begins with the
+    real executable it invokes (e.g. ``cd client && npm test`` -> ``["npm
+    test"]``). Used so preflight/provisioning see the *actual* runner binary of a
+    monorepo command instead of treating the whole thing as opaque.
+    """
+    if not command or not str(command).strip():
+        return []
+    segments: list[str] = []
+    for part in _COMPOSITE_SPLIT_RE.split(command):
+        seg = part.strip().strip("()").strip()
+        if not seg:
+            continue
+        try:
+            tokens = shlex.split(seg, posix=True)
+        except ValueError:
+            segments.append(seg)
+            continue
+        # Drop a bare `cd <dir>` navigation segment; it carries no binary.
+        stripped = list(tokens)
+        while stripped and _ENV_ASSIGN_RE.match(stripped[0]):
+            stripped.pop(0)
+        if stripped and stripped[0] == "cd":
+            continue
+        segments.append(seg)
+    return segments
+
+
+def _simple_leading_binary(command: str | None) -> str | None:
+    """Leading executable of a *simple* (non-composite) command, or None.
+
+    Skips leading ``VAR=value`` env assignments. Does not attempt to parse
+    composite commands — callers use :func:`_required_binaries` for those.
     """
     if not command or not str(command).strip():
-        return None
-    if any(op in command for op in ("&&", "||", ";", "|", "(", ")")):
         return None
     try:
         tokens = shlex.split(command, posix=True)
@@ -207,29 +248,101 @@ def _leading_binary(command: str | None) -> str | None:
     return tokens[0]
 
 
+def _required_binaries(command: str | None) -> list[str]:
+    """Distinct leading binaries required by a (possibly composite) command.
+
+    A monorepo runner like ``cd client && npm test && cd server && pytest`` needs
+    several runtimes; returning each lets preflight validate — and provisioning
+    cover — all of them instead of trusting the command blindly. Order preserved,
+    duplicates removed, ``cd`` ignored.
+    """
+    binaries: list[str] = []
+    for seg in _command_segments(command):
+        binary = _simple_leading_binary(seg)
+        if binary and binary != "cd" and binary not in binaries:
+            binaries.append(binary)
+    return binaries
+
+
+def _leading_binary(command: str | None) -> str | None:
+    """Primary runner binary of a command (first of :func:`_required_binaries`).
+
+    Kept for callers that only need a single representative binary; unlike the
+    old implementation this is composite-aware (``cd x && npm test`` -> ``npm``).
+    """
+    required = _required_binaries(command)
+    return required[0] if required else None
+
+
+def _binary_on_path(binary: str, *, env: dict | None = None) -> bool:
+    """True when ``binary`` (or an interchangeable interpreter alias) is runnable.
+
+    An absolute/relative path is checked on disk; a bare name is looked up on
+    ``PATH`` (optionally the provisioned ``env``'s PATH). ``python``/``python3``
+    are treated as interchangeable so a ``python3``-only host satisfies a
+    ``python`` command without provisioning a managed runtime.
+    """
+    if not binary:
+        return False
+    if "/" in binary:
+        return Path(binary).expanduser().exists()
+    search_path = (env or {}).get("PATH") if env else None
+    if shutil.which(binary, path=search_path) is not None:
+        return True
+    alias = _INTERPRETER_ALIASES.get(binary)
+    return bool(alias and shutil.which(alias, path=search_path) is not None)
+
+
 def _client_preflight_command(
     project_root: Path, command: str | None, *, env: dict | None = None
 ) -> bool:
-    """Return True when ``command`` looks runnable on this host.
-
-    Composite/shell commands (``&&``, subshells, pipes) run under ``shell=True``
-    and can't be reduced to one binary, so we trust them and let the real exit
-    code gate. Simple commands are validated by checking the leading binary is on
-    PATH — this guards against running (and charging for) a server-suggested
-    command whose toolchain isn't installed. ``env`` optionally supplies the
-    PATH to check against (e.g. after a managed toolchain is provisioned).
+    """Return True when *every* binary ``command`` needs is runnable on this host.
+
+    Composite/shell commands run under ``shell=True``, but we no longer trust
+    them blindly: we extract each segment's leading binary (ignoring ``cd``) and
+    require all of them to be present on PATH. This is what stops an un-runnable
+    ``cd client && python ...`` from reaching the baseline and failing at runtime
+    with ``python: not found``. ``env`` optionally supplies the PATH to check
+    against (e.g. after a managed toolchain is provisioned).
     """
     if not command or not str(command).strip():
         return False
-    if any(op in command for op in ("&&", "||", ";", "|", "(", ")")):
-        return True
-    binary = _leading_binary(command)
-    if not binary:
+    required = _required_binaries(command)
+    if not required:
         return False
-    if "/" in binary:
-        return Path(binary).expanduser().exists()
+    return all(_binary_on_path(binary, env=env) for binary in required)
+
+
+def _missing_binaries(command: str | None, *, env: dict | None = None) -> list[str]:
+    """Required binaries of ``command`` that are NOT runnable on this host."""
+    return [b for b in _required_binaries(command) if not _binary_on_path(b, env=env)]
+
+
+def _normalize_command_interpreters(command: str | None, *, env: dict | None = None) -> str | None:
+    """Rewrite a bare ``python`` command token to ``python3`` when needed.
+
+    On ``python3``-only hosts (common on Debian/Ubuntu) a generated
+    ``python -m unittest ...`` command fails with ``python: not found`` even
+    though a perfectly good interpreter exists. When ``python`` is absent but
+    ``python3`` is present we rewrite the *command token* (word-boundary, never
+    touching ``python3`` or a ``/usr/bin/python`` path) so the baseline runs.
+    No-op when ``python`` is available (incl. via a provisioned toolchain).
+    """
+    if not command or not str(command).strip():
+        return command
     search_path = (env or {}).get("PATH") if env else None
-    return shutil.which(binary, path=search_path) is not None
+    for src, dst in (("python", "python3"), ("python3", "python")):
+        if src not in command:
+            continue
+        if shutil.which(src, path=search_path) is not None:
+            continue
+        if shutil.which(dst, path=search_path) is None:
+            continue
+        # Replace ``src`` only when it is a standalone command token: not part of
+        # a longer word (python3/pythonic) and not a path segment (/usr/bin/...).
+        pattern = re.compile(rf"(?<![\w./-]){re.escape(src)}(?![\w])")
+        command = pattern.sub(dst, command)
+    return command
 
 
 def _managed_toolchain_enabled(config: dict) -> bool:
@@ -245,18 +358,47 @@ def _managed_toolchain_enabled(config: dict) -> bool:
 
 
 def _detected_is_provisionable(command: str | None) -> bool:
-    """True when ``command``'s leading binary maps to a managed runtime.
+    """True when every missing binary of ``command`` maps to a managed runtime.
 
-    Lets the resolver keep a detected command (e.g. ``npm test``) whose runtime
-    is missing from the host PATH but which the managed toolchain can download,
-    instead of discarding it and deferring the run.
+    Lets the resolver keep a detected command (e.g. ``cd client && npm test``)
+    whose runtime is missing from the host PATH but which the managed toolchain
+    can download, instead of discarding it and deferring the run. Requires *all*
+    missing binaries to be provisionable so a command that mixes a managed
+    runtime with an un-provisionable Tier-3 binary still falls through.
     """
     from refactor_core.host_toolchain import binary_to_runtime
 
-    binary = _leading_binary(command)
-    if not binary:
+    missing = _missing_binaries(command)
+    if not missing:
         return False
-    return binary_to_runtime(binary) is not None
+    return all(binary_to_runtime(binary) is not None for binary in missing)
+
+
+def _merge_toolchain_env(base: dict | None, new: dict) -> dict:
+    """Merge a freshly provisioned toolchain env into an accumulated one.
+
+    Composite commands can need several managed runtimes (e.g. ``node`` +
+    ``python``). Each ``provision_for_command`` call returns a full env built
+    from ``os.environ`` with its bin dir prepended to ``PATH``; naively using the
+    last one would drop earlier runtimes. This prepends the new toolchain's PATH
+    entries ahead of the accumulated PATH and carries over runtime-specific vars
+    (e.g. ``GOROOT``). ``base`` None => first provisioned runtime.
+    """
+    if base is None:
+        return dict(new)
+    merged = dict(base)
+    new_path = new.get("PATH", "")
+    base_path = base.get("PATH", "")
+    if new_path and new_path != base_path:
+        env_tail = os.environ.get("PATH", "")
+        prefix = new_path
+        if env_tail and new_path.endswith(env_tail):
+            prefix = new_path[: -len(env_tail)].rstrip(os.pathsep)
+        merged["PATH"] = f"{prefix}{os.pathsep}{base_path}" if prefix else base_path
+    for key, value in new.items():
+        if key != "PATH" and key not in os.environ:
+            merged[key] = value
+    return merged
 
 
 def _provision_toolchain(
@@ -267,45 +409,56 @@ def _provision_toolchain(
     consent_cb: Callable[[dict], bool] | None,
     progress_cb: Callable[[dict], None] | None,
 ) -> tuple[dict | None, str]:
-    """Provision a managed runtime for ``test_command`` when it's missing locally.
-
-    Returns ``(env, note)``. ``env`` (with the toolchain on ``PATH``) is returned
-    only when a runtime was actually provisioned; otherwise ``None`` (the caller
-    then runs with the inherited environment). No-ops when the command is already
-    runnable, has no managed runtime, or provisioning is disabled/declined.
+    """Provision managed runtimes for every missing binary in ``test_command``.
+
+    Returns ``(env, note)``. ``env`` (with the toolchain(s) on ``PATH``) is
+    returned only when at least one runtime was actually provisioned; otherwise
+    ``None`` (the caller runs with the inherited environment). Composite commands
+    are handled per segment so a monorepo runner like ``cd client && npm test &&
+    cd server && pytest`` provisions BOTH node and python. No-ops when the command
+    is already runnable, has no managed runtime, or provisioning is disabled.
     """
     if not test_command or not _managed_toolchain_enabled(config):
         return None, ""
-    if _client_preflight_command(project_root, test_command):
+    missing = _missing_binaries(test_command)
+    if not missing:
         return None, ""  # already runnable on the host
-    binary = _leading_binary(test_command)
-    if not binary:
-        return None, ""
-    from refactor_core.host_toolchain import binary_to_runtime, guidance_for_binary
-
-    runtime = binary_to_runtime(binary)
-    if runtime is None:
-        # No self-provisionable runtime -> Tier 3 guided-install guidance so the
-        # developer gets an actionable message instead of a silent defer.
-        guidance = guidance_for_binary(binary)
-        if guidance:
-            return None, f"'{binary}' is not installed and cannot be auto-provisioned. {guidance}"
-        return None, ""
 
-    if consent_cb is not None:
-        approved = bool(consent_cb({"binary": binary, "runtime": runtime}))
-        if not approved:
-            return None, f"managed toolchain for '{binary}' declined; skipping provisioning."
+    from refactor_core.host_toolchain import binary_to_runtime, guidance_for_binary
 
     def _on_progress(msg: str) -> None:
         _emit(progress_cb, phase="rr", event="toolchain_provisioning", detail=msg)
 
-    env, note = provision_for_command(binary, on_progress=_on_progress)
-    if env is None:
-        return None, note
-    _emit(progress_cb, phase="rr", event="toolchain_ready", runtime=runtime)
-    _restore_dependencies(project_root, runtime, env, progress_cb)
-    return env, note
+    merged_env: dict | None = None
+    notes: list[str] = []
+    for binary in missing:
+        # A single provisioned runtime can satisfy several missing binaries
+        # (e.g. python also provides pip), so re-check against progress so far.
+        if merged_env is not None and _binary_on_path(binary, env=merged_env):
+            continue
+        runtime = binary_to_runtime(binary)
+        if runtime is None:
+            # No self-provisionable runtime -> Tier 3 guided-install guidance so
+            # the developer gets an actionable message instead of a silent defer.
+            guidance = guidance_for_binary(binary)
+            notes.append(
+                f"'{binary}' is not installed and cannot be auto-provisioned."
+                + (f" {guidance}" if guidance else "")
+            )
+            continue
+        if consent_cb is not None and not bool(consent_cb({"binary": binary, "runtime": runtime})):
+            notes.append(f"managed toolchain for '{binary}' declined; skipping provisioning.")
+            continue
+        env, note = provision_for_command(binary, on_progress=_on_progress)
+        if env is None:
+            if note:
+                notes.append(note)
+            continue
+        _emit(progress_cb, phase="rr", event="toolchain_ready", runtime=runtime)
+        merged_env = _merge_toolchain_env(merged_env, env)
+        _restore_dependencies(project_root, runtime, merged_env, progress_cb)
+
+    return merged_env, " ".join(n for n in notes if n).strip()
 
 
 def _restore_dependencies(
@@ -713,6 +866,22 @@ def run_cloud_refactor_requests(
         progress_cb=progress_cb,
     )
 
+    # python3-only hosts: rewrite a bare `python` test command to `python3` when
+    # we did NOT provision a managed runtime (managed provisioning already
+    # supplies a `python`). Prevents a `python: not found` baseline failure and
+    # the endless-defer loop it caused.
+    if toolchain_env is None and test_command:
+        normalized = _normalize_command_interpreters(test_command)
+        if normalized and normalized != test_command:
+            _emit(
+                progress_cb,
+                phase="rr",
+                event="testcmd_normalized",
+                test_command=normalized,
+                previous=test_command,
+            )
+            test_command = normalized
+
     run_store = create_run(project_root)
     run_id = run_store.run_id
     resolved_model = model_hint or str(
@@ -736,6 +905,35 @@ def run_cloud_refactor_requests(
             notes, stopped=False, stop_reason="", test_command=test_command,
         )
 
+    # Fail-fast: if a test command is configured but STILL not runnable after
+    # provisioning + interpreter normalization, stop up front with an actionable
+    # message instead of opening a session and deferring every RR behind an
+    # opaque `python: not found`. (A run with NO test command keeps prior
+    # behavior: the server decides per-RR whether it can proceed.)
+    if test_command and not _client_preflight_command(
+        project_root, test_command, env=toolchain_env
+    ):
+        missing = _missing_binaries(test_command, env=toolchain_env)
+        reason = (
+            "baseline test command is not runnable on this host "
+            f"(missing: {', '.join(missing) or 'required toolchain'}). "
+            "Install the toolchain or enable managed provisioning, then re-run. "
+            "No changes were attempted."
+        )
+        _emit(
+            progress_cb,
+            phase="rr",
+            event="preflight_failed",
+            reason=reason,
+            test_command=test_command,
+            missing=missing,
+        )
+        notes.append(reason)
+        return _build_artifact(
+            run_store, run_id, constitution, model_id, outcomes, counts,
+            notes, stopped=True, stop_reason=reason, test_command=test_command,
+        )
+
     session = _Session(
         auth_ctx=auth_ctx,
         execution_mode=execution_mode,

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/refactorai_cli/commands/watch_cmds.py

@@ -18,6 +18,7 @@ import os
 import select
 import subprocess
 import sys
+import threading
 import time
 from pathlib import Path
 from typing import Callable
@@ -330,6 +331,21 @@ def _report_node(project_root: Path, node) -> None:
         pass
 
 
+def _report_refactor_requests(project_root: Path) -> None:
+    """Best-effort sync of the local RR store to the platform Inbox (docs/44).
+
+    Fail-open like commit telemetry: no-ops unless the repo is bound to a project
+    and never raises. Called after any pass/action that can change RR state so the
+    cloud Inbox mirrors the developer's local requests.
+    """
+    try:
+        from refactorai_cli import commit_telemetry
+
+        commit_telemetry.post_refactor_requests(project_root)
+    except Exception:
+        pass
+
+
 def process_pending(
     project_root: Path,
     state: WatchState,
@@ -382,6 +398,8 @@ def process_pending(
     refresh_finalize(project_root, state)
     if on_update:
         on_update(state)
+    if reviewed:
+        _report_refactor_requests(project_root)
     return reviewed
 
 
@@ -574,6 +592,9 @@ def _run_action(
             refactor_branch_store.set_outcome(project_root, branch, refactor_branch_store.OUTCOME_DROPPED)
         _sync_current_branch(project_root, state)
         refresh_finalize(project_root, state)
+    # `[r]`/`[m]`/`[d]` can change RR status; mirror the local store to the Inbox.
+    if action in ("code", "merge", "drop"):
+        _report_refactor_requests(project_root)
     console.print("\n[dim]watch: returning to the Refactor Terminal...[/dim]")
     live.start()
 
@@ -609,6 +630,7 @@ def _run_revert_action(live, project_root: Path, node, state: WatchState) -> Non
                 build_action_command("revert", node.sha, rr_id=rr_id), project_root
             )
             refresh_finalize(project_root, state)
+            _report_refactor_requests(project_root)
         else:
             console.print("[dim]watch: nothing reverted (out of range).[/dim]")
     else:
@@ -717,6 +739,46 @@ def _dispatch_key(live, project_root: Path, key: str, state: WatchState) -> None
         )
 
 
+class _AnalysisAnimator:
+    """Repaint the Live graph on a timer so a blocking review animates.
+
+    While a commit is being analyzed the main thread is blocked inside
+    ``runner.run``; without this the "analyzing..." spinner on the reviewing node
+    would freeze and the terminal would look stuck. A daemon thread re-renders
+    the graph every ``interval`` seconds so the spinner keeps moving. Refreshes
+    share ``lock`` with the foreground refresh so Rich is never driven from two
+    threads at once.
+    """
+
+    def __init__(self, live, state: WatchState, lock: threading.Lock, *, interval: float = 0.08):
+        self._live = live
+        self._state = state
+        self._lock = lock
+        self._interval = interval
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def __enter__(self) -> "_AnalysisAnimator":
+        self._thread = threading.Thread(target=self._run, name="watch-animator", daemon=True)
+        self._thread.start()
+        return self
+
+    def __exit__(self, *exc) -> bool:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+        return False
+
+    def _run(self) -> None:
+        while not self._stop.wait(self._interval):
+            with self._lock:
+                try:
+                    self._live.update(render_graph(self._state))
+                    self._live.refresh()
+                except Exception:
+                    return
+
+
 def _run_tui(project_root: Path, state: WatchState, runner: ReviewRunner) -> None:
     """Render the live Graphite-style graph and consume the queue serially."""
     from refactorai_cli.main import _print_agent_intro
@@ -726,14 +788,19 @@ def _run_tui(project_root: Path, state: WatchState, runner: ReviewRunner) -> Non
 
     live = Live(render_graph(state), console=console, auto_refresh=False, screen=False)
     live.start()
+    refresh_lock = threading.Lock()
 
     def refresh(st: WatchState) -> None:
-        live.update(render_graph(st))
-        live.refresh()
+        with refresh_lock:
+            live.update(render_graph(st))
+            live.refresh()
 
     try:
         while True:
-            process_pending(project_root, state, runner, on_update=refresh)
+            # Animate the spinner while reviews run (the review call blocks the
+            # main thread, so a background refresher drives the animation).
+            with _AnalysisAnimator(live, state, refresh_lock):
+                process_pending(project_root, state, runner, on_update=refresh)
             state.select_default()
             refresh(state)
 

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/refactorai_cli/commit_telemetry.py

@@ -47,6 +47,25 @@ _GATE_MAP = {
     "blocked": "high",
 }
 
+# Local RR lifecycle states -> server RefactorRequest.status. The server Inbox
+# treats {pending,in_progress,deferred,failed} as open; applied is terminal-done;
+# denied is a human "won't fix" (mapped to suppressed); reverted re-opens the
+# finding locally, so it maps back to pending.
+_RR_STATUS_MAP = {
+    "pending": "pending",
+    "in_progress": "in_progress",
+    "deferred": "deferred",
+    "failed": "failed",
+    "applied": "applied",
+    "denied": "suppressed",
+    "reverted": "pending",
+}
+# Local RR states that imply a resolution outcome on the server row.
+_RR_OUTCOME_MAP = {
+    "applied": "applied",
+    "denied": "suppressed",
+}
+
 
 def telemetry_disabled() -> bool:
     return str(os.environ.get(ENV_DISABLE, "")).strip().lower() in _TRUTHY
@@ -130,6 +149,46 @@ def build_commit_event_from_queue(event: dict) -> dict:
     }
 
 
+def build_refactor_request(rr) -> dict:
+    """Map a local ``refactor_core`` RefactorRequest to the RR ingest body.
+
+    Accepts the dataclass instance (uses attributes) and normalizes the local
+    lifecycle status/outcome to the server's enum. Attempts are flattened to a
+    compact per-proposal snapshot so the Inbox can show attempt history.
+    """
+    status = _RR_STATUS_MAP.get(str(getattr(rr, "status", "") or "").strip().lower(), "pending")
+    outcome = _RR_OUTCOME_MAP.get(str(getattr(rr, "status", "") or "").strip().lower())
+    attempts: list[dict] = []
+    for att in getattr(rr, "attempts", None) or []:
+        to_dict = getattr(att, "to_dict", None)
+        if callable(to_dict):
+            try:
+                attempts.append(to_dict())
+                continue
+            except Exception:
+                pass
+        if isinstance(att, dict):
+            attempts.append(att)
+    return {
+        "rr_id": str(getattr(rr, "rr_id", "") or ""),
+        "file_path": str(getattr(rr, "file_path", "") or ""),
+        "symbol": getattr(rr, "symbol", None),
+        "category": str(getattr(rr, "category", "") or ""),
+        "severity": str(getattr(rr, "severity", "medium") or "medium"),
+        "rationale": str(getattr(rr, "rationale", "") or ""),
+        "recommendation": str(getattr(rr, "recommendation", "") or ""),
+        "operation_type": str(getattr(rr, "operation_type", "content_patch") or "content_patch"),
+        "status": status,
+        "outcome": outcome,
+        "attempt_count": int(getattr(rr, "attempt_count", 0) or 0),
+        "detail": None,
+        "attempts": attempts,
+        "refactor_branch": str(getattr(rr, "refactor_branch", "") or ""),
+        "commit_sha": str(getattr(rr, "commit_sha", "") or ""),
+        "reverted": bool(getattr(rr, "reverted", False)),
+    }
+
+
 def _auth_and_project(project_root: Path | str, config: dict | None) -> tuple[object | None, str]:
     if telemetry_disabled():
         return None, ""
@@ -190,6 +249,30 @@ def post_heartbeat(
     return _post(url, auth.key.key, body, timeout)
 
 
+def post_refactor_requests(
+    project_root: Path | str, *, config: dict | None = None, timeout: float = 8.0
+) -> bool:
+    """Sync the full local RR store to the platform. Best-effort + fail-open.
+
+    Sends the complete local snapshot (so terminal RRs land as their resolved
+    status) and asks the server to reconcile any previously-synced open RRs that
+    are no longer present locally (e.g. cleared by a fresh review). Never raises.
+    """
+    auth, project_id = _auth_and_project(project_root, config)
+    if not auth or not project_id:
+        return False
+    try:
+        from refactor_core.refactor_requests import list_requests
+
+        requests = list_requests(Path(project_root))
+    except Exception:
+        return False
+    items = [build_refactor_request(rr) for rr in requests]
+    url = f"{platform_url()}/v1/projects/{project_id}/refactor-requests/ingest"
+    body = {"reconcile": True, "requests": items}
+    return _post(url, auth.key.key, body, timeout)
+
+
 def emit_node(project_root: Path | str, node, *, config: dict | None = None) -> bool:
     """Build + post a commit event from a watch ``CommitNode``. Never raises."""
     try:

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/refactorai_cli/watch_state.py

@@ -9,12 +9,25 @@ without a live terminal, a queue file, or the review engine.
 
 from __future__ import annotations
 
+import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 
 from rich.console import Group
 from rich.text import Text
 
+# Braille spinner frames for the "reviewing" (commit-analysis) status line, so a
+# long analysis animates instead of looking hung. Frame is derived from the wall
+# clock so the graph animates whenever it is re-rendered (the TUI drives that via
+# a background refresher during the blocking review).
+_SPINNER_FRAMES = "\u280b\u2819\u2839\u2838\u283c\u2834\u2826\u2827\u2807\u280f"
+
+
+def _spinner_frame(now: datetime | None = None) -> str:
+    """Return the current spinner glyph (time-based; ~12.5 fps)."""
+    tick = time.monotonic() if now is None else now.timestamp()
+    return _SPINNER_FRAMES[int(tick * 12.5) % len(_SPINNER_FRAMES)]
+
 # Node lifecycle states (docs/41 Part F).
 QUEUED = "queued"
 REVIEWING = "reviewing"
@@ -393,7 +406,8 @@ def _status_line(node: CommitNode) -> str:
         return "[dim]queued[/dim]"
     if node.state == REVIEWING:
         scope = f" ({node.changed} files)" if node.changed else ""
-        return f"[dim]reviewing changed+associated{scope}...[/dim]"
+        spinner = _spinner_frame()
+        return f"[cyan]{spinner}[/cyan] [dim]analyzing changed+associated{scope}...[/dim]"
     if node.state == ERROR:
         return f"[red]review error:[/red] {node.error or 'unknown'}"
     # reviewed

{refactorai_cli-0.5.3 → refactorai_cli-0.5.6}/refactorai_cli.egg-info/PKG-INFO

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