refactorai-cli 0.3.5__tar.gz → 0.3.9__tar.gz

{refactorai_cli-0.3.5 → refactorai_cli-0.3.9}/PKG-INFO

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

{refactorai_cli-0.3.5 → refactorai_cli-0.3.9}/pyproject.toml

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

{refactorai_cli-0.3.5 → refactorai_cli-0.3.9}/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.5"
+__version__ = "0.3.9"

{refactorai_cli-0.3.5 → refactorai_cli-0.3.9}/refactorai_cli/cloud_rr.py

@@ -50,8 +50,14 @@ 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, discover_test_command, resolve_test_command
+from refactor_core.testcmd import (
+    _SKIP_DIRS,
+    _configured_command,
+    discover_test_command,
+    resolve_test_command,
+)
 
 from refactorai_cli.auth import ensure_authenticated
 from refactorai_cli.settings import platform_url
@@ -93,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
@@ -101,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"
@@ -115,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}"
@@ -123,31 +135,132 @@ 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 _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(
@@ -257,18 +370,47 @@ def _resolve_cloud_test_command(
     """Resolve a test command for a cloud run; return ``(command, note)``.
 
     Layered resolution so the developer usually needs no config:
-    1. configured ``verification.tests.command`` or root-marker detection,
-    2. deterministic monorepo discovery (subproject test setups),
-    3. agentic discovery (server infers from manifests), preflight-validated.
+    1. configured ``verification.tests.command`` (explicit developer intent),
+    2. root-marker detection / deterministic monorepo discovery (subproject
+       test setups),
+    3. agentic discovery (server infers from manifests).
+
+    Cloud runs execute tests on the HOST (no sandbox), so every candidate is
+    preflight-validated against the host ``PATH`` before it is committed to. An
+    explicitly *configured* command is honored even when preflight fails (the
+    developer may know something we don't, e.g. a shell-resolved binary), but the
+    mismatch is surfaced as a note. Marker/monorepo-*detected* commands that fail
+    preflight are NOT returned: resolution falls through to server discovery so a
+    runnable alternative can be suggested instead of locking in an un-runnable
+    command (e.g. ``npm test`` when ``npm`` is not installed on the host).
     """
-    configured = resolve_test_command(project_root, config)
+    # 1) Explicitly configured command: honor developer intent, but warn if the
+    #    toolchain is not visible on the host PATH.
+    configured = _configured_command(config)
     if configured:
-        return configured, ""
+        if _client_preflight_command(project_root, configured):
+            return configured, ""
+        return configured, (
+            f"configured test command '{configured}' was not found on the host PATH; "
+            "cloud runs execute tests on the host, so it may fail. Install the "
+            "toolchain or update verification.tests.command."
+        )
 
-    discovered = discover_test_command(project_root)
-    if discovered:
-        return discovered, f"auto-detected test command: {discovered}"
+    # 2) Root-marker / monorepo detection: only usable if runnable on the host.
+    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.
+        detected_note = (
+            f"auto-detected test command '{detected}' but its toolchain was not "
+            "found on the host PATH; trying server discovery."
+        )
+    else:
+        detected_note = ""
 
+    # 3) Server-assisted discovery, preflight-validated.
     suggested = _discover_test_command_via_cloud(
         project_root=project_root,
         constitution=constitution,
@@ -280,11 +422,12 @@ def _resolve_cloud_test_command(
     if suggested and _client_preflight_command(project_root, suggested):
         return suggested, f"server-suggested test command: {suggested}"
     if suggested:
-        return None, (
+        note = (
             f"server suggested test command '{suggested}' but its toolchain was not "
-            "found on PATH; skipped."
+            "found on the host PATH; skipped."
         )
-    return None, ""
+        return None, f"{detected_note} {note}".strip() if detected_note else note
+    return None, detected_note
 
 
 class _Session:
@@ -375,6 +518,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.
 
@@ -382,6 +526,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)
@@ -399,6 +545,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)
 
@@ -416,6 +574,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
@@ -499,9 +659,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)
@@ -550,7 +711,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)
@@ -626,13 +787,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", []
@@ -647,7 +809,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.5 → refactorai_cli-0.3.9}/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.5 → refactorai_cli-0.3.9}/refactorai_cli/commands/runtime_proxy_cmds.py

@@ -75,7 +75,17 @@ def _delegate_to_run_cmds(command_name: str, passthrough_args: list[str]) -> Non
     real command signature (options, arguments, help) is honored without manual
     argument parsing. Exit codes propagate to the caller.
     """
-    from refactorai_cli.commands import run_cmds
+    try:
+        from refactorai_cli.commands import run_cmds
+    except ModuleNotFoundError as exc:
+        if exc.name == "refactor_core.merge_gate":
+            console.print(
+                "[red]Installed refactor core is too old for this CLI.[/red]\n"
+                "Please upgrade both packages:\n"
+                "  pip install --upgrade refactorai-core refactorai-cli"
+            )
+            raise typer.Exit(code=1) from exc
+        raise
 
     func = getattr(run_cmds, command_name, None)
     if func is None:  # pragma: no cover - defensive; all cloud verbs exist

refactorai_cli-0.3.9/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.5 → refactorai_cli-0.3.9}/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(
@@ -40,6 +41,12 @@ _TITLE_BY_COMMAND = {
     "review": "Refactor Review Agent",
     "code": "Refactor Code Agent",
 }
+_COLOR_BY_COMMAND = {
+    "setup": ("245", "250", "247"),   # base, soft, art
+    "doctor": ("39", "117", "81"),
+    "review": ("214", "222", "220"),
+    "code": ("46", "120", "82"),
+}
 
 
 def _print_agent_intro(command_name: str) -> None:
@@ -48,19 +55,20 @@ def _print_agent_intro(command_name: str) -> None:
         return
     title = _TITLE_BY_COMMAND.get(command_name, "Refactor Agent")
     tip = _TIP_BY_COMMAND.get(command_name, "Next: refactor review .")
-    green_bold = "\033[1;38;5;46m"
-    green_soft = "\033[38;5;120m"
-    green_art = "\033[38;5;82m"
+    base, soft, art = _COLOR_BY_COMMAND.get(command_name, ("46", "120", "82"))
+    color_bold = f"\033[1;38;5;{base}m"
+    color_soft = f"\033[38;5;{soft}m"
+    color_art = f"\033[38;5;{art}m"
     reset = "\033[0m"
     typer.echo("")
-    typer.echo(f"{green_bold}{title}{reset}")
-    typer.echo(f"{green_soft}Model: Sonnet 4.5{reset}")
+    typer.echo(f"{color_bold}{title}{reset}")
+    typer.echo(f"{color_soft}Model: Sonnet 4.5{reset}")
     typer.echo(f"Welcome back, {os.environ.get('USER', 'developer')}")
     typer.echo("")
-    typer.echo(f"{green_art}      *  [■ ■]  *{reset}")
-    typer.echo(f"{green_art}      *   \\_/   *{reset}")
+    typer.echo(f"{color_art}      *  [■ ■]  *{reset}")
+    typer.echo(f"{color_art}      *   \\_/   *{reset}")
     typer.echo("")
-    typer.echo(f"{green_bold}Tip:{reset} {tip}")
+    typer.echo(f"{color_bold}Tip:{reset} {tip}")
     typer.echo("")
 
 
@@ -123,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.5 → refactorai_cli-0.3.9}/refactorai_cli.egg-info/PKG-INFO

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

{refactorai_cli-0.3.5 → refactorai_cli-0.3.9}/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.5 → refactorai_cli-0.3.9}/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.4
+refactorai-core>=3.1.0