refactorai-cli 0.3.8__tar.gz → 0.3.10__tar.gz

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.3.8
+Version: 0.3.10
 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.0.5
+Requires-Dist: refactorai-core>=3.1.0
 
 # refactorai-cli
 

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.3.8"
+version = "0.3.10"
 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.0.5",
+  "refactorai-core>=3.1.0",
 ]
 
 [project.scripts]

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/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.3.8"
+__version__ = "0.3.10"

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/refactorai_cli/cloud_rr.py

@@ -50,6 +50,7 @@ from refactor_core.refactor_requests import (
     rr_test_dir,
     save_request,
 )
+from refactor_core.host_toolchain import provision_for_command
 from refactor_core.store import create_run
 from refactor_core.testcmd import (
     _SKIP_DIRS,
@@ -98,7 +99,9 @@ def _read_source(project_root: Path, rel: str) -> str:
         return ""
 
 
-def _run_test(project_root: Path, test_command: str | None) -> tuple[bool, str]:
+def _run_test(
+    project_root: Path, test_command: str | None, *, env: dict | None = None
+) -> tuple[bool, str]:
     """Run the configured test command on the host; (passed, detail).
 
     Cloud runs execute tests client-side because the developer's code + deps live
@@ -106,6 +109,9 @@ def _run_test(project_root: Path, test_command: str | None) -> tuple[bool, str]:
     command is configured we return ``(False, ...)`` so the server defers the RR
     rather than applying an unverifiable change. This differs from local's
     permissive skip on purpose -- cloud never applies an unverified change.
+
+    ``env`` optionally overrides the process environment (e.g. a managed host
+    toolchain prepended to ``PATH``); when None the inherited environment is used.
     """
     if not test_command or not str(test_command).strip():
         return False, "no test command configured; cannot verify behavior preservation"
@@ -120,6 +126,7 @@ def _run_test(project_root: Path, test_command: str | None) -> tuple[bool, str]:
             capture_output=True,
             text=True,
             timeout=600,
+            env=env,
         )
     except (subprocess.SubprocessError, OSError) as exc:
         return False, f"test command error: {exc}"
@@ -128,31 +135,147 @@ def _run_test(project_root: Path, test_command: str | None) -> tuple[bool, str]:
     return False, (proc.stdout or proc.stderr or "")[-500:]
 
 
-def _client_preflight_command(project_root: Path, command: str | None) -> bool:
+def _leading_binary(command: str | None) -> str | None:
+    """Return the leading executable of a simple command, or None.
+
+    Returns None for composite/shell commands (``&&``, subshells, pipes) that
+    can't be reduced to a single binary, and for env-only prefixes.
+    """
+    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)
+    except ValueError:
+        return None
+    while tokens and _ENV_ASSIGN_RE.match(tokens[0]):
+        tokens.pop(0)
+    if not tokens:
+        return None
+    return tokens[0]
+
+
+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.
+    command whose toolchain isn't installed. ``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
-    try:
-        tokens = shlex.split(command, posix=True)
-    except ValueError:
-        return False
-    while tokens and _ENV_ASSIGN_RE.match(tokens[0]):
-        tokens.pop(0)
-    if not tokens:
+    binary = _leading_binary(command)
+    if not binary:
         return False
-    binary = tokens[0]
     if "/" in binary:
         return Path(binary).expanduser().exists()
