refactorai-cli 0.7.4__tar.gz → 0.7.6__tar.gz

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.4
+Version: 0.7.6
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ Requires-Dist: typer>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: refactorai-core>=3.2.16
+Requires-Dist: refactorai-core>=3.2.18
 
 # refactorai-cli
 

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.7.4"
+version = "0.7.6"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ dependencies = [
   "httpx>=0.27.0",
   "rich>=13.7.0",
   "PyYAML>=6.0.1",
-  "refactorai-core>=3.2.16",
+  "refactorai-core>=3.2.18",
 ]
 
 [project.scripts]

{refactorai_cli-0.7.4 → refactorai_cli-0.7.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.7.4"
+__version__ = "0.7.6"

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/refactorai_cli/commands/run_cmds.py

@@ -15,6 +15,7 @@ import shlex
 import shutil
 import subprocess
 import sys
+import time
 import uuid
 from pathlib import Path
 from typing import Callable
@@ -57,7 +58,7 @@ from refactor_core.apply import (
     read_marker,
     revert_from_backup,
 )
-from refactor_core.budgeting import compute_budget
+from refactor_core.budgeting import DEFAULT_BUDGET_RATIO, compute_budget, plan_batches
 from refactor_core.capabilities import resolve_capabilities
 from refactor_core.gate import evaluate_gate
 from refactor_core.merge_gate import (
@@ -692,7 +693,6 @@ def _stable_idempotency_key(
     stage: str,
     constitution_hash: str,
     target: str,
-    max_alerts: int,
     execution_mode: str,
     scope_digest: str = "",
 ) -> str:
@@ -714,13 +714,129 @@ def _stable_idempotency_key(
             stage,
             constitution_hash,
             str(target),
-            str(int(max_alerts)),
             scope_digest,
         ]
     )
     return hashlib.sha256(seed.encode("utf-8")).hexdigest()
 
 
+class _CloudCapabilityShim:
+    """Minimal provider-like object for cloud batch sizing.
+
+    ``plan_batches`` needs a resolved ``CapabilitySnapshot`` (context window +
+    output ceiling) to pack documents. On the cloud path there is no local
+    provider instance, so this shim carries just the provider/model identity;
+    :func:`resolve_capabilities` fills in the catalog-derived context window.
+    """
+
+    supports_tools = False
+    supports_refactor = True
+
+    def __init__(self, provider_name: str, model_id: str) -> None:
+        self.provider_name = provider_name
+        self.model_id = model_id
+
+
+def _plan_cloud_batches(constitution, documents: list[dict], *, model_hint: str) -> list[list[dict]]:
+    """Split indexed documents into context-safe batches for cloud inference.
+
+    Mirrors the local planner so a large first review is sent as several bounded
+    requests instead of one oversized call that blows the read timeout. Always
+    returns at least one batch (possibly empty) so callers can loop uniformly.
+    """
+    provider_name = str(constitution.get_setting("provider", "") or "").strip() or "cloud"
+    settings = dict(getattr(constitution, "settings", {}) or {})
+    ratio = float(
+        constitution.get_setting("context_budget_ratio", DEFAULT_BUDGET_RATIO) or DEFAULT_BUDGET_RATIO
+    )
+    capabilities = resolve_capabilities(_CloudCapabilityShim(provider_name, model_hint), settings)
+    plan = plan_batches(documents, capabilities, ratio=ratio)
+    return plan.batches or [list(documents)]
+
+
+def _cloud_timeout(constitution) -> httpx.Timeout:
+    """Split connect/read timeout for cloud calls (configurable via refactor.config).
+
+    A single long ``timeout=`` collapses connect and read into one number; a
+    first-run review needs a generous *read* budget (the model is thinking) but a
+    short *connect* budget (fail fast on an unreachable host).
+    """
+    read = float(constitution.get_setting("cloud_request_timeout", 120) or 120)
+    connect = float(constitution.get_setting("cloud_connect_timeout", 10) or 10)
+    return httpx.Timeout(read, connect=connect, write=read, pool=connect)
+
+
+def _cloud_max_retries(constitution) -> int:
+    """Bounded retry count for transient cloud failures (default 2 => 3 attempts)."""
+    raw = constitution.get_setting("cloud_max_retries", 2)
+    try:
+        return max(0, int(raw))
+    except (TypeError, ValueError):
+        return 2
+
+
+_RETRYABLE_INFERENCE_STATUS = {429, 500, 502, 503, 504}
+
+
+def _inference_backoff_seconds(attempt: int) -> float:
+    """Linear backoff capped at 8s (attempt is 1-based)."""
+    return min(2.0 * attempt, 8.0)
+
+
+def _post_cloud_inference(
+    url: str,
+    *,
+    headers: dict,
+    payload: dict,
+    timeout: httpx.Timeout,
+    max_retries: int,
+) -> httpx.Response:
+    """POST one inference request, retrying transient timeouts/5xx/429.
+
+    Retries are safe because every request carries a stable ``Idempotency-Key``
+    (the backend replays instead of re-charging), so a read timeout on a slow
+    first run recovers without duplicating work.
+    """
+    attempt = 0
+    while True:
+        try:
+            response = httpx.post(url, headers=headers, json=payload, timeout=timeout)
+        except httpx.HTTPError as exc:
+            retryable = isinstance(exc, (httpx.TimeoutException, httpx.TransportError))
+            if retryable and attempt < max_retries:
+                attempt += 1
+                time.sleep(_inference_backoff_seconds(attempt))
+                continue
+            raise RuntimeError(f"Could not reach cloud inference service: {exc}") from exc
+        if response.status_code in _RETRYABLE_INFERENCE_STATUS and attempt < max_retries:
+            attempt += 1
+            time.sleep(_inference_backoff_seconds(attempt))
+            continue
+        return response
+
+
+def _raise_for_inference_status(response: httpx.Response, execution_mode: str) -> None:
+    """Map a non-2xx inference response to an actionable ``RuntimeError``."""
+    if response.status_code == 401:
+        raise RuntimeError("Cloud inference unauthorized (developer key invalid or revoked).")
+    if response.status_code == 402:
+        if execution_mode == "cloud_byok":
+            raise RuntimeError(
+                "Cloud BYOK is not enabled for this account (missing `run:byok`). "
+                "Contact your admin to enable BYOK cloud execution."
+            )
+        raise RuntimeError("Cloud inference requires paid tier (`mode: cloud_managed`).")
+    if response.status_code == 404 and execution_mode == "cloud_byok":
+        raise RuntimeError(
+            "BYOK credential not found or not owned by this account. "
+            "Check `refactor cloud credentials list` and your `credential_ref`."
+        )
+    if response.status_code == 429:
+        raise RuntimeError("Cloud inference quota exhausted or rate-limited.")
+    if response.status_code >= 400:
+        raise RuntimeError(f"Cloud inference failed ({response.status_code}): {response.text[:500]}")
+
+
 def _cloud_inference(
     *,
     stage: str,
@@ -731,8 +847,9 @@ def _cloud_inference(
     findings: list | None = None,
     scope_paths: list[str] | None = None,
 ) -> RunArtifact:
-    _raw_alerts = constitution.get_setting("max_alerts_per_run", 5)
-    max_alerts = int(_raw_alerts if _raw_alerts is not None else 5)
+    # Cloud inference is intentionally uncapped on the client: send/accept the
+    # full model output instead of truncating findings/patches/tests.
+    max_alerts = 0
     gate_mode = str(constitution.get_setting("gate_mode", "strict") or "strict")
     excludes = set(constitution.get_setting("exclude", []) or [])
     # Commit-scoped cloud review (docs/41 `R28`): when a scope is supplied, index
@@ -756,77 +873,123 @@ def _cloud_inference(
 
     execution_mode = _cloud_execution_mode(constitution) or "cloud_managed"
     auth_ctx = ensure_authenticated(project_root)
-    # Digest the exact documents so the idempotency key keys on the reviewed
-    # code, not just account/stage/target. (The backend independently recomputes
-    # a documents hash for its own replay guard, so this need not be sent.)
-    documents_hash = _documents_digest(documents)
-    payload = {
-        "stage": stage,
-        "execution_mode": execution_mode,
-        "constitution_hash": constitution.content_hash,
-        "documents": documents,
-        "constitution_body": getattr(constitution, "body", "") or "",
-        "findings": request_findings if stage != "review" else [],
-        "max_alerts": max_alerts,
-        "model_hint": model_hint or str(constitution.get_setting("model_id", "managed-default") or "managed-default"),
-    }
+    model_hint_value = model_hint or str(
+        constitution.get_setting("model_id", "managed-default") or "managed-default"
+    )
 
-    if execution_mode == "cloud_byok":
-        _apply_byok_payload(payload, constitution)
+    # Split the indexed documents into context-safe batches so a large first
+    # review is never sent as one oversized request that blows the read timeout.
+    # Each batch is an independent, idempotent inference call; findings/patches/
+    # tests are aggregated client-side (mirrors the local planner). Each call
+    # uses a split connect/read timeout and bounded retries for transient
+    # timeouts/5xx/429 (safe because of the stable per-batch idempotency key).
+    batches = _plan_cloud_batches(constitution, documents, model_hint=model_hint_value)
+    timeout = _cloud_timeout(constitution)
+    max_retries = _cloud_max_retries(constitution)
+    url = f"{platform_url()}/v1/inference/refactor"
+    batch_count = len(batches)
+    if batch_count > 1:
+        console.print(
+            f"[dim]cloud {stage}: {len(documents)} document(s) split into "
+            f"{batch_count} batch(es).[/dim]"
+        )
 
-    idempotency_key = _stable_idempotency_key(
-        account_id=auth_ctx.account_id,
-        stage=stage,
-        constitution_hash=constitution.content_hash,
-        target=target,
-        max_alerts=max_alerts,
-        execution_mode=execution_mode,
-        scope_digest=documents_hash,
-    )
-    try:
-        response = httpx.post(
-            f"{platform_url()}/v1/inference/refactor",
+    findings: list[Finding] = []
+    patches: list[PatchGroup] = []
+    generated_tests: list[GeneratedTest] = []
+    seen_findings: set[tuple] = set()
+    resolved_model_id = ""
+    server_security_summary: dict = {}
+
+    for idx, batch in enumerate(batches, start=1):
+        batch_paths = {str(d.get("path", "")) for d in batch}
+        # For the refactor stage, forward only the prior findings relevant to
+        # this batch's files (fall back to all when none match), so each request
+        # stays scoped and small (parity with the local planner's per-batch set).
+        if stage != "review":
+            batch_findings_payload = [
+                f for f in request_findings
+                if str((f or {}).get("file_path", "")) in batch_paths
+            ] or request_findings
+        else:
+            batch_findings_payload = []
+
+        payload = {
+            "stage": stage,
+            "execution_mode": execution_mode,
+            "constitution_hash": constitution.content_hash,
+            "documents": batch,
+            "constitution_body": getattr(constitution, "body", "") or "",
+            "findings": batch_findings_payload,
+            "max_alerts": max_alerts,
+            "model_hint": model_hint_value,
+        }
+        if execution_mode == "cloud_byok":
+            _apply_byok_payload(payload, constitution)
+
+        # Digest the exact batch documents (plus batch index/count) so the
+        # idempotency key keys on the reviewed code: a genuine retry replays, but
+        # distinct batches never collide onto one cached result.
+        batch_digest = _documents_digest(batch)
+        idempotency_key = _stable_idempotency_key(
+            account_id=auth_ctx.account_id,
+            stage=stage,
+            constitution_hash=constitution.content_hash,
+            target=target,
+            execution_mode=execution_mode,
+            scope_digest=f"{batch_digest}:{idx}:{batch_count}",
+        )
+        if batch_count > 1:
+            console.print(
+                f"[dim]cloud {stage}: batch {idx}/{batch_count} "
+                f"({len(batch)} document(s))...[/dim]"
+            )
+
+        response = _post_cloud_inference(
+            url,
             headers={
                 "Authorization": f"Bearer {auth_ctx.key.key}",
                 "Content-Type": "application/json",
                 "Idempotency-Key": idempotency_key,
             },
-            json=payload,
-            timeout=45.0,
+            payload=payload,
+            timeout=timeout,
+            max_retries=max_retries,
         )
-    except httpx.HTTPError as exc:
-        raise RuntimeError(f"Could not reach cloud inference service: {exc}") from exc
-
-    if response.status_code == 401:
-        raise RuntimeError("Cloud inference unauthorized (developer key invalid or revoked).")
-    if response.status_code == 402:
-        if execution_mode == "cloud_byok":
-            raise RuntimeError(
-                "Cloud BYOK is not enabled for this account (missing `run:byok`). "
-                "Contact your admin to enable BYOK cloud execution."
+        _raise_for_inference_status(response, execution_mode)
+
+        data = response.json() if response.content else {}
+        for item in (data.get("findings") or []):
+            finding = Finding.model_validate(item)
+            key = (
+                finding.severity,
+                finding.category,
+                finding.file_path,
+                finding.symbol,
+                finding.rationale,
             )
-        raise RuntimeError("Cloud inference requires paid tier (`mode: cloud_managed`).")
-    if response.status_code == 404 and execution_mode == "cloud_byok":
-        raise RuntimeError(
-            "BYOK credential not found or not owned by this account. "
-            "Check `refactor cloud credentials list` and your `credential_ref`."
-        )
-    if response.status_code == 429:
-        raise RuntimeError("Cloud inference quota exhausted or rate-limited.")
-    if response.status_code >= 400:
-        raise RuntimeError(f"Cloud inference failed ({response.status_code}): {response.text[:500]}")
-
-    data = response.json() if response.content else {}
-    _no_cap = max_alerts <= 0
-    findings = [Finding.model_validate(item) for item in (data.get("findings") or [])]
-    patches = [PatchGroup.model_validate(item) for item in (data.get("patches") or [])]
-    generated_tests = [
-        GeneratedTest.model_validate(item) for item in (data.get("generated_tests") or [])
-    ]
-    if not _no_cap:
-        findings = findings[:max_alerts]
-        patches = patches[:max_alerts]
-        generated_tests = generated_tests[:max_alerts]
+            if key in seen_findings:
+                continue
+            seen_findings.add(key)
+            findings.append(finding)
+        for item in (data.get("patches") or []):
+            patches.append(PatchGroup.model_validate(item))
+        for item in (data.get("generated_tests") or []):
+            generated_tests.append(GeneratedTest.model_validate(item))
+        if not resolved_model_id:
+            resolved_model_id = str(data.get("model_id") or "")
+        # Prefer the first server-provided security baseline across batches.
+        batch_server_summary = data.get("security_summary")
+        if (
+            not server_security_summary
+            and isinstance(batch_server_summary, dict)
+            and batch_server_summary.get("enabled")
+        ):
+            server_security_summary = batch_server_summary
+
+    # Stable ordering across batches: highest severity first.
+    severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    findings.sort(key=lambda f: severity_order.get(f.severity, 4))
     gate = evaluate_gate(findings, [], mode=gate_mode)
 
     # Optional security-scan enrichment (R19). Semgrep is an additive signal and
@@ -836,7 +999,7 @@ def _cloud_inference(
     # the local checkout (Phase 1) so parity holds against older backends.
     security_summary: dict = {}
     security_notes: list[str] = []
-    server_summary = data.get("security_summary")
+    server_summary = server_security_summary
     if isinstance(server_summary, dict) and server_summary.get("enabled"):
         security_summary = server_summary
     else:
@@ -870,7 +1033,7 @@ def _cloud_inference(
         gate=gate,
         summary=summary,
         constitution_hash=constitution.content_hash,
-        model_id=str(data.get("model_id") or payload["model_hint"]),
+        model_id=str(resolved_model_id or model_hint_value),
         notes=security_notes,
         rule_source=rule_meta.get("rule_source", ""),
         rule_pattern=rule_meta.get("rule_pattern", ""),

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/refactorai_cli/commands/watch_cmds.py

@@ -489,22 +489,40 @@ def process_pending(
     return reviewed
 
 
-def _read_key(timeout: float) -> str:
-    """Non-blocking key read on a POSIX TTY, normalized to a token.
-
-    Returns ``up``/``down`` for arrow keys, the raw character for normal keys
-    (used for hotkeys like ``[r]`` and ``[f]``), ``esc`` for a
-    bare Escape, or ``""`` when nothing was pressed / the terminal is not
-    interactive. Sleeps ``timeout`` in the non-interactive case so the caller's
-    poll cadence is preserved.
-    """
-    if not sys.stdin.isatty():
+def _read_key_windows(timeout: float) -> str:
+    """Non-blocking key read on Windows consoles (PowerShell/cmd/Terminal)."""
+    try:
+        import msvcrt
+    except ImportError:
         time.sleep(timeout)
         return ""
+    deadline = time.monotonic() + max(0.0, float(timeout))
+    while True:
+        if msvcrt.kbhit():
+            ch = msvcrt.getwch()
+            # Windows emits extended keys as a two-char sequence:
+            # prefix (\x00 or \xe0) + code (H/P/K/M etc).
+            if ch in ("\x00", "\xe0"):
+                code = msvcrt.getwch() if msvcrt.kbhit() else ""
+                if code == "H":
+                    return "up"
+                if code == "P":
+                    return "down"
+                return ""
+            if ch == "\x1b":
+                return "esc"
+            return ch
+        if time.monotonic() >= deadline:
+            return ""
+        time.sleep(0.01)
+
+
+def _read_key_posix(timeout: float) -> str:
+    """Non-blocking key read on a POSIX TTY, normalized to a token."""
     try:
         import termios
         import tty
-    except ImportError:  # non-POSIX
+    except ImportError:
         time.sleep(timeout)
         return ""
     fd = sys.stdin.fileno()
@@ -534,6 +552,16 @@ def _read_key(timeout: float) -> str:
         termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
 
+def _read_key(timeout: float) -> str:
+    """Cross-platform non-blocking key read for ``refactor watch`` hotkeys."""
+    if not sys.stdin.isatty():
+        time.sleep(timeout)
+        return ""
+    if os.name == "nt":
+        return _read_key_windows(timeout)
+    return _read_key_posix(timeout)
+
+
 def build_action_command(
     action: str,
     sha: str,

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.4
+Version: 0.7.6
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ Requires-Dist: typer>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: refactorai-core>=3.2.16
+Requires-Dist: refactorai-core>=3.2.18
 
 # refactorai-cli
 

{refactorai_cli-0.7.4 → refactorai_cli-0.7.6}/refactorai_cli.egg-info/requires.txt

@@ -2,4 +2,4 @@ typer>=0.12.0
 httpx>=0.27.0
 rich>=13.7.0
 PyYAML>=6.0.1
-refactorai-core>=3.2.16
+refactorai-core>=3.2.18