refactorai-cli 0.2.8__tar.gz → 0.2.10__tar.gz

{refactorai_cli-0.2.8 → refactorai_cli-0.2.10}/PKG-INFO

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

{refactorai_cli-0.2.8 → refactorai_cli-0.2.10}/pyproject.toml

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

{refactorai_cli-0.2.8 → refactorai_cli-0.2.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.2.8"
+__version__ = "0.2.10"

{refactorai_cli-0.2.8 → refactorai_cli-0.2.10}/refactorai_cli/commands/run_cmds.py

@@ -8,6 +8,7 @@ generation and application.
 from __future__ import annotations
 
 import os
+import json
 import re
 import shlex
 import shutil
@@ -61,9 +62,12 @@ from refactor_core.sandbox_runtime import (
     DEFAULT_IMAGE as SANDBOX_DEFAULT_IMAGE,
     DEFAULT_SHELL as SANDBOX_DEFAULT_SHELL,
     attach_shell as attach_sandbox_shell,
+    command_exists_in_container,
     command_exists_in_sandbox,
+    detect_installer_in_container,
     detect_installer_in_sandbox,
     ensure_sandbox,
+    exec_in_container,
     exec_in_sandbox,
     remove_sandbox_container,
     sandbox_name,
@@ -89,10 +93,62 @@ from refactor_core.store import (
 from refactor_core.testcmd import resolve_test_command
 
 from refactorai_cli.auth import AuthError, ensure_authenticated
+from refactorai_cli.local_engine_runtime import DEFAULT_ENGINE_PORT, read_engine_state
 from refactorai_cli.settings import platform_url
+from refactorai_cli.setup_flow import (
+    BACKEND_BYOK,
+    BACKEND_LOCAL_SERVER,
+    read_setup_state,
+    stage_output_path,
+)
 
 console = Console()
 
+
+def _read_stage_output(stage_id: str) -> dict:
+    path = stage_output_path(stage_id)
+    if not path.is_file():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+    output = payload.get("output")
+    return output if isinstance(output, dict) else {}
+
+
+def _setup_recommended_model_id() -> str:
+    s5_output = _read_stage_output("S5")
+    model_id = str(s5_output.get("recommended_model_id") or "").strip()
+    return model_id or "qwen2.5-coder:1.5b-instruct"
+
+
+def _setup_engine_base_url() -> str:
+    state = read_engine_state()
+    try:
+        port = int(state.get("port", DEFAULT_ENGINE_PORT))
+    except (TypeError, ValueError):
+        port = DEFAULT_ENGINE_PORT
+    return f"http://127.0.0.1:{port}/v1"
+
+
+def _default_config_for_init() -> tuple[str, str]:
+    setup_state = read_setup_state()
+    backend = str(setup_state.get("execution_backend") or "").strip().lower()
+    if backend == BACKEND_LOCAL_SERVER:
+        model_id = _setup_recommended_model_id()
+        base_url = _setup_engine_base_url()
+        config_text = DEFAULT_CONFIG.replace("provider: heuristic", "provider: ollama", 1)
+        config_text = config_text.replace(
+            "model_id: heuristic-local-v1",
+            f"model_id: {model_id}\nbase_url: {base_url}",
+            1,
+        )
+        return config_text, "local_server"
+    if backend == BACKEND_BYOK:
+        return DEFAULT_CONFIG, "byok"
+    return DEFAULT_CONFIG, "default"
+
 _SEVERITY_STYLE = {
     "critical": "bold red",
     "high": "red",
@@ -600,12 +656,23 @@ def init(
         )
         raise typer.Exit(code=1)
     consti_target.write_text(DEFAULT_CONSTITUTION, encoding="utf-8")
-    config_target.write_text(DEFAULT_CONFIG, encoding="utf-8")
+    config_text, config_profile = _default_config_for_init()
+    config_target.write_text(config_text, encoding="utf-8")
 
     constitution = load_constitution(consti_target)
     record = register_project(project_root, constitution_hash=constitution.content_hash)
     console.print(f"[green]Created[/green] {consti_target}")
     console.print(f"[green]Created[/green] {config_target}")
+    if config_profile == "local_server":
+        console.print(
+            "[green]Configured[/green] refactor.config for local server setup "
+            "(provider=ollama with setup-recommended model)."
+        )
+    elif config_profile == "byok":
+        console.print(
+            "[green]Configured[/green] refactor.config for BYOK setup "
+            "(provider=heuristic; uncomment a provider block to use your key)."
+        )
     console.print(
         f"[green]Registered[/green] project in central store: {project_store_dir(project_root)}"
     )
@@ -854,13 +921,47 @@ def _sandbox_preflight(
     config_settings: dict,
     auto_approve: bool,
     no_install: bool,
+    runtime: str | None = None,
+    container_name: str | None = None,
+    workdir: str | None = None,
 ) -> tuple[bool, str]:
     """Run sandbox preflight and optionally perform approved install plan."""
+
+    has_container_ctx = bool(runtime and container_name)
+    resolved_workdir = str(workdir or "/workspace")
+
+    def _binary_exists(binary: str) -> bool:
+        if has_container_ctx:
+            return command_exists_in_container(
+                runtime=str(runtime),
+                container_name=str(container_name),
+                binary=binary,
+                workdir=resolved_workdir,
+            )
+        return command_exists_in_sandbox(project_root=project_root, binary=binary)
+
+    def _exec(command: str) -> tuple[bool, str]:
+        if has_container_ctx:
+            return exec_in_container(
+                runtime=str(runtime),
+                container_name=str(container_name),
+                command=command,
+                workdir=resolved_workdir,
+            )
+        return exec_in_sandbox(project_root=project_root, command=command)
+
+    def _detect_installer() -> str | None:
+        if has_container_ctx:
+            return detect_installer_in_container(
+                runtime=str(runtime),
+                container_name=str(container_name),
+                workdir=resolved_workdir,
+            )
+        return detect_installer_in_sandbox(project_root=project_root)
+
     test_command = resolve_test_command(project_root, config_settings)
     required_lsp = _required_lsp_commands(project_root)
-    missing_lsp = [
-        cmd for cmd in sorted(required_lsp) if not command_exists_in_sandbox(project_root=project_root, binary=cmd)
-    ]
+    missing_lsp = [cmd for cmd in sorted(required_lsp) if not _binary_exists(cmd)]
     missing_binary = ""
     test_command_present = ""
     if test_command:
@@ -877,7 +978,7 @@ def _sandbox_preflight(
             )
             return False, f"Could not parse test command: {test_command!r}"
         test_command_present = binary
-        if not command_exists_in_sandbox(project_root=project_root, binary=binary):
+        if not _binary_exists(binary):
             missing_binary = binary
 
     if not missing_binary and not missing_lsp:
@@ -896,7 +997,7 @@ def _sandbox_preflight(
             return True, "No test command configured."
         return True, f"Preflight ok: found '{test_command_present}' and required LSP server(s) in sandbox."
 
-    installer = detect_installer_in_sandbox(project_root=project_root)
+    installer = _detect_installer()
     plan: list[str] = []
     if missing_binary:
         plan.extend(
@@ -1007,7 +1108,7 @@ def _sandbox_preflight(
         "results": [],
     }
     for cmd in plan:
-        ok, output = exec_in_sandbox(project_root=project_root, command=cmd)
+        ok, output = _exec(cmd)
         entry["results"].append({"command": cmd, "ok": ok, "output": (output or "")[:500]})
         if not ok:
             detail = output[:400] if output else "unknown error"
@@ -1027,7 +1128,7 @@ def _sandbox_preflight(
             return False, f"Install command failed: `{cmd}` -> {detail}"
     append_sandbox_install_history(project_root, entry)
 
-    if missing_binary and not command_exists_in_sandbox(project_root=project_root, binary=missing_binary):
+    if missing_binary and not _binary_exists(missing_binary):
         write_sandbox_preflight(
             project_root,
             {
@@ -1041,9 +1142,7 @@ def _sandbox_preflight(
             },
         )
         return False, f"Preflight still failed after install: '{missing_binary}' not found."
-    still_missing_lsp = [
-        cmd for cmd in missing_lsp if not command_exists_in_sandbox(project_root=project_root, binary=cmd)
-    ]
+    still_missing_lsp = [cmd for cmd in missing_lsp if not _binary_exists(cmd)]
     if still_missing_lsp:
         write_sandbox_preflight(
             project_root,
@@ -1140,6 +1239,9 @@ def _ensure_sandbox_ready(
         config_settings=settings,
         auto_approve=auto_approve_install,
         no_install=no_install,
+        runtime=resolved_runtime,
+        container_name=str(state.get("container_name", "") or ""),
+        workdir=str(state.get("workdir") or workdir),
     )
     if not preflight_ok:
         console.print(f"[red]{stage}: {preflight_msg}[/red]")
@@ -1149,6 +1251,7 @@ def _ensure_sandbox_ready(
         "ephemeral": ephemeral,
         "runtime": resolved_runtime,
         "container_name": state.get("container_name", ""),
+        "workdir": str(state.get("workdir") or workdir),
         "stage": stage,
     }
 
@@ -1233,6 +1336,9 @@ def start(
         config_settings=settings,
         auto_approve=yes,
         no_install=no_install,
+        runtime=resolved_runtime,
+        container_name=str(state.get("container_name", "") or ""),
+        workdir=str(state.get("workdir") or workdir),
     )
     if not preflight_ok:
         console.print(f"[red]{preflight_msg}[/red]")
@@ -1497,8 +1603,11 @@ def code(
                 constitution=constitution,
                 provider=selected_provider,
                 requests=requests,
-                config=dict(getattr(project_config, "settings", {}) or {})
-                | ({"sandbox": {"enabled": True}} if sandbox_on else {})
+                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 {}),
                 progress_cb=_rr_progress_logger(status=status),
                 approval_cb=_rr_approval_prompt(auto_approve=auto_approve),

{refactorai_cli-0.2.8 → refactorai_cli-0.2.10}/refactorai_cli/commands/runtime_proxy_cmds.py

@@ -44,6 +44,20 @@ def _exec_runtime(command_name: str, passthrough_args: list[str]) -> None:
         artifact.chmod(mode | 0o111)
     except OSError:
         pass
+    probe = subprocess.run(
+        [str(artifact), command_name, "--help"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    probe_text = f"{probe.stdout}\n{probe.stderr}".lower()
+    if "unrecognized arguments" in probe_text and command_name in probe_text:
+        console.print(
+            "[red]Active runtime artifact does not support command dispatch yet.[/red]\n"
+            "Run `refactor runtime update` (or rerun setup from S3) to install the "
+            "latest runtime binary from your server."
+        )
+        raise typer.Exit(code=2)
     proc = subprocess.run([str(artifact), command_name, *passthrough_args], check=False)
     if proc.returncode != 0:
         raise typer.Exit(code=proc.returncode)

{refactorai_cli-0.2.8 → refactorai_cli-0.2.10}/refactorai_cli.egg-info/PKG-INFO

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