-    return shutil.which(binary) is not None
+    search_path = (env or {}).get("PATH") if env else None
+    return shutil.which(binary, path=search_path) is not None
+
+
+def _managed_toolchain_enabled(config: dict) -> bool:
+    """Whether managed host-toolchain provisioning is enabled (default on).
+
+    Reads ``verification.managed_toolchain`` from the project config; absent =>
+    enabled, so cloud modes provision runtimes for the developer by default.
+    """
+    verification = (config or {}).get("verification")
+    if isinstance(verification, dict) and "managed_toolchain" in verification:
+        return bool(verification.get("managed_toolchain"))
+    return True
+
+
+def _detected_is_provisionable(command: str | None) -> bool:
+    """True when ``command``'s leading binary 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.
+    """
+    from refactor_core.host_toolchain import binary_to_runtime
+
+    binary = _leading_binary(command)
+    if not binary:
+        return False
+    return binary_to_runtime(binary) is not None
+
+
+def _provision_toolchain(
+    project_root: Path,
+    test_command: str | None,
+    config: dict,
+    *,
+    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.
+    """
+    if not test_command or not _managed_toolchain_enabled(config):
+        return None, ""
+    if _client_preflight_command(project_root, test_command):
+        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."
+
+    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
+
+
+def _restore_dependencies(
+    project_root: Path, runtime: str, env: dict, progress_cb: Callable[[dict], None] | None
+) -> None:
+    """Restore project dependencies with the provisioned toolchain (best effort).
+
+    Mirrors the sandbox dependency-restore step so the test command has its deps
+    present. Failures are non-fatal: the test run surfaces the real error.
+    """
+    if runtime == "node" and (project_root / "package.json").is_file():
+        _emit(progress_cb, phase="rr", event="toolchain_provisioning", detail="npm install")
+        _run_test(project_root, "npm install", env=env)
+    elif runtime == "python":
+        if (project_root / "requirements.txt").is_file():
+            _emit(progress_cb, phase="rr", event="toolchain_provisioning",
+                  detail="pip install -r requirements.txt")
+            _run_test(project_root, "python -m pip install -r requirements.txt", env=env)
+        elif (project_root / "pyproject.toml").is_file() or (project_root / "setup.py").is_file():
+            _emit(progress_cb, phase="rr", event="toolchain_provisioning", detail="pip install -e .")
+            _run_test(project_root, "python -m pip install -e .", env=env)
 
 
 def _collect_test_manifests(
@@ -288,13 +411,22 @@ def _resolve_cloud_test_command(
             "toolchain or update verification.tests.command."
         )
 
-    # 2) Root-marker / monorepo detection: only usable if runnable on the host.
+    # 2) Root-marker / monorepo detection. Usable if runnable on the host OR if
+    #    its runtime can be provisioned by the managed toolchain (the caller then
+    #    downloads it before the baseline). Only when neither holds do we fall
+    #    through to server discovery, so we never lock onto a command that is
+    #    truly un-runnable (e.g. a Tier-3 binary with no managed runtime).
     detected = resolve_test_command(project_root, config) or discover_test_command(project_root)
     if detected:
         if _client_preflight_command(project_root, detected):
             return detected, f"auto-detected test command: {detected}"
-        # Detected but not runnable on the host -> fall through to server
-        # discovery rather than committing to an un-runnable command.
+        if _managed_toolchain_enabled(config) and _detected_is_provisionable(detected):
+            return detected, (
+                f"auto-detected test command: {detected} "
+                "(runtime not on host PATH; will provision a managed toolchain)"
+            )
+        # Detected but neither runnable nor provisionable -> fall through to
+        # server discovery rather than committing to an un-runnable command.
         detected_note = (
             f"auto-detected test command '{detected}' but its toolchain was not "
             "found on the host PATH; trying server discovery."
@@ -410,6 +542,7 @@ def run_cloud_refactor_requests(
     progress_cb: Callable[[dict], None] | None = None,
     approval_cb: Callable[[dict], bool] | None = None,
     apply_byok_payload: Callable[[dict, object], None] | None = None,
+    toolchain_consent_cb: Callable[[dict], bool] | None = None,
 ) -> RunArtifact:
     """Drive pending RRs through the cloud server-run loop and return a summary.
 
@@ -417,6 +550,8 @@ def run_cloud_refactor_requests(
     (``_rr_progress_logger`` / ``_rr_approval_prompt``), so the run streams the
     same events and prompts per RR mid-run (FR8). ``apply_byok_payload`` is the
     shared BYOK resolver injected by the caller to avoid a circular import.
+    ``toolchain_consent_cb`` gates first-run managed-toolchain provisioning; when
+    None, provisioning proceeds without prompting (e.g. ``--auto-approve``).
     """
     project_root = Path(project_root)
     progress_cb = progress_cb or (lambda e: None)
@@ -434,6 +569,18 @@ def run_cloud_refactor_requests(
         apply_byok_payload=apply_byok_payload,
     )
 
+    # Managed host toolchain: when the resolved command's runtime is missing from
+    # the host PATH, download a pinned runtime into the central store and run
+    # tests with it (no container, no system changes). ``toolchain_env`` is None
+    # when nothing was provisioned (already runnable / no managed runtime).
+    toolchain_env, toolchain_note = _provision_toolchain(
+        project_root,
+        test_command,
+        config,
+        consent_cb=toolchain_consent_cb,
+        progress_cb=progress_cb,
+    )
+
     if requests is None:
         requests = pending_requests(project_root)
 
@@ -451,6 +598,8 @@ def run_cloud_refactor_requests(
     notes: list[str] = []
     if testcmd_note:
         notes.append(testcmd_note)
+    if toolchain_note:
+        notes.append(toolchain_note)
     stopped = False
     stop_reason = ""
     model_id = resolved_model
@@ -534,9 +683,10 @@ def run_cloud_refactor_requests(
             current_rr_id = action.get("rr_id", "") or current_rr_id
             _emit(progress_cb, phase="rr", event="test_generating", rr_id=current_rr_id)
             _write_generated_test(project_root, current_rr_id, action, by_id)
-            passed, detail = _run_test(project_root, test_command)
+            passed, detail = _run_test(project_root, test_command, env=toolchain_env)
             _emit(progress_cb, phase="rr", event="baseline_test", rr_id=current_rr_id,
-                  passed=passed, detail=detail, execution_env="host")
+                  passed=passed, detail=detail,
+                  execution_env="host+toolchain" if toolchain_env else "host")
             action = session.step(
                 _step_payload(token, current_rr_id, "baseline_result", by_id, project_root,
                               baseline_passed=passed, baseline_detail=detail)
@@ -585,7 +735,7 @@ def run_cloud_refactor_requests(
                 current_rr_id = action.get("rr_id", "") or current_rr_id
                 diff_text = _PENDING_DIFF.get(current_rr_id, "")
                 passed, detail, files = _apply_and_verify(
-                    project_root, run_store.run_dir, diff_text, test_command
+                    project_root, run_store.run_dir, diff_text, test_command, env=toolchain_env
                 )
                 if passed:
                     _emit(progress_cb, phase="rr", event="rr_applied", rr_id=current_rr_id, files=files)
@@ -661,13 +811,14 @@ def _write_generated_test(project_root: Path, rr_id: str, action: dict, by_id: d
 
 
 def _apply_and_verify(
-    project_root: Path, run_dir: Path, diff_text: str, test_command
+    project_root: Path, run_dir: Path, diff_text: str, test_command, *, env: dict | None = None
 ) -> tuple[bool, str, list[str]]:
     """Apply the diff (with backup), run the test; revert on red.
 
     Returns ``(passed, detail, changed_files)``. ``changed_files`` is computed
     from the diff BEFORE applying (the tree is mutated in place afterward, so it
-    cannot be recomputed against the modified files).
+    cannot be recomputed against the modified files). ``env`` optionally supplies
+    the managed-toolchain environment used to run the test.
     """
     if not diff_text:
         return False, "empty diff", []
@@ -682,7 +833,7 @@ def _apply_and_verify(
         apply_changes(project_root, run_dir, changes)
     except Exception as exc:
         return False, f"apply failed: {exc}", changed_files
-    passed, detail = _run_test(project_root, test_command)
+    passed, detail = _run_test(project_root, test_command, env=env)
     if not passed:
         try:
             revert_from_backup(project_root, run_dir)

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/refactorai_cli/commands/run_cmds.py

@@ -460,6 +460,29 @@ def _rr_approval_prompt(*, auto_approve: bool) -> Callable[[dict], bool]:
     return _ask
 
 
+def _toolchain_consent_prompt(*, auto_approve: bool) -> Callable[[dict], bool]:
+    """First-run consent for downloading a managed language runtime.
+
+    Managed toolchains are downloaded into the central store (``~/.refactor``),
+    never system paths, so this is low-risk; we still confirm once per run before
+    fetching. ``--auto-approve`` and non-interactive terminals proceed silently.
+    """
+
+    def _ask(info: dict) -> bool:
+        binary = str(info.get("binary", "?"))
+        runtime = str(info.get("runtime", "?"))
+        if auto_approve or not sys.stdin.isatty():
+            return True
+        console.print(
+            f"[dim]'{binary}' was not found on your PATH. refactor can download a "
+            f"pinned {runtime} runtime into ~/.refactor (no system changes, no container).[/dim]"
+        )
+        raw = typer.prompt("Download managed toolchain? (Y/n)", default="Y")
+        return raw.strip().lower() in {"", "y", "yes"}
+
+    return _ask
+
+
 def _rr_progress_logger(status=None) -> Callable[[dict], None]:
     """Render the per-RR interactive flow with clear, dynamic messages."""
 
@@ -482,6 +505,16 @@ def _rr_progress_logger(status=None) -> Callable[[dict], None]:
                     f"[bold cyan]code:[/bold cyan] running in sandbox: [dim]{cmd}[/dim] "
                     f"(container={container or '?'})"
                 )
+        elif ev == "toolchain_provisioning":
+            detail = str(event.get("detail", "") or "")
+            if status:
+                status.update(f"[cyan]code[/cyan] provisioning toolchain: {detail}")
+            console.print(f"[dim]  toolchain: {detail}[/dim]")
+        elif ev == "toolchain_ready":
+            console.print(
+                f"[green]  toolchain ready:[/green] {event.get('runtime', '?')} "
+                "(managed; no container required)"
+            )
         elif ev == "rr_start":
             if status:
                 status.update(f"[cyan]code[/cyan] working on {event.get('location', '?')}...")
@@ -2211,6 +2244,7 @@ def code(
                     progress_cb=_rr_progress_logger(status=status),
                     approval_cb=_rr_approval_prompt(auto_approve=auto_approve),
                     apply_byok_payload=_apply_byok_payload,
+                    toolchain_consent_cb=_toolchain_consent_prompt(auto_approve=auto_approve),
                 )
         else:
             # Local mode is unchanged: dispatch to the local executor with the

refactorai_cli-0.3.10/refactorai_cli/commands/toolchains_cmds.py

@@ -0,0 +1,57 @@
+"""Managed host-toolchain commands: inspect and prune provisioned runtimes.
+
+Managed toolchains are pinned language runtimes (Node/Python/Go) downloaded into
+the central store (``~/.refactor/toolchains``) so cloud modes can run tests on
+the host without a container. These commands let developers see and clean up
+what has been provisioned.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from refactor_core import host_toolchain as ht
+
+console = Console()
+app = typer.Typer(help="Inspect and manage managed language toolchains.")
+
+
+@app.command("list")
+def list_toolchains() -> None:
+    """List runtimes provisioned into the central store."""
+    installed = ht.list_installed()
+    if not installed:
+        console.print("[dim]No managed toolchains provisioned.[/dim]")
+        return
+    table = Table(title="Managed toolchains")
+    table.add_column("runtime")
+    table.add_column("version")
+    table.add_column("platform")
+    table.add_column("path", overflow="fold")
+    for entry in installed:
+        table.add_row(entry["runtime"], entry["version"], entry["platform"], entry["path"])
+    console.print(table)
+
+
+@app.command("prune")
+def prune_toolchains(
+    runtime: str = typer.Option(
+        None, "--runtime", help="Only remove this runtime (e.g. node, python, go)."
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Remove provisioned toolchains to reclaim disk space."""
+    target = runtime or "all managed toolchains"
+    if not yes:
+        confirm = typer.prompt(f"Remove {target}? (y/N)", default="N")
+        if confirm.strip().lower() not in {"y", "yes"}:
+            console.print("[dim]Aborted.[/dim]")
+            raise typer.Exit(code=0)
+    removed = ht.prune(runtime=runtime)
+    if not removed:
+        console.print("[dim]Nothing to remove.[/dim]")
+        return
+    for path in removed:
+        console.print(f"[green]removed[/green] {path}")

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/refactorai_cli/main.py

@@ -17,6 +17,7 @@ from refactorai_cli.commands import (
     runtime_cmds,
     runtime_proxy_cmds,
     setup_cmds,
+    toolchains_cmds,
 )
 
 app = typer.Typer(
@@ -130,6 +131,9 @@ app.add_typer(model_cmds.app, name="model")
 # Cloud (BYOK) credential management (R20).
 app.add_typer(cloud_cmds.app, name="cloud")
 
+# Managed host toolchains (R24 Phase 2).
+app.add_typer(toolchains_cmds.app, name="toolchains")
+
 
 if __name__ == "__main__":
     app()

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.3.8
+Version: 0.3.10
 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.0.5
+Requires-Dist: refactorai-core>=3.1.0
 
 # refactorai-cli
 

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/refactorai_cli.egg-info/SOURCES.txt

@@ -30,4 +30,5 @@ refactorai_cli/commands/rules_cmds.py
 refactorai_cli/commands/run_cmds.py
 refactorai_cli/commands/runtime_cmds.py
 refactorai_cli/commands/runtime_proxy_cmds.py
-refactorai_cli/commands/setup_cmds.py
+refactorai_cli/commands/setup_cmds.py
+refactorai_cli/commands/toolchains_cmds.py

{refactorai_cli-0.3.8 → refactorai_cli-0.3.10}/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.0.5
+refactorai-core>=3.1.0