refactorai-cli 0.7.8__tar.gz → 0.7.10__tar.gz

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.8
+Version: 0.7.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.2.19
+Requires-Dist: refactorai-core>=3.2.21
 
 # refactorai-cli
 

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.7.8"
+version = "0.7.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.2.19",
+  "refactorai-core>=3.2.21",
 ]
 
 [project.scripts]

{refactorai_cli-0.7.8 → refactorai_cli-0.7.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.7.8"
+__version__ = "0.7.9"

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/refactorai_cli/cloud_rr.py

@@ -328,6 +328,20 @@ def _missing_binaries(command: str | None, *, env: dict | None = None) -> list[s
     return [b for b in _required_binaries(command) if not _binary_on_path(b, env=env)]
 
 
+def _command_runtimes(command: str | None) -> list[str]:
+    """Managed runtime ids implied by the command's required binaries."""
+    if not command:
+        return []
+    from refactor_core.host_toolchain import binary_to_runtime
+
+    out: list[str] = []
+    for binary in _required_binaries(command):
+        runtime = binary_to_runtime(binary)
+        if runtime and runtime not in out:
+            out.append(runtime)
+    return out
+
+
 def _normalize_command_interpreters(command: str | None, *, env: dict | None = None) -> str | None:
     """Rewrite a bare ``python`` command token to ``python3`` when needed.
 
@@ -521,12 +535,12 @@ def _provision_toolchain(
 ) -> tuple[dict | None, str]:
     """Provision managed runtimes for every missing binary in ``test_command``.
 
-    Returns ``(env, note)``. ``env`` (with the toolchain(s) on ``PATH``) is
-    returned only when at least one runtime was actually provisioned; otherwise
-    ``None`` (the caller runs with the inherited environment). Composite commands
-    are handled per segment so a monorepo runner like ``cd client && npm test &&
-    cd server && pytest`` provisions BOTH node and python. No-ops when the command
-    is already runnable, has no managed runtime, or provisioning is disabled.
+    Returns ``(env, note)``. ``env`` (with provisioned toolchain(s) on ``PATH``)
+    is returned only when at least one runtime was provisioned; otherwise
+    ``None`` (caller uses inherited env). Composite commands are handled per
+    segment so e.g. ``cd client && npm test && cd server && pytest`` can
+    provision BOTH node and python. Dependency restore is run-level and handled
+    by the caller after provisioning.
     """
     if not test_command or not _managed_toolchain_enabled(config):
         return None, ""
@@ -570,10 +584,6 @@ def _provision_toolchain(
             continue
         _emit(progress_cb, phase="rr", event="toolchain_ready", runtime=runtime)
         merged_env = _merge_toolchain_env(merged_env, env)
-        _restore_dependencies(
-            execution_root, runtime, merged_env, progress_cb,
-            config=config, dep_locator_cb=dep_locator_cb,
-        )
 
     return merged_env, " ".join(n for n in notes if n).strip()
 
@@ -1495,7 +1505,13 @@ def run_cloud_refactor_requests(
     progress_cb = progress_cb or (lambda e: None)
     approval_cb = approval_cb or (lambda r: False)
 
-    execution_mode = str(constitution.get_setting("mode", "cloud_managed") or "cloud_managed")
+    from refactor_core.execution_variant import (
+        platform_inference_mode,
+        resolve_execution_variant,
+    )
+
+    variant = resolve_execution_variant(getattr(constitution, "settings", {}) or {})
+    execution_mode = platform_inference_mode(variant) or "cloud_managed"
     auth_ctx = ensure_authenticated(project_root)
     test_command, testcmd_note = _resolve_cloud_test_command(
         project_root=project_root,
@@ -1607,10 +1623,18 @@ def run_cloud_refactor_requests(
     if toolchain_note:
         notes.append(toolchain_note)
 
-    if not requests:
-        return _build_artifact(
-            run_store, run_id, constitution, model_id, outcomes, counts,
-            notes, stopped=False, stop_reason="", test_command=test_command,
+    # Run-level dependency preflight: always attempt dependency restoration for
+    # runtimes implied by the configured test command, even when binaries are
+    # already present on PATH. This prevents import-time baseline failures from
+    # deferring requests one-by-one later in the loop.
+    for runtime in _command_runtimes(test_command):
+        _restore_dependencies(
+            execution_root,
+            runtime,
+            toolchain_env,
+            progress_cb,
+            config=config,
+            dep_locator_cb=_dep_locator,
         )
 
     # Fail-fast: if a test command is configured but STILL not runnable after
@@ -1642,6 +1666,43 @@ def run_cloud_refactor_requests(
             notes, stopped=True, stop_reason=reason, test_command=test_command,
         )
 
+    # Run-level baseline characterization: execute ONCE and reuse for all RR
+    # steps. If baseline is red, stop the run before opening the RR session so
+    # requests are not deferred one-by-one for dependency/env failures.
+    baseline_ok, baseline_detail = _run_test(execution_root, test_command, env=toolchain_env)
+    _emit(
+        progress_cb,
+        phase="rr",
+        event="baseline_test",
+        rr_id="",
+        passed=baseline_ok,
+        detail=baseline_detail,
+        execution_env="host+toolchain" if toolchain_env else "host",
+    )
+    if not baseline_ok:
+        reason = (
+            "baseline characterization test is not green. "
+            f"Fix test/dependency issues, then retry. Detail: {baseline_detail}"
+        )
+        _emit(
+            progress_cb,
+            phase="rr",
+            event="preflight_failed",
+            reason=reason,
+            test_command=test_command or "",
+        )
+        notes.append(reason)
+        return _build_artifact(
+            run_store, run_id, constitution, model_id, outcomes, counts,
+            notes, stopped=True, stop_reason=reason, test_command=test_command,
+        )
+
+    if not requests:
+        return _build_artifact(
+            run_store, run_id, constitution, model_id, outcomes, counts,
+            notes, stopped=False, stop_reason="", test_command=test_command,
+        )
+
     session = _Session(
         auth_ctx=auth_ctx,
         execution_mode=execution_mode,
@@ -1704,6 +1765,10 @@ def run_cloud_refactor_requests(
 
     guard = 0
     max_iters = max(50, len(requests) * 25)
+    # Cache the single run-level baseline result and reuse it whenever the
+    # server asks for `run_baseline_test` for a specific RR.
+    cached_baseline: tuple[bool, str] = (baseline_ok, baseline_detail)
+
     while guard < max_iters:
         guard += 1
         act = str(action.get("action", ""))
@@ -1716,7 +1781,7 @@ 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(execution_root, test_command, env=toolchain_env)
+            passed, detail = cached_baseline
             _emit(progress_cb, phase="rr", event="baseline_test", rr_id=current_rr_id,
                   passed=passed, detail=detail,
                   execution_env="host+toolchain" if toolchain_env else "host")

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/refactorai_cli/commands/run_cmds.py

@@ -113,6 +113,12 @@ from refactor_core.store import (
     write_sandbox_preflight,
 )
 from refactor_core.testcmd import resolve_test_command
+from refactor_core.execution_variant import (
+    is_cloud_execution,
+    platform_inference_mode,
+    resolve_execution_variant,
+    uses_platform_inference,
+)
 
 from refactorai_cli.auth import AuthContext, AuthError, ensure_authenticated
 from refactorai_cli.client import PlatformClient, PlatformError
@@ -185,10 +191,10 @@ def _default_config_for_init() -> tuple[str, str]:
     if backend == BACKEND_LOCAL_SERVER:
         model_id = _setup_recommended_model_id()
         base_url = _setup_engine_base_url()
-        # local_server stays in `mode: local` but swaps the default heuristic
+        # local_model runs tests on the host and swaps the default heuristic
         # provider block for an Ollama block pointing at the local engine.
         config_text = DEFAULT_CONFIG.replace(
-            "# Heuristic (local, no LLM) - default for mode: local\n"
+            "# Heuristic (local, no LLM) - default for execution_variant: local_heuristic\n"
             "provider: heuristic\n"
             "model_id: heuristic-local-v1",
             "# Ollama (local engine) - configured by `refactor init`\n"
@@ -197,13 +203,18 @@ def _default_config_for_init() -> tuple[str, str]:
             f"base_url: {base_url}",
             1,
         )
+        config_text = config_text.replace(
+            "execution_variant: local_heuristic",
+            "execution_variant: local_model",
+            1,
+        )
         return config_text, "local_server"
     if backend == BACKEND_BYOK:
-        # BYOK only flips the execution mode. The developer chooses and
+        # BYOK only flips the execution variant. The developer chooses and
         # uncomments a provider block in the Provider selection section.
         config_text = DEFAULT_CONFIG.replace(
-            "mode: local\n# mode: cloud_byok",
-            "# mode: local\nmode: cloud_byok",
+            "execution_variant: local_heuristic",
+            "execution_variant: cloud_byok",
             1,
         )
         return config_text, "byok"
@@ -652,19 +663,36 @@ def _require_auth() -> None:
         raise typer.Exit(code=1) from exc
 
 
-def _cloud_execution_mode(constitution) -> str:
-    """Return the cloud execution mode for the project, or "" for local mode.
+def _platform_inference_mode(constitution) -> str:
+    """Platform inference ``execution_mode`` (``cloud_byok``/``cloud_managed``/"")."""
+    variant = resolve_execution_variant(getattr(constitution, "settings", {}) or {})
+    return platform_inference_mode(variant)
 
-    Recognizes both cloud modes (R20):
-    - ``cloud_managed``: platform-managed provider keys.
-    - ``cloud_byok``: developer-supplied provider credential (via credential_ref).
-    """
-    mode = str(constitution.get_setting("mode", "local") or "local").strip().lower()
-    return mode if mode in {"cloud_managed", "cloud_byok"} else ""
+
+def _execution_variant(constitution) -> str:
+    return resolve_execution_variant(getattr(constitution, "settings", {}) or {})
 
 
 def _is_cloud_mode(constitution) -> bool:
-    return bool(_cloud_execution_mode(constitution))
+    """True only for cloud-execution variants (loop + tests run server-side)."""
+    return is_cloud_execution(_execution_variant(constitution))
+
+
+def _guard_local_inference_ready(variant: str) -> None:
+    """Fail clearly for host-verified variants whose inference is not wired yet.
+
+    ``local_managed`` (host tests + Refactor-managed inference) needs a managed
+    on-host inference path that is not implemented yet; without this guard the
+    local provider factory would silently fall back to a default provider.
+    """
+    from refactor_core.execution_variant import LOCAL_MANAGED
+
+    if variant == LOCAL_MANAGED:
+        raise RuntimeError(
+            "local_managed (host tests + Refactor-managed inference) is not "
+            "available yet. Use local_heuristic, local_model, or local_byok for "
+            "host runs, or cloud_managed for managed inference in the cloud."
+        )
 
 
 def _documents_digest(documents: list | None) -> str:
@@ -871,7 +899,8 @@ def _cloud_inference(
         f.model_dump() if hasattr(f, "model_dump") else dict(f) for f in (findings or [])
     ]
 
-    execution_mode = _cloud_execution_mode(constitution) or "cloud_managed"
+    variant = _execution_variant(constitution)
+    execution_mode = platform_inference_mode(variant) or "cloud_managed"
     auth_ctx = ensure_authenticated(project_root)
     model_hint_value = model_hint or str(
         constitution.get_setting("model_id", "managed-default") or "managed-default"
@@ -3253,9 +3282,10 @@ def review(
         cloud = _is_cloud_mode(constitution)
         if _sandbox_enabled(project_config):
             if cloud:
+                variant = _execution_variant(constitution)
                 console.print(
                     f"[dim]review: sandbox.enabled is ignored in "
-                    f"{_cloud_execution_mode(constitution)} mode.[/dim]"
+                    f"{variant} variant.[/dim]"
                 )
             else:
                 sandbox_ctx = _ensure_sandbox_ready(
@@ -3281,6 +3311,7 @@ def review(
             from refactor_core.execution.orchestrator import run_with_mode
             from refactor_core.providers import get_provider
 
+            _guard_local_inference_ready(_execution_variant(constitution))
             selected_provider = get_provider(
                 constitution, project_root=project_root, provider_name=provider
             )
@@ -3622,9 +3653,10 @@ def code(
         sandbox_on = _sandbox_enabled(project_config)
         if _sandbox_enabled(project_config):
             if cloud:
+                variant = _execution_variant(constitution)
                 console.print(
                     f"[dim]code: sandbox.enabled is ignored in "
-                    f"{_cloud_execution_mode(constitution)} mode.[/dim]"
+                    f"{variant} variant.[/dim]"
                 )
             else:
                 sandbox_ctx = _ensure_sandbox_ready(
@@ -3638,6 +3670,7 @@ def code(
         if not cloud:
             from refactor_core.providers import get_provider
 
+            _guard_local_inference_ready(_execution_variant(constitution))
             selected_provider = get_provider(
                 constitution, project_root=project_root, provider_name=provider
             )
@@ -5036,6 +5069,7 @@ def _cloud_doctor(
     project_root: Path,
     constitution,
     execution_mode: str,
+    execution_variant: str,
     skip_ping: bool,
     dotenv: DotenvResult | None = None,
 ) -> None:
@@ -5047,6 +5081,7 @@ def _cloud_doctor(
     """
     console.print(f"[bold]project[/bold]: {project_root}")
     console.print(f"[bold]mode[/bold]: {execution_mode}")
+    console.print(f"[bold]execution variant[/bold]: {execution_variant}")
     _report_store_binding(project_root)
 
     try:
@@ -5253,12 +5288,13 @@ def doctor(
 
     _report_dotenv(dotenv, project_root)
 
-    execution_mode = _cloud_execution_mode(constitution)
-    if execution_mode:
+    execution_variant = _execution_variant(constitution)
+    if uses_platform_inference(execution_variant):
         _cloud_doctor(
             project_root=project_root,
             constitution=constitution,
-            execution_mode=execution_mode,
+            execution_mode=platform_inference_mode(execution_variant),
+            execution_variant=execution_variant,
             skip_ping=skip_ping,
             dotenv=dotenv,
         )
@@ -5274,11 +5310,11 @@ def doctor(
         supported_providers,
     )
 
-    mode = str(constitution.get_setting("mode", "local") or "local")
+    variant = _execution_variant(constitution)
     provider_name = resolve_provider_name(constitution, provider_name=provider)
 
     console.print(f"[bold]project[/bold]: {project_root}")
-    console.print(f"[bold]mode[/bold]: {mode}")
+    console.print(f"[bold]execution variant[/bold]: {variant}")
     console.print(f"[bold]provider[/bold]: {provider_name}")
     console.print(f"[bold]supported[/bold]: {', '.join(supported_providers())}")
     _report_store_binding(project_root)

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/refactorai_cli/commands/runtime_proxy_cmds.py

@@ -3,11 +3,12 @@
 The public CLI package is intentionally thin; operational commands are executed
 by the activated runtime artifact under ``~/.refactor/runtime``.
 
-Cloud modes (``cloud_managed`` / ``cloud_byok``) do not require a downloaded
-runtime: those commands are handled locally by ``run_cmds`` which offloads only
-the model call to the platform inference API. Each dual-path command below
-detects the project's execution mode and delegates to ``run_cmds`` for cloud
-modes, falling back to the proprietary runtime for local mode (R20, C1).
+Cloud-execution variants (``cloud_byok`` / ``cloud_managed``) run the whole
+loop server-side and do not require a downloaded runtime: those commands are
+handled by ``run_cmds`` speaking the cloud session protocol. Every ``local_*``
+variant verifies on the host via the proprietary runtime. Each dual-path
+command below resolves the project's execution variant and routes on
+verification location (cloud vs local).
 """
 
 from __future__ import annotations
@@ -24,29 +25,38 @@ console = Console()
 
 
 def _project_execution_mode() -> str:
-    """Return the configured execution mode for the current project.
+    """Return the configured execution variant for the current project.
 
-    Reads ``refactor.config`` without requiring a runtime. Returns ``"local"``
+    Reads ``refactor.config`` without requiring a runtime. Returns
+    ``"local_heuristic"``
     when no project files are present or mode is unset, so local behavior (and
     the existing "run `refactor init`" guidance downstream) is preserved.
     """
     try:
         from refactor_core.constitution import find_project_files, load_constitution
+        from refactor_core.execution_variant import resolve_execution_variant
 
         files = find_project_files()
         if not files:
-            return "local"
+            return "local_heuristic"
         consti_path, _config_path = files
         constitution = load_constitution(consti_path)
-        mode = str(constitution.get_setting("mode", "local") or "local").strip().lower()
-        return mode or "local"
+        return resolve_execution_variant(constitution.settings)
     except Exception:
         # Never let mode detection break command dispatch; default to local.
-        return "local"
+        return "local_heuristic"
 
 
 def _is_cloud_project() -> bool:
-    return _project_execution_mode() in {"cloud_managed", "cloud_byok"}
+    """True when the loop + tests run server-side (``cloud_byok`` / ``cloud_managed``).
+
+    Only the two ``cloud_*`` variants execute in the cloud; every ``local_*``
+    variant (including ``local_byok`` and ``local_managed``, which use remote
+    inference but verify on the host) runs through the local runtime.
+    """
+    from refactor_core.execution_variant import is_cloud_execution
+
+    return is_cloud_execution(_project_execution_mode())
 
 
 def _active_runtime_artifact() -> Path:

{refactorai_cli-0.7.8 → refactorai_cli-0.7.10}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.8
+Version: 0.7.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.2.19
+Requires-Dist: refactorai-core>=3.2.21
 
 # refactorai-cli
 

{refactorai_cli-0.7.8 → refactorai_cli-0.7.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.2.19
+refactorai-core>=3.2.21