refactorai-cli 0.2.14__tar.gz → 0.2.16__tar.gz

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/PKG-INFO

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

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/pyproject.toml

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

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/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.2.14"
+__version__ = "0.2.16"

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/refactorai_cli/commands/run_cmds.py

@@ -46,13 +46,20 @@ from refactor_core.budgeting import compute_budget
 from refactor_core.capabilities import resolve_capabilities
 from refactor_core.execution import resolve_mode, run_with_mode
 from refactor_core.execution.rr_executor import run_refactor_requests
+from refactor_core.execution.structural_ops import structural_compatibility_matrix
 from refactor_core.gate import evaluate_gate
 from refactor_core.refactor_requests import (
+    DEFERRED,
+    RequestSuppression,
+    RequestWarning,
     clear_requests,
     create_requests,
     list_requests,
+    load_request,
     pending_requests,
+    save_request,
 )
+from refactor_core.refactor_ops import remediation_hint
 from refactor_core.indexing import index_target
 from refactor_core.models import Finding, GeneratedTest, PatchGroup, RunArtifact
 from refactor_core.pipeline import build_refactor_prompt, build_review_prompt
@@ -486,6 +493,20 @@ def _rr_progress_logger(status=None) -> Callable[[dict], None]:
         elif ev == "run_done":
             if status:
                 status.update("[green]code[/green] completed.")
+        elif ev == "rr_deferred":
+            if status:
+                status.update("[yellow]code[/yellow] deferred unsupported operation...")
+            reason = str(event.get("reason", "") or "")[:300]
+            hint = remediation_hint(reason)
+            suffix = f" [dim]hint: {hint}[/dim]" if hint else ""
+            console.print(f"[yellow]  ↷ deferred:[/yellow] {reason}{suffix}")
+        elif ev == "rr_failed":
+            if status:
+                status.update("[red]code[/red] failed unsupported operation.")
+            reason = str(event.get("reason", "") or "")[:300]
+            hint = remediation_hint(reason)
+            suffix = f" [dim]hint: {hint}[/dim]" if hint else ""
+            console.print(f"[red]  ✗ failed:[/red] {reason}{suffix}")
 
     return _log
 
