refactorai-cli 0.1.0__py3-none-any.whl

refactor_cli/setup_flow.py

@@ -0,0 +1,412 @@
+"""Stage-based setup flow and checkpoints for local bootstrap (R16)."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+from refactor_core.engine_runtime import (
+    DEFAULT_ENGINE_CONTAINER,
+    engine_status,
+    ensure_engine_up,
+    pull_model,
+    resolve_runtime as resolve_engine_runtime,
+)
+from refactor_core.paths import ensure_dir, refactor_home
+
+from refactor_cli.auth import ensure_authenticated
+from refactor_cli.control_plane import ensure_lease, heartbeat, resolve_policy
+from refactor_cli.model_policy import detect_machine_profile, evaluate_model, recommended_model_id
+from refactor_cli.runtime_manager import activate_runtime, download_artifact, resolve_runtime_manifest, runtime_status
+
+SETUP_DIR = "setup"
+STATE_FILE = "state.json"
+BACKEND_LOCAL_SERVER = "local_server"
+BACKEND_BYOK = "byok"
+BACKEND_CHOICES = (BACKEND_LOCAL_SERVER, BACKEND_BYOK)
+STAGE_IDS = ("S1", "S2", "S3", "S4", "S5", "S6")
+STAGE_NAMES = {
+    "S1": "precheck",
+    "S2": "auth",
+    "S3": "runtime",
+    "S4": "backend_choice",
+    "S5": "backend_bootstrap",
+    "S6": "validate",
+}
+
+
+class SetupError(RuntimeError):
+    """Raised for setup-stage failures with actionable messages."""
+
+
+@dataclass
+class SetupResult:
+    status: str
+    completed_stages: list[str]
+    last_error: str = ""
+    execution_backend: str = ""
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def setup_root() -> Path:
+    return refactor_home() / SETUP_DIR
+
+
+def setup_state_path() -> Path:
+    return setup_root() / STATE_FILE
+
+
+def stage_output_path(stage_id: str) -> Path:
+    return setup_root() / f"stage-{stage_id}.json"
+
+
+def _default_state() -> dict:
+    return {
+        "status": "idle",
+        "current_stage": "",
+        "execution_backend": "",
+        "completed_stages": [],
+        "last_error": "",
+        "updated_at": "",
+    }
+
+
+def read_setup_state() -> dict:
+    path = setup_state_path()
+    if not path.is_file():
+        return _default_state()
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return _default_state()
+    out = _default_state()
+    out.update({k: payload.get(k, v) for k, v in out.items()})
+    if not isinstance(out.get("completed_stages"), list):
+        out["completed_stages"] = []
+    return out
+
+
+def write_setup_state(state: dict) -> None:
+    ensure_dir(setup_root())
+    merged = _default_state()
+    merged.update(state or {})
+    merged["updated_at"] = _now_iso()
+    path = setup_state_path()
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(merged, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def reset_setup_state() -> None:
+    write_setup_state(_default_state())
+
+
+def write_stage_output(stage_id: str, payload: dict) -> None:
+    ensure_dir(setup_root())
+    path = stage_output_path(stage_id)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(
+        json.dumps(
+            {
+                "stage_id": stage_id,
+                "stage": STAGE_NAMES.get(stage_id, stage_id),
+                "written_at": _now_iso(),
+                "output": payload,
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    tmp.replace(path)
+
+
+def get_setup_diagnostics() -> dict:
+    state = read_setup_state()
+    stages: dict[str, dict] = {}
+    for stage_id in STAGE_IDS:
+        path = stage_output_path(stage_id)
+        if not path.is_file():
+            continue
+        try:
+            stages[stage_id] = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            stages[stage_id] = {"error": "unreadable stage output"}
+    return {"state": state, "stages": stages}
+
+
+def _stage_s1_precheck(_ask_approval: Callable[[str], bool]) -> dict:
+    profile = detect_machine_profile()
+    runtime, reason = resolve_engine_runtime("podman")
+    disk = shutil.disk_usage(str(refactor_home()))
+    blockers: list[str] = []
+    if disk.free < 2 * 1024 * 1024 * 1024:
+        blockers.append("Less than 2GB free disk available in REFACTOR_HOME filesystem.")
+    if blockers:
+        raise SetupError("Precheck failed: " + "; ".join(blockers))
+    return {
+        "profile": profile,
+        "podman_available": bool(runtime),
+        "podman_reason": reason,
+        "disk_free_mb": int(disk.free / (1024 * 1024)),
+    }
+
+
+def _stage_s2_auth(_ask_approval: Callable[[str], bool]) -> dict:
+    auth = ensure_authenticated(force_remote=True)
+    lease = ensure_lease(force_refresh=True)
+    return {
+        "account_id": auth.account_id,
+        "quota_remaining": auth.quota_remaining,
+        "key_source": auth.key.source,
+        "lease_policy_revision": lease.policy_revision,
+        "lease_capabilities": lease.capabilities,
+    }
+
+
+def _stage_s3_runtime(ask_approval: Callable[[str], bool]) -> dict:
+    manifest = resolve_runtime_manifest(channel="stable")
+    if not ask_approval(f"Install runtime artifact version {manifest.runtime_version}?"):
+        raise SetupError("Runtime installation was not approved.")
+    artifact = download_artifact(manifest.artifact_url)
+    path = activate_runtime(manifest, artifact, channel="stable")
+    status = runtime_status()
+    return {
+        "runtime_version": manifest.runtime_version,
+        "artifact_path": str(path),
+        "runtime_status": status,
+    }
+
+
+def _normalize_backend(value: str | None) -> str:
+    candidate = str(value or "").strip().lower()
+    if candidate in BACKEND_CHOICES:
+        return candidate
+    return ""
+
+
+def _selected_backend() -> str:
+    state = read_setup_state()
+    backend = _normalize_backend(state.get("execution_backend"))
+    if not backend:
+        raise SetupError("Backend choice is missing. Re-run setup from stage S4.")
+    return backend
+
+
+def _stage_s4_backend_choice(ask_approval: Callable[[str], bool]) -> dict:
+    if ask_approval("Install local refactor-server and local model now?"):
+        backend = BACKEND_LOCAL_SERVER
+    else:
+        backend = BACKEND_BYOK
+    return {
+        "execution_backend": backend,
+        "available_backends": list(BACKEND_CHOICES),
+    }
+
+
+def _stage_s5_backend_bootstrap(ask_approval: Callable[[str], bool]) -> dict:
+    backend = _selected_backend()
+    if backend == BACKEND_BYOK:
+        return {
+            "execution_backend": BACKEND_BYOK,
+            "server_bootstrap": "skipped_by_choice",
+            "model_bootstrap": "skipped_by_choice",
+            "next": "Run `refactor init` and configure your provider credentials.",
+        }
+    if not ask_approval("Install/start local refactor-server and bootstrap model now?"):
+        raise SetupError("Local server bootstrap was not approved.")
+    runtime, reason = resolve_engine_runtime("podman")
+    if not runtime:
+        raise SetupError(reason or "Engine runtime unavailable.")
+    ok, message, state = ensure_engine_up(runtime=runtime)
+    if not ok:
+        raise SetupError(f"Local server bootstrap failed: {message}")
+    estatus = engine_status(runtime=runtime, container_name=DEFAULT_ENGINE_CONTAINER)
+    if str(estatus.get("status") or "").lower() != "ready":
+        raise SetupError("Local server is not ready. Run `refactor engine status` and retry from S5.")
+
+    policy = resolve_policy(force_refresh=False)
+    profile = detect_machine_profile()
+    model_id = recommended_model_id(policy, profile=str(profile["profile"]))
+    if not model_id:
+        raise SetupError("No recommended model available for this machine profile.")
+    decision = evaluate_model(model_id=model_id, policy_bundle=policy, profile=str(profile["profile"]))
+    if not decision.allowed:
+        suffix = f" Suggested: {decision.suggested_model_id}" if decision.suggested_model_id else ""
+        raise SetupError(f"{decision.message}{suffix}")
+    if not ask_approval(f"Pull recommended model '{model_id}' in local engine?"):
+        raise SetupError("Model pull was not approved.")
+    runtime, reason = resolve_engine_runtime("podman")
+    if not runtime:
+        raise SetupError(reason or "Engine runtime unavailable.")
+    ok, message = pull_model(runtime=runtime, container_name=DEFAULT_ENGINE_CONTAINER, model_id=model_id)
+    if not ok:
+        raise SetupError(f"Model pull failed: {message}")
+    return {
+        "execution_backend": BACKEND_LOCAL_SERVER,
+        "engine_status": estatus.get("status"),
+        "recommended_model_id": model_id,
+        "decision": decision.reason_code,
+        "profile": profile["profile"],
+    }
+
+
+def _stage_s6_validate(_ask_approval: Callable[[str], bool]) -> dict:
+    backend = _selected_backend()
+    runtime_status_data = runtime_status()
+    if not runtime_status_data.get("active_version") or not runtime_status_data.get("active_artifact_exists"):
+        raise SetupError("Runtime is not active. Re-run setup from stage S3.")
+    if backend == BACKEND_LOCAL_SERVER:
+        runtime, reason = resolve_engine_runtime("podman")
+        if not runtime:
+            raise SetupError(reason or "Engine runtime unavailable.")
+        estatus = engine_status(runtime=runtime, container_name=DEFAULT_ENGINE_CONTAINER)
+        if estatus.get("status") != "ready":
+            raise SetupError("Engine is not ready. Re-run setup from stage S5.")
+        heartbeat(
+            command="setup.validate.local_server",
+            result="ok",
+            duration_ms=0,
+            runtime_version=str(runtime_status_data.get("active_version") or ""),
+        )
+        return {
+            "execution_backend": backend,
+            "runtime_version": runtime_status_data.get("active_version"),
+            "engine_status": estatus.get("status"),
+        }
+    heartbeat(
+        command="setup.validate.byok",
+        result="ok",
+        duration_ms=0,
+        runtime_version=str(runtime_status_data.get("active_version") or ""),
+    )
+    return {
+        "execution_backend": backend,
+        "runtime_version": runtime_status_data.get("active_version"),
+        "provider_status": "pending_provider_configuration",
+    }
+
+
+STAGE_HANDLERS: dict[str, Callable[[Callable[[str], bool]], dict]] = {
+    "S1": _stage_s1_precheck,
+    "S2": _stage_s2_auth,
+    "S3": _stage_s3_runtime,
+    "S4": _stage_s4_backend_choice,
+    "S5": _stage_s5_backend_bootstrap,
+    "S6": _stage_s6_validate,
+}
+
+
+def run_setup(
+    *,
+    auto_approve: bool = False,
+    resume: bool = False,
+    from_stage: str | None = None,
+    ask_approval: Callable[[str], bool] | None = None,
+) -> SetupResult:
+    if ask_approval is None:
+        ask_approval = lambda _prompt: bool(auto_approve)
+    if from_stage and from_stage not in STAGE_IDS:
+        raise SetupError(f"Unknown stage '{from_stage}'. Expected one of: {', '.join(STAGE_IDS)}")
+    state = read_setup_state()
+    if not resume and not from_stage:
+        reset_setup_state()
+        state = read_setup_state()
+
+    completed = list(state.get("completed_stages") or [])
+    if from_stage:
+        start_index = STAGE_IDS.index(from_stage)
+        for stage_id in STAGE_IDS[start_index:]:
+            path = stage_output_path(stage_id)
+            if path.is_file():
+                path.unlink()
+    elif resume:
+        pending = [stage for stage in STAGE_IDS if stage not in completed]
+        if not pending:
+            return SetupResult(status="already_completed", completed_stages=completed, last_error="")
+        start_index = STAGE_IDS.index(pending[0])
+    else:
+        start_index = 0
+
+    write_setup_state(
+        {
+            "status": "in_progress",
+            "current_stage": STAGE_IDS[start_index],
+            "execution_backend": state.get("execution_backend", ""),
+            "completed_stages": completed,
+            "last_error": "",
+        }
+    )
+    for stage_id in STAGE_IDS[start_index:]:
+        write_setup_state(
+            {
+                "status": "in_progress",
+                "current_stage": stage_id,
+                "execution_backend": read_setup_state().get("execution_backend", ""),
+                "completed_stages": completed,
+                "last_error": "",
+            }
+        )
+        handler = STAGE_HANDLERS[stage_id]
+        try:
+            output = handler(ask_approval)
+        except SetupError as exc:
+            write_setup_state(
+                {
+                    "status": "failed",
+                    "current_stage": stage_id,
+                    "execution_backend": read_setup_state().get("execution_backend", ""),
+                    "completed_stages": completed,
+                    "last_error": str(exc),
+                }
+            )
+            raise
+        except Exception as exc:  # pragma: no cover - defensive path
+            write_setup_state(
+                {
+                    "status": "failed",
+                    "current_stage": stage_id,
+                    "execution_backend": read_setup_state().get("execution_backend", ""),
+                    "completed_stages": completed,
+                    "last_error": str(exc),
+                }
+            )
+            raise SetupError(f"Stage {stage_id} failed unexpectedly: {exc}") from exc
+        if stage_id == "S4":
+            chosen = _normalize_backend(output.get("execution_backend"))
+            if not chosen:
+                raise SetupError("Backend choice did not return a valid selection.")
+            write_setup_state(
+                {
+                    "status": "in_progress",
+                    "current_stage": stage_id,
+                    "execution_backend": chosen,
+                    "completed_stages": completed,
+                    "last_error": "",
+                }
+            )
+        write_stage_output(stage_id, output)
+        if stage_id not in completed:
+            completed.append(stage_id)
+    final_backend = _normalize_backend(read_setup_state().get("execution_backend"))
+    write_setup_state(
+        {
+            "status": "completed",
+            "current_stage": "",
+            "execution_backend": final_backend,
+            "completed_stages": completed,
+            "last_error": "",
+        }
+    )
+    return SetupResult(
+        status="completed",
+        completed_stages=completed,
+        last_error="",
+        execution_backend=final_backend,
+    )

refactorai_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: refactorai-cli
+Version: 0.1.0
+Summary: Local-first CLI for the refactor platform
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+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: refactor-core>=0.1.0
+
+# refactorai-cli
+
+Public CLI package for Refactor.
+
+- PyPI package name: `refactorai-cli`
+- Installed command: `refactor`
+- Python module package: `refactor_cli`
+
+## Local development install
+
+From repository root:
+
+```bash
+pip install -e refactor_core -e refactorai-cli
+```
+
+## Build
+
+From repository root:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build "./refactorai-cli"
+```
+
+Artifacts are created in:
+
+- `refactorai-cli/dist/*.whl`
+- `refactorai-cli/dist/*.tar.gz`
+
+## Publish
+
+```bash
+python -m twine check ./refactorai-cli/dist/*
+python -m twine upload ./refactorai-cli/dist/*
+```
+
+## Install test (local)
+
+```bash
+python -m pip install ./refactorai-cli/dist/refactorai_cli-0.1.0-py3-none-any.whl
+refactor --version
+```

refactorai_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+refactor_cli/__init__.py,sha256=z48_Q9yH5k83qlBUPbd4sEDyCVY2fJyoKtpl0Hc1ZZg,273
+refactor_cli/auth.py,sha256=qAjAizH3mDkTudRxODVwZtxjNdHMX8P_D8OTBbbqqAU,3616
+refactor_cli/client.py,sha256=u145fBgX4DvM0RfDJJMAanI375dGD7ZrXNTJ6p8qlvQ,1682
+refactor_cli/control_plane.py,sha256=xA1ch4M4FwZs_LyeqG0bBPsfPwN8UPUoJ0WMFrenQ5k,7994
+refactor_cli/credentials.py,sha256=6SwDCeTNDg8EzfDrlcF81QZbsN3GGvkgEjqyJUoEKWs,2046
+refactor_cli/main.py,sha256=74YzNvhpqeNNT-1JRfR-rAZpJi4Z_F_b1Q1Y8IJHPJs,1701
+refactor_cli/model_policy.py,sha256=cevlBp6TOhUmc-7iYOy9eQq272c2mZSC3MBCRmSzBhI,5239
+refactor_cli/runtime_manager.py,sha256=cs4bjbLBYLfRuj5FjdE6g8kj6gcDVM8OKgIStYqQvew,7904
+refactor_cli/settings.py,sha256=EObjAnMFDXFF-nc4eEZ-MuuJnTjrycUmGPr46kDbpIY,867
+refactor_cli/setup_flow.py,sha256=o0Vv7IDlB20Hr_8ZnXwcn_hg8RRUWef8A7bXh7fLo5g,14369
+refactor_cli/commands/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+refactor_cli/commands/auth_cmds.py,sha256=OyX1B-4JW34QcC6XmV5su5T41yFZ_LQIVNIBKKgY4dU,2904
+refactor_cli/commands/engine_cmds.py,sha256=8gPPFqxGAOI-rk5HlZMMtiUS2R5Hgy3YFlqePxU2j0k,5641
+refactor_cli/commands/model_cmds.py,sha256=sDrf5Yoeu3SmJQBKu4dcOPySXaZBJMD_tXDp-1JfEKI,5410
+refactor_cli/commands/rules_cmds.py,sha256=fs7Sk2Z7S-gG6rvx3lAEs-GPIm2m-GXBaZNS2Pe_yjY,4527
+refactor_cli/commands/run_cmds.py,sha256=31NORRBSLZLFcmmLGOtdA4U2157nKgS50eAQbZnR1ng,87336
+refactor_cli/commands/runtime_cmds.py,sha256=z75RAKcEzIT2FADIfJ8fTTmS9GFimEWOlZ6aJmO4A6c,6604
+refactor_cli/commands/setup_cmds.py,sha256=7nVPEVq8hZowWEOyCi9XHV1RozelyLZmrfr08v3Iz1w,2960
+refactorai_cli-0.1.0.dist-info/METADATA,sha256=4E1Q7UZELCZeNzufpmR4rZ6uoBq_H3YT8k03_vAMa4Y,1073
+refactorai_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+refactorai_cli-0.1.0.dist-info/entry_points.txt,sha256=u1uvoDxjmWshkIOgSlOFVZOYyYMObSU56VYAUAGGLeE,51
+refactorai_cli-0.1.0.dist-info/top_level.txt,sha256=6b9iP26oBAqYY_1PP-9r17jzX7q8Bf-e3wnOiCKnTLA,13
+refactorai_cli-0.1.0.dist-info/RECORD,,

refactorai_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

refactorai_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+refactor = refactor_cli.main:app

refactorai_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+refactor_cli