refactorai-cli 0.2.13__tar.gz → 0.2.15__tar.gz

{refactorai_cli-0.2.13 → refactorai_cli-0.2.15}/PKG-INFO

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

{refactorai_cli-0.2.13 → refactorai_cli-0.2.15}/pyproject.toml

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

{refactorai_cli-0.2.13 → refactorai_cli-0.2.15}/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.13"
+__version__ = "0.2.15"

{refactorai_cli-0.2.13 → refactorai_cli-0.2.15}/refactorai_cli/commands/run_cmds.py

@@ -46,13 +46,18 @@ 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,
     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
@@ -68,7 +73,9 @@ from refactor_core.sandbox_runtime import (
     detect_installer_in_sandbox,
     ensure_sandbox,
     exec_in_container,
+    exec_in_container_stream,
     exec_in_sandbox,
+    exec_in_sandbox_stream,
     remove_sandbox_container,
     sandbox_name,
     resolve_runtime,
@@ -318,9 +325,14 @@ def _agent_progress_logger(
         elif kind == "step_limit_reached":
             _set_status(
                 f"[yellow]{stage}[/yellow] step limit reached "
-                f"({event.get('steps_used', 0)}/{event.get('max_steps', 0)})"
+                f"({event.get('steps_used', 0)}/{event.get('max_steps', 0)}); "
+                "awaiting your input [y/N]"
             )
         elif kind == "step_limit_extended":
+            _set_status(
+                f"[green]{stage}[/green] continuing with extended budget "
+                f"({event.get('old_max_steps', 0)} -> {event.get('new_max_steps', 0)})"
+            )
             console.print(
                 f"[green]{stage}: continuing[/green] "
                 f"step budget {event.get('old_max_steps', 0)} -> {event.get('new_max_steps', 0)}"
@@ -479,6 +491,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
 
@@ -500,7 +526,11 @@ def _step_limit_prompt(stage: str) -> Callable[[dict], bool]:
             f"[yellow]{stage}: reached step limit ({steps_used}/{max_steps}).[/yellow] "
             f"Increase by {extension} steps and continue?"
         )
-        raw = typer.prompt("Continue agent loop? (y/N)", default="N")
+        console.print(
+            "[dim]Input required: type 'y' then Enter to continue, "
+            "or press Enter (or type 'n') to stop.[/dim]"
+        )
+        raw = typer.prompt("Extend agent step budget and continue? [y/N]", default="N")
         return raw.strip().lower() in {"y", "yes"}
 
     return _ask
@@ -940,14 +970,31 @@ def _sandbox_preflight(
             )
         return command_exists_in_sandbox(project_root=project_root, binary=binary)
 
-    def _exec(command: str) -> tuple[bool, str]:
+    def _exec(command: str, *, stream_output: bool = False) -> tuple[bool, str]:
+        def _on_output(line: str) -> None:
+            console.print(f"[dim]    {line}[/dim]")
+
         if has_container_ctx:
+            if stream_output:
+                return exec_in_container_stream(
+                    runtime=str(runtime),
+                    container_name=str(container_name),
+                    command=command,
+                    workdir=resolved_workdir,
+                    on_output=_on_output,
+                )
             return exec_in_container(
                 runtime=str(runtime),
                 container_name=str(container_name),
                 command=command,
                 workdir=resolved_workdir,
             )
+        if stream_output:
+            return exec_in_sandbox_stream(
+                project_root=project_root,
+                command=command,
+                on_output=_on_output,
+            )
         return exec_in_sandbox(project_root=project_root, command=command)
 
     def _detect_installer() -> str | None:
@@ -1107,8 +1154,10 @@ def _sandbox_preflight(
         "plan": plan,
         "results": [],
     }
-    for cmd in plan:
-        ok, output = _exec(cmd)
+    total_steps = len(plan)
+    for index, cmd in enumerate(plan, start=1):
+        console.print(f"[cyan]Installing step {index}/{total_steps}[/cyan]: [dim]{cmd}[/dim]")
+        ok, output = _exec(cmd, stream_output=True)
         entry["results"].append({"command": cmd, "ok": ok, "output": (output or "")[:500]})
         if not ok:
             detail = output[:400] if output else "unknown error"
@@ -1126,6 +1175,7 @@ def _sandbox_preflight(
                 },
             )
             return False, f"Install command failed: `{cmd}` -> {detail}"
+        console.print(f"[green]Install step {index}/{total_steps} completed.[/green]")
     append_sandbox_install_history(project_root, entry)
 
     if missing_binary and not _binary_exists(missing_binary):
@@ -1191,8 +1241,8 @@ def _sandbox_enabled(project_config) -> bool:
 
 
 def _sandbox_lifecycle(project_config) -> str:
-    lifecycle = str(_sandbox_settings(project_config).get("lifecycle", "per_run") or "per_run").strip().lower()
-    return lifecycle if lifecycle in {"per_project", "per_run"} else "per_run"
+    lifecycle = str(_sandbox_settings(project_config).get("lifecycle", "per_project") or "per_project").strip().lower()
+    return lifecycle if lifecycle in {"per_project", "per_run"} else "per_project"
 
 
 def _ensure_sandbox_ready(
@@ -1542,6 +1592,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.
 
@@ -1625,19 +1685,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}")
@@ -1655,32 +1717,137 @@ 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 apply(
     force: bool = typer.Option(False, "--force", help="Apply even if the quality gate blocks."),
 ) -> None:
@@ -2082,6 +2249,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]")
@@ -2215,6 +2383,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 {})
@@ -2244,20 +2445,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.13 → refactorai_cli-0.2.15}/refactorai_cli.egg-info/PKG-INFO

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