refactorai-cli 0.7.11__tar.gz → 0.7.12__tar.gz

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/PKG-INFO

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

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/pyproject.toml

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

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/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.11"
+__version__ = "0.7.12"

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli/client.py

@@ -143,3 +143,68 @@ class PlatformClient:
             )
         payload = response.json()
         return payload if isinstance(payload, dict) else {}
+
+    def get_project_execution_mode(self, developer_key: str, project_id: str) -> dict:
+        """Read a project's engine execution settings via the developer key.
+
+        Used by the CLI (``setup`` / ``doctor`` / ``watch``) to sync the server's
+        ``execution_mode`` (as chosen in the web UI) into the local
+        ``refactor.config`` -- server-wins. Returns the project record dict.
+        """
+        try:
+            response = httpx.get(
+                f"{self.base_url}/v1/projects/{project_id}/execution-mode",
+                headers={"Authorization": f"Bearer {developer_key}"},
+                timeout=self.timeout,
+            )
+        except httpx.HTTPError as exc:
+            raise PlatformError(f"Could not reach platform at {self.base_url}: {exc}") from exc
+        if response.status_code == 401:
+            raise PlatformError("Developer key is invalid or revoked", status_code=401)
+        if response.status_code == 404:
+            raise PlatformError("Project not found for this account", status_code=404)
+        if response.status_code >= 400:
+            raise PlatformError(
+                f"Could not read project execution mode ({response.status_code})",
+                status_code=response.status_code,
+            )
+        payload = response.json() if response.content else {}
+        return payload if isinstance(payload, dict) else {}
+
+    def set_project_execution_mode(
+        self, developer_key: str, project_id: str, execution_mode: str
+    ) -> dict:
+        """Push a chosen execution variant to the server project (developer key).
+
+        Lets ``refactor setup --mode`` keep the terminal and the web UI in sync.
+        Returns the updated project record dict.
+        """
+        try:
+            response = httpx.patch(
+                f"{self.base_url}/v1/projects/{project_id}/execution-mode",
+                headers={
+                    "Authorization": f"Bearer {developer_key}",
+                    "Content-Type": "application/json",
+                },
+                json={"execution_mode": execution_mode},
+                timeout=self.timeout,
+            )
+        except httpx.HTTPError as exc:
+            raise PlatformError(f"Could not reach platform at {self.base_url}: {exc}") from exc
+        if response.status_code == 401:
+            raise PlatformError("Developer key is invalid or revoked", status_code=401)
+        if response.status_code == 404:
+            raise PlatformError("Project not found for this account", status_code=404)
+        if response.status_code >= 400:
+            detail = ""
+            try:
+                detail = str((response.json() or {}).get("detail", ""))
+            except Exception:
+                detail = response.text[:200]
+            suffix = f": {detail}" if detail else ""
+            raise PlatformError(
+                f"Could not update project execution mode ({response.status_code}){suffix}",
+                status_code=response.status_code,
+            )
+        payload = response.json() if response.content else {}
+        return payload if isinstance(payload, dict) else {}

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli/commands/run_cmds.py

@@ -126,15 +126,8 @@ from refactorai_cli.auth import AuthContext, AuthError, ensure_authenticated
 from refactorai_cli.client import PlatformClient, PlatformError
 from refactorai_cli.credentials import load_credentials, save_credentials
 from refactorai_cli.dotenv_loader import DotenvResult, load_project_dotenv
-from refactorai_cli.local_engine_runtime import DEFAULT_ENGINE_PORT, read_engine_state
 from refactorai_cli.runtime_manager import runtime_status, runtime_version_dir
 from refactorai_cli.settings import mask_key, platform_url
-from refactorai_cli.setup_flow import (
-    BACKEND_BYOK,
-    BACKEND_LOCAL_SERVER,
-    read_setup_state,
-    stage_output_path,
-)
 
 console = Console()
 
@@ -165,66 +158,16 @@ def _sandbox_runtime():
     return _sr
 
 