@@ -1536,9 +1557,13 @@ def review(
     _print_findings(artifact.findings)
 
     # A fresh review supersedes prior refactor requests: replace them with one
-    # RR per finding (central-only; nothing is written into the project tree).
-    clear_requests(project_root)
-    requests = create_requests(project_root, artifact.findings, run_id=artifact.run_id)
+    # RR per actionable finding (central-only; nothing is written into project tree).
+    requests = _replace_requests_with_framework_guardrails(
+        project_root=project_root,
+        findings=artifact.findings,
+        run_id=artifact.run_id,
+        artifact=artifact,
+    )
     if requests:
         console.print(
             f"\n[bold]Created {len(requests)} refactor request(s).[/bold] "
@@ -1573,6 +1598,16 @@ def code(
         "--auto-approve",
         help="Skip interactive issue approvals in agentic code mode.",
     ),
+    on_rr_failure: str = typer.Option(
+        "stop",
+        "--on-rr-failure",
+        help="RR failure behavior: stop | continue | defer.",
+    ),
+    equivalence: str = typer.Option(
+        "strict",
+        "--equivalence",
+        help="Equivalence policy: strict | balanced.",
+    ),
 ) -> None:
     """Work through refactor requests one by one, applying & verifying each.
 
@@ -1637,9 +1672,11 @@ def code(
             review_store = create_run(project_root, run_id=review_artifact.run_id)
             review_store.write_artifact(review_artifact, target=target, status="completed")
             _print_findings(review_artifact.findings)
-            clear_requests(project_root)
-            requests = create_requests(
-                project_root, review_artifact.findings, run_id=review_artifact.run_id
+            requests = _replace_requests_with_framework_guardrails(
+                project_root=project_root,
+                findings=review_artifact.findings,
+                run_id=review_artifact.run_id,
+                artifact=review_artifact,
             )
             console.print(f"[bold]Created {len(requests)} refactor request(s).[/bold]")
 
@@ -1656,19 +1693,21 @@ def code(
             return
 
         with console.status("[cyan]code[/cyan] running...", spinner="dots") as status:
+            rr_config = (
+                dict(getattr(project_config, "settings", {}) or {})
+                | ({"sandbox": {"enabled": True}} if sandbox_on else {})
+                | ({"_sandbox_context": sandbox_ctx} if sandbox_ctx else {})
+            ) or dict(getattr(constitution, "settings", {}) or {})
             artifact = run_refactor_requests(
                 project_root=project_root,
                 constitution=constitution,
                 provider=selected_provider,
                 requests=requests,
-                config=(
-                    dict(getattr(project_config, "settings", {}) or {})
-                    | ({"sandbox": {"enabled": True}} if sandbox_on else {})
-                    | ({"_sandbox_context": sandbox_ctx} if sandbox_ctx else {})
-                )
-                or dict(getattr(constitution, "settings", {}) or {}),
+                config=rr_config,
                 progress_cb=_rr_progress_logger(status=status),
                 approval_cb=_rr_approval_prompt(auto_approve=auto_approve),
+                on_rr_failure=on_rr_failure,
+                equivalence_mode=equivalence,
             )
     except Exception as exc:
         console.print(f"[red]Refactor failed:[/red] {exc}")
@@ -1686,32 +1725,190 @@ def code(
     )
 
 
-def requests() -> None:
-    """List refactor requests and their status for this project."""
+def requests(
+    show_operation: bool = typer.Option(
+        False,
+        "--show-operation",
+        help="Show operation scope details (source/target/split map).",
+    ),
+    retry_deferred: bool = typer.Option(
+        False,
+        "--retry-deferred",
+        help="Re-run deferred requests immediately.",
+    ),
+    provider: str | None = typer.Option(
+        None,
+        "--provider",
+        help="Provider override when --retry-deferred is used.",
+    ),
+    auto_approve: bool = typer.Option(
+        False,
+        "--auto-approve",
+        help="Auto-approve retry-deferred proposals.",
+    ),
+    on_rr_failure: str = typer.Option(
+        "stop",
+        "--on-rr-failure",
+        help="RR failure behavior for retry: stop | continue | defer.",
+    ),
+    equivalence: str = typer.Option(
+        "strict",
+        "--equivalence",
+        help="Equivalence policy for retry: strict | balanced.",
+    ),
+) -> None:
+    """List refactor requests and optionally re-run deferred requests."""
     _require_auth()
-    project_root, _constitution, _config = _load_project()
+    project_root, constitution, project_config = _load_project()
+    if retry_deferred:
+        deferred_rrs = [rr for rr in list_requests(project_root) if rr.status == DEFERRED]
+        if not deferred_rrs:
+            console.print("[dim]No deferred requests to retry.[/dim]")
+        else:
+            selected_provider = get_provider(
+                constitution, project_root=project_root, provider_name=provider
+            )
+            for rr in deferred_rrs:
+                rr.status = "pending"
+                loaded = load_request(project_root, rr.rr_id)
+                if loaded is not None:
+                    loaded.status = "pending"
+                    save_request(project_root, loaded)
+            with console.status("[cyan]requests[/cyan] retrying deferred...", spinner="dots") as status:
+                _ = run_refactor_requests(
+                    project_root=project_root,
+                    constitution=constitution,
+                    provider=selected_provider,
+                    requests=[rr for rr in list_requests(project_root) if rr.status == "pending"],
+                    config=dict(getattr(project_config, "settings", {}) or {}),
+                    progress_cb=_rr_progress_logger(status=status),
+                    approval_cb=_rr_approval_prompt(auto_approve=auto_approve),
+                    on_rr_failure=on_rr_failure,
+                    equivalence_mode=equivalence,
+                )
     rrs = list_requests(project_root)
     if not rrs:
         console.print("[dim]No refactor requests. Run `refactor review` to create them.[/dim]")
         return
     table = Table(title="Refactor requests", show_lines=False)
     table.add_column("issue")
+    table.add_column("operation", no_wrap=True)
+    if show_operation:
+        table.add_column("scope")
     table.add_column("severity", no_wrap=True)
     table.add_column("category")
     table.add_column("status", no_wrap=True)
     table.add_column("attempts", no_wrap=True)
-    color = {"applied": "green", "denied": "yellow", "failed": "red", "pending": "cyan", "in_progress": "cyan"}
+    color = {
+        "applied": "green",
+        "denied": "yellow",
+        "failed": "red",
+        "deferred": "yellow",
+        "pending": "cyan",
+        "in_progress": "cyan",
+    }
     for rr in rrs:
-        table.add_row(
+        row = [
             rr.location,
-            rr.severity,
-            rr.category,
-            f"[{color.get(rr.status, 'white')}]{rr.status}[/{color.get(rr.status, 'white')}]",
-            str(rr.attempt_count),
+            rr.operation_type,
+        ]
+        if show_operation:
+            row.append(_format_operation_scope(rr))
+        row.extend(
+            [
+                rr.severity,
+                rr.category,
+                f"[{color.get(rr.status, 'white')}]{rr.status}[/{color.get(rr.status, 'white')}]",
+                str(rr.attempt_count),
+            ]
         )
+        table.add_row(*row)
     console.print(table)
 
 
+def _format_operation_scope(rr) -> str:
+    scope = getattr(rr, "scope", None)
+    if scope is None:
+        return "-"
+    source = str(getattr(scope, "source_path", "") or "").strip()
+    target = str(getattr(scope, "target_path", "") or "").strip()
+    split_map = dict(getattr(scope, "split_map", {}) or {})
+    symbol = str(getattr(scope, "symbol", "") or "").strip()
+    new_name = str(getattr(scope, "new_name", "") or "").strip()
+    if split_map:
+        if "__sources__" in split_map:
+            srcs = ", ".join(str(item) for item in split_map.get("__sources__", []))
+            return f"merge: [{srcs}] -> {target or '?'}"
+        chunks = []
+        for dst, symbols in split_map.items():
+            if symbols:
+                chunks.append(f"{dst}({','.join(str(s) for s in symbols)})")
+            else:
+                chunks.append(str(dst))
+        src_label = source or "?"
+        return f"split: {src_label} -> {', '.join(chunks)}"
+    if source or target:
+        if source and target:
+            return f"{source} -> {target}"
+        return source or target
+    if symbol and new_name:
+        return f"{symbol} -> {new_name}"
+    return "-"
+
+
+def _replace_requests_with_framework_guardrails(
+    *,
+    project_root: Path,
+    findings: list[Finding],
+    run_id: str,
+    artifact: RunArtifact | None = None,
+) -> list:
+    clear_requests(project_root)
+    requests, suppressions, warnings = create_requests(
+        project_root,
+        findings,
+        run_id=run_id,
+        return_diagnostics=True,
+    )
+    _report_framework_suppressions(suppressions, artifact=artifact)
+    _report_framework_warnings(warnings, artifact=artifact)
+    return requests
+
+
+def _report_framework_suppressions(
+    suppressions: list[RequestSuppression], *, artifact: RunArtifact | None = None
+) -> None:
+    if not suppressions:
+        return
+    console.print(
+        f"[yellow]warning:[/yellow] suppressed {len(suppressions)} finding(s) due to framework invariants."
+    )
+    for item in suppressions:
+        console.print(
+            f"[yellow]-[/yellow] {item.location}: {item.message} "
+            f"[dim](framework={item.framework or 'unknown'}, rule={item.rule_id or 'unspecified'})[/dim]"
+        )
+        if artifact is not None:
+            artifact.notes.append(item.note())
+
+
+def _report_framework_warnings(
+    warnings: list[RequestWarning], *, artifact: RunArtifact | None = None
+) -> None:
+    if not warnings:
+        return
+    console.print(
+        f"[yellow]warning:[/yellow] flagged {len(warnings)} finding(s) with framework caution."
+    )
+    for item in warnings:
+        console.print(
+            f"[yellow]-[/yellow] {item.location}: {item.message} "
+            f"[dim](framework={item.framework or 'unknown'}, rule={item.rule_id or 'unspecified'})[/dim]"
+        )
+        if artifact is not None:
+            artifact.notes.append(item.note())
+
+
 def apply(
     force: bool = typer.Option(False, "--force", help="Apply even if the quality gate blocks."),
 ) -> None:
@@ -2113,6 +2310,7 @@ def doctor(
     )
 
     _report_intelligence(project_root)
+    _report_structural_readiness(project_root, project_config)
 
     if skip_ping:
         console.print("[dim]Skipping provider live ping (--skip-ping).[/dim]")
@@ -2246,6 +2444,39 @@ def _report_sandbox(project_root: Path, config) -> None:
         console.print(f"  [dim]latest command results: {len(latest.get('results', []))} (failures={failures})[/dim]")
 
 
+def _report_structural_readiness(project_root: Path, config) -> None:
+    settings = dict(getattr(config, "settings", {}) or {})
+    refactor_cfg = settings.get("refactor", {})
+    if not isinstance(refactor_cfg, dict):
+        refactor_cfg = {}
+    structural = refactor_cfg.get("structural", {})
+    if not isinstance(structural, dict):
+        structural = {}
+    eq_mode = str(structural.get("equivalence_mode", "strict") or "strict")
+    rr_policy = str(structural.get("on_rr_failure", "stop") or "stop")
+    rewrite_mode = str(structural.get("reference_rewrite", "auto") or "auto")
+    langs = structural.get("languages", [])
+    rollout = str(structural.get("rollout", "default") or "default")
+    canary_percent = int(structural.get("canary_percent", 20) or 20)
+    if not isinstance(langs, list):
+        langs = []
+    console.print(
+        f"[bold]structural mode[/bold]: equivalence={eq_mode} on_rr_failure={rr_policy} "
+        f"rollout={rollout} canary_percent={canary_percent}"
+    )
+    console.print(f"[bold]reference rewrite[/bold]: {rewrite_mode} [{', '.join(str(x) for x in langs) or 'defaults'}]")
+    matrix = structural_compatibility_matrix()
+    enabled_langs = [name for name, ok in matrix.items() if ok]
+    disabled_langs = [name for name, ok in matrix.items() if not ok]
+    console.print(
+        f"[bold]adapter matrix[/bold]: enabled={', '.join(enabled_langs) or '-'}; "
+        f"degraded={', '.join(disabled_langs) or '-'}"
+    )
+    rrs = list_requests(project_root)
+    deferred = sum(1 for rr in rrs if rr.status == DEFERRED)
+    console.print(f"[bold]deferred requests[/bold]: {deferred}")
+
+
 def _maybe_build_graph(project_root: Path, config) -> None:
     """Build + persist the symbol graph when intelligence.graph is enabled."""
     settings = dict(getattr(config, "settings", {}) or {})
@@ -2275,20 +2506,22 @@ def _print_rr_summary(artifact) -> None:
         return
     table = Table(title="Refactor request outcomes", show_lines=False)
     table.add_column("issue")
+    table.add_column("operation", no_wrap=True)
     table.add_column("outcome", no_wrap=True)
     table.add_column("attempts", no_wrap=True)
-    color = {"applied": "green", "denied": "yellow", "failed": "red"}
+    color = {"applied": "green", "denied": "yellow", "failed": "red", "deferred": "yellow"}
     for o in outcomes:
         outcome = str(o.get("outcome", "?"))
         table.add_row(
             str(o.get("location", "?")),
+            str(o.get("operation_type", "content_patch")),
             f"[{color.get(outcome, 'white')}]{outcome}[/{color.get(outcome, 'white')}]",
             str(o.get("attempts", 0)),
         )
     console.print(table)
     console.print(
         f"[dim]applied={trace.get('applied', 0)} denied={trace.get('denied', 0)} "
-        f"failed={trace.get('failed', 0)}[/dim]"
+        f"failed={trace.get('failed', 0)} deferred={trace.get('deferred', 0)}[/dim]"
     )
 
 

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/refactorai_cli/commands/runtime_cmds.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import typer
 from rich.console import Console
+from rich.progress import BarColumn, DownloadColumn, Progress, TaskID, TextColumn, TimeRemainingColumn, TransferSpeedColumn
 
 from refactorai_cli.auth import AuthError, ensure_authenticated
 from refactorai_cli.control_plane import ensure_lease, heartbeat, read_cached_lease, resolve_policy
@@ -62,7 +63,23 @@ def update(
             f"[bold]resolved manifest[/bold]: version={manifest.runtime_version} "
             f"channel={channel}"
         )
-        artifact = download_artifact(manifest.artifact_url)
+        progress_columns = (
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+        )
+        with Progress(*progress_columns, console=console, transient=True) as progress:
+            task_id: TaskID = progress.add_task("Downloading runtime artifact", total=None)
+
+            def _on_progress(downloaded: int, total: int | None) -> None:
+                update_kwargs = {"completed": int(max(downloaded, 0))}
+                if total is not None and total > 0:
+                    update_kwargs["total"] = total
+                progress.update(task_id, **update_kwargs)
+
+            artifact = download_artifact(manifest.artifact_url, progress_cb=_on_progress)
         console.print(f"[bold]downloaded artifact[/bold]: {len(artifact)} bytes")
         if dry_run:
             # Verification happens in activate_runtime; dry-run still checks

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/refactorai_cli/runtime_manager.py

@@ -14,6 +14,7 @@ import platform
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Callable
 from urllib.parse import urlparse
 
 import httpx
@@ -153,17 +154,49 @@ def resolve_runtime_manifest(*, channel: str = "stable", timeout: float = 20.0)
     return manifest
 
 
-def download_artifact(url: str, *, timeout: float = 60.0) -> bytes:
+def download_artifact(
+    url: str,
+    *,
+    timeout: float = 60.0,
+    progress_cb: Callable[[int, int | None], None] | None = None,
+) -> bytes:
     headers: dict[str, str] = {}
     if _should_send_runtime_auth(url):
         headers["Authorization"] = _runtime_auth_header()
+    resolved_timeout = max(float(timeout), 300.0)
+    if progress_cb is None:
+        try:
+            response = httpx.get(url, headers=headers, timeout=resolved_timeout)
+        except httpx.HTTPError as exc:
+            raise RuntimeError(f"Could not download runtime artifact: {exc}") from exc
+        if response.status_code >= 400:
+            raise RuntimeError(f"Runtime artifact download failed ({response.status_code})")
+        return response.content
     try:
-        response = httpx.get(url, headers=headers, timeout=max(float(timeout), 300.0))
+        with httpx.stream("GET", url, headers=headers, timeout=resolved_timeout) as response:
+            if response.status_code >= 400:
+                raise RuntimeError(f"Runtime artifact download failed ({response.status_code})")
+            total: int | None = None
+            total_header = str(response.headers.get("Content-Length") or "").strip()
+            if total_header:
+                try:
+                    parsed_total = int(total_header)
+                except ValueError:
+                    parsed_total = -1
+                if parsed_total > 0:
+                    total = parsed_total
+            downloaded = 0
+            chunks: list[bytes] = []
+            progress_cb(downloaded, total)
+            for chunk in response.iter_bytes(chunk_size=64 * 1024):
+                if not chunk:
+                    continue
+                chunks.append(chunk)
+                downloaded += len(chunk)
+                progress_cb(downloaded, total)
     except httpx.HTTPError as exc:
         raise RuntimeError(f"Could not download runtime artifact: {exc}") from exc
-    if response.status_code >= 400:
-        raise RuntimeError(f"Runtime artifact download failed ({response.status_code})")
-    return response.content
+    return b"".join(chunks)
 
 
 def _should_send_runtime_auth(url: str) -> bool:

{refactorai_cli-0.2.14 → refactorai_cli-0.2.16}/refactorai_cli.egg-info/PKG-INFO

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