-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()
-        # 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 execution_variant: local_heuristic\n"
-            "provider: heuristic\n"
-            "model_id: heuristic-local-v1",
-            "# Ollama (local engine) - configured by `refactor init`\n"
-            "provider: ollama\n"
-            f"model_id: {model_id}\n"
-            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 variant. The developer chooses and
-        # uncomments a provider block in the Provider selection section.
-        config_text = DEFAULT_CONFIG.replace(
-            "execution_variant: local_heuristic",
-            "execution_variant: cloud_byok",
-            1,
-        )
-        return config_text, "byok"
+    """Return the config `init` writes: always the ``local_heuristic`` default.
+
+    Mode selection is a *setup*-time concern (docs/46): after ``init`` the
+    developer picks the execution variant in the web UI or via ``refactor setup
+    --mode``, which persists it to ``refactor.config`` (and the server project).
+    ``init`` therefore never derives the mode from prior setup-backend state --
+    that legacy coupling produced configs whose variant disagreed with the
+    server's default and is intentionally removed.
+    """
     return DEFAULT_CONFIG, "default"
 
 _SEVERITY_STYLE = {
@@ -1479,7 +1422,7 @@ def init(
         raise typer.Exit(code=1)
 
     consti_target.write_text(DEFAULT_CONSTITUTION, encoding="utf-8")
-    config_text, config_profile = _default_config_for_init()
+    config_text, _config_profile = _default_config_for_init()
     config_text = _inject_project_id(config_text, project_id)
     config_target.write_text(config_text, encoding="utf-8")
     gitignore_updated = _ensure_refactor_gitignore(project_root)
@@ -1534,16 +1477,11 @@ def init(
         f"{account_label.title()}: [bold]{account_value}[/bold]. "
         f"Project id saved in {CONFIG_FILENAME}."
     )
-    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 "
-            "(mode=cloud_byok, env-key-first via provider_key; credential_ref is optional fallback)."
-        )
+    console.print(
+        "[green]Configured[/green] refactor.config with the default mode "
+        "([bold]local_heuristic[/bold]). Choose your execution mode (and provider "
+        "keys, if any) in the web UI or via `refactor setup --mode <variant>`."
+    )
     console.print(
         f"Added {CONSTITUTION_FILENAME}. "
         f"{CONFIG_FILENAME} is treated as local by default and added to .gitignore "
@@ -5360,6 +5298,21 @@ def doctor(
     consti_path, _ = files
     project_root = consti_path.parent
 
+    # Server-wins: pull the project's execution mode (as chosen in the web UI)
+    # into the local refactor.config before reading it, so doctor diagnoses the
+    # mode that runs will actually use. Best-effort; a no-op when offline.
+    try:
+        from refactorai_cli.mode_sync import sync_execution_variant_from_server
+
+        synced = sync_execution_variant_from_server(
+            project_root, emit=lambda m: console.print(f"[dim]{m}[/dim]")
+        )
+        if synced:
+            files = find_project_files() or files
+            consti_path, _ = files
+    except Exception:
+        pass
+
     # Load ``.env`` BEFORE parsing config so ``${VAR}`` interpolation (for
     # example ``provider_key: ${OPENAI_API_KEY}``) resolves from it. The
     # entrypoint already loads it for real runs; here we also surface the status

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli/commands/watch_cmds.py

@@ -1098,6 +1098,16 @@ def watch(
     _ensure_auth_in_window(json_output)
     _report_heartbeat(project_root)
 
+    # Server-wins: sync the project's execution mode (web UI choice) into the
+    # local refactor.config before the loop reads it. Silent + best-effort so it
+    # never pollutes the --json stream or blocks the terminal when offline.
+    try:
+        from refactorai_cli.mode_sync import sync_execution_variant_from_server
+
+        sync_execution_variant_from_server(project_root)
+    except Exception:
+        pass
+
     state = WatchState(repo_name=project_root.name)
     try:
         state.current_branch = git_scope.current_branch(project_root) or ""

refactorai_cli-0.7.12/refactorai_cli/mode_sync.py

@@ -0,0 +1,140 @@
+"""Execution-mode sync between the server project and local ``refactor.config``.
+
+The web UI sets a project's ``execution_mode`` on the server (JWT). The CLI
+authenticates with a developer key and treats the server as the source of truth
+(server-wins): ``setup`` / ``doctor`` / ``watch`` pull the server mode and write
+it into the local ``refactor.config`` so a UI change reflects in terminal runs.
+``refactor setup --mode`` also pushes the chosen variant up so both agree.
+
+All operations are best-effort: offline / unauthenticated / unbound projects are
+a silent no-op so they never break the surrounding command.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from refactor_core.constitution import CONFIG_FILENAME, find_project_files
+from refactor_core.execution_variant import (
+    normalize_execution_variant,
+    resolve_execution_variant,
+)
+from refactor_core.store import resolve_project_id
+
+from refactorai_cli.client import PlatformClient
+from refactorai_cli.credentials import resolve_developer_key
+
+
+def _local_config_path(project_root: Path) -> Path | None:
+    files = find_project_files(project_root)
+    if files:
+        return Path(files[1])
+    candidate = Path(project_root) / CONFIG_FILENAME
+    return candidate if candidate.is_file() else None
+
+
+def _read_local_variant(project_root: Path) -> str:
+    files = find_project_files(project_root)
+    if not files:
+        return ""
+    try:
+        from refactor_core.constitution import load_constitution
+
+        constitution = load_constitution(files[0])
+        return resolve_execution_variant(getattr(constitution, "settings", {}) or {})
+    except Exception:
+        return ""
+
+
+def _write_variant_to_config(config_path: Path, variant: str) -> bool:
+    """Replace (or append) the ``execution_variant`` line in refactor.config."""
+    try:
+        text = config_path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    lines = text.splitlines()
+    new_line = f"execution_variant: {variant}"
+    replaced = False
+    for idx, line in enumerate(lines):
+        if line.strip().startswith("execution_variant:"):
+            if line.strip() == new_line:
+                return False
+            lines[idx] = new_line
+            replaced = True
+            break
+    if not replaced:
+        lines.append(new_line)
+    try:
+        config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    except OSError:
+        return False
+    return True
+
+
+def sync_execution_variant_from_server(
+    project_root: Path,
+    *,
+    client: PlatformClient | None = None,
+    emit: Callable[[str], None] | None = None,
+) -> str | None:
+    """Pull the server project's execution mode into local config (server-wins).
+
+    Returns the newly applied variant when the local config was updated, else
+    ``None`` (already in sync, offline, unauthenticated, or unbound project).
+    """
+    try:
+        project_id = resolve_project_id(project_root)
+        if not project_id:
+            return None
+        resolved = resolve_developer_key(project_root)
+        if not resolved:
+            return None
+        client = client or PlatformClient()
+        record = client.get_project_execution_mode(resolved.key, project_id)
+    except Exception:
+        return None
+
+    server_variant = normalize_execution_variant((record or {}).get("execution_mode"))
+    if not server_variant:
+        return None
+    if server_variant == _read_local_variant(project_root):
+        return None
+    config_path = _local_config_path(project_root)
+    if config_path is None:
+        return None
+    if _write_variant_to_config(config_path, server_variant):
+        if emit:
+            emit(f"Synced execution_variant from server: {server_variant}")
+        return server_variant
+    return None
+
+
+def push_execution_variant_to_server(
+    project_root: Path,
+    variant: str,
+    *,
+    client: PlatformClient | None = None,
+    emit: Callable[[str], None] | None = None,
+) -> bool:
+    """Push a locally chosen execution variant to the server project.
+
+    Best-effort; returns ``True`` on a successful push, else ``False``.
+    """
+    normalized = normalize_execution_variant(variant)
+    if not normalized:
+        return False
+    try:
+        project_id = resolve_project_id(project_root)
+        if not project_id:
+            return False
+        resolved = resolve_developer_key(project_root)
+        if not resolved:
+            return False
+        client = client or PlatformClient()
+        client.set_project_execution_mode(resolved.key, project_id, normalized)
+    except Exception:
+        return False
+    if emit:
+        emit(f"Pushed execution_variant to server: {normalized}")
+    return True

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli/setup_flow.py

@@ -18,9 +18,11 @@ from rich.progress import BarColumn, DownloadColumn, Progress, TaskID, TextColum
 from refactorai_cli.local_engine_runtime import (
     DEFAULT_ENGINE_CONTAINER,
     DEFAULT_ENGINE_IMAGE,
+    DEFAULT_ENGINE_PORT,
     engine_status,
     ensure_engine_up,
     pull_model,
+    read_engine_state,
     resolve_runtime as resolve_engine_runtime,
 )
 from refactorai_cli.local_paths import ensure_dir, refactor_home
@@ -151,6 +153,19 @@ def write_stage_output(stage_id: str, payload: dict) -> None:
     tmp.replace(path)
 
 
+def read_stage_output(stage_id: str) -> dict:
+    """Return a stage's persisted ``output`` dict (or ``{}`` when absent)."""
+    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 get_setup_diagnostics() -> dict:
     state = read_setup_state()
     stages: dict[str, dict] = {}
@@ -562,12 +577,54 @@ def _resolve_project_variant() -> str:
         return ""
 
 
+def _local_model_provider_values() -> tuple[str, str]:
+    """Resolve (model_id, base_url) for the local_model Ollama provider block.
+
+    ``model_id`` prefers the S5 setup recommendation, falling back to a small
+    default; ``base_url`` targets the local engine port.
+    """
+    model_id = ""
+    try:
+        s5 = read_stage_output("S5")
+        model_id = str(s5.get("recommended_model_id") or "").strip()
+    except Exception:
+        model_id = ""
+    if not model_id:
+        model_id = "qwen2.5-coder:1.5b-instruct"
+    try:
+        port = int(read_engine_state().get("port", DEFAULT_ENGINE_PORT))
+    except Exception:
+        port = DEFAULT_ENGINE_PORT
+    return model_id, f"http://127.0.0.1:{port}/v1"
+
+
+def _apply_local_model_provider_block(text: str) -> str:
+    """Swap the default heuristic provider block for an Ollama block (local_model).
+
+    Only rewrites when the untouched heuristic default is still present, so a
+    developer who already configured a provider is never overwritten.
+    """
+    model_id, base_url = _local_model_provider_values()
+    return text.replace(
+        "# 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 setup --mode local_model`\n"
+        "provider: ollama\n"
+        f"model_id: {model_id}\n"
+        f"base_url: {base_url}",
+        1,
+    )
+
+
 def _persist_variant_to_project_config(variant: str, emit: Callable[[str], None] | None = None) -> None:
     """Write the chosen ``execution_variant`` into the project's refactor.config.
 
     Keeps a UI-selected or terminal-selected mode as the single source of truth
-    for subsequent runs (doctor/review/code read it from config). Best-effort: a
-    missing project config or write error never fails setup.
+    for subsequent runs (doctor/review/code read it from config). For
+    ``local_model`` it also swaps the default heuristic provider block for a local
+    Ollama block (docs/46: local_model provider config is a setup concern, not an
+    init concern). Best-effort: a missing config or write error never fails setup.
     """
     if not variant:
         return
@@ -580,14 +637,15 @@ def _persist_variant_to_project_config(variant: str, emit: Callable[[str], None]
         _consti_path, config_path = files
         config_path = Path(config_path)
         text = config_path.read_text(encoding="utf-8")
+        if variant == LOCAL_MODEL:
+            text = _apply_local_model_provider_block(text)
         lines = text.splitlines()
         new_line = f"execution_variant: {variant}"
         replaced = False
         for idx, line in enumerate(lines):
             if line.strip().startswith("execution_variant:"):
-                if line.strip() == new_line:
-                    return
-                lines[idx] = new_line
+                if line.strip() != new_line:
+                    lines[idx] = new_line
                 replaced = True
                 break
         if not replaced:
@@ -819,6 +877,20 @@ def run_setup(
         resolved_variant = _resolve_project_variant()
     if resolved_variant:
         _persist_variant_to_project_config(resolved_variant, on_progress)
+        # Push the chosen variant to the server project so the web UI and the
+        # terminal agree (server-wins on later syncs). Best-effort; never blocks
+        # setup when offline or the project is not bound to a cloud record.
+        try:
+            from refactor_core.constitution import find_project_files
+            from refactorai_cli.mode_sync import push_execution_variant_to_server
+
+            files = find_project_files()
+            if files:
+                push_execution_variant_to_server(
+                    Path(files[0]).parent, resolved_variant, emit=on_progress
+                )
+        except Exception:
+            pass
 
     state = read_setup_state()
     if not resume and not from_stage:

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli.egg-info/PKG-INFO

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

{refactorai_cli-0.7.11 → refactorai_cli-0.7.12}/refactorai_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ refactorai_cli/local_constitution.py
 refactorai_cli/local_engine_runtime.py
 refactorai_cli/local_paths.py
 refactorai_cli/main.py
+refactorai_cli/mode_sync.py
 refactorai_cli/model_policy.py
 refactorai_cli/pre_push_gate.py
 refactorai_cli/refactor_branch_store.py