refactorai-cli 0.2.7__tar.gz → 0.2.9__tar.gz

{refactorai_cli-0.2.7 → refactorai_cli-0.2.9}/PKG-INFO

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

{refactorai_cli-0.2.7 → refactorai_cli-0.2.9}/pyproject.toml

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

{refactorai_cli-0.2.7 → refactorai_cli-0.2.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.2.7"
+__version__ = "0.2.9"

{refactorai_cli-0.2.7 → refactorai_cli-0.2.9}/refactorai_cli/commands/run_cmds.py

@@ -61,9 +61,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,
@@ -854,13 +857,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 +914,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 +933,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 +1044,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 +1064,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 +1078,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 +1175,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 +1187,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 +1272,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 +1539,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.9/refactorai_cli/commands/runtime_proxy_cmds.py

@@ -0,0 +1,138 @@
+"""Top-level run commands proxied to the downloaded proprietary runtime binary.
+
+The public CLI package is intentionally thin; operational commands are executed
+by the activated runtime artifact under ``~/.refactor/runtime``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from refactorai_cli.runtime_manager import runtime_artifact_path, runtime_status
+
+console = Console()
+
+
+def _active_runtime_artifact() -> Path:
+    status = runtime_status()
+    version = str(status.get("active_version") or "").strip()
+    if not version:
+        console.print(
+            "[red]No active runtime found.[/red] "
+            "Run `refactor setup` or `refactor runtime update` first."
+        )
+        raise typer.Exit(code=1)
+    artifact = runtime_artifact_path(version)
+    if not artifact.is_file():
+        console.print(
+            f"[red]Active runtime artifact is missing:[/red] {artifact}\n"
+            "Run `refactor runtime update` to recover."
+        )
+        raise typer.Exit(code=1)
+    return artifact
+
+
+def _exec_runtime(command_name: str, passthrough_args: list[str]) -> None:
+    artifact = _active_runtime_artifact()
+    # Best-effort ensure executable bit for artifacts downloaded on Linux/macOS.
+    try:
+        mode = artifact.stat().st_mode
+        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)
+
+
+def init(ctx: typer.Context) -> None:
+    """Initialize project state via proprietary runtime."""
+    _exec_runtime("init", list(ctx.args))
+
+
+def start(ctx: typer.Context) -> None:
+    """Start runtime-managed workflow via proprietary runtime."""
+    _exec_runtime("start", list(ctx.args))
+
+
+def stop(ctx: typer.Context) -> None:
+    """Stop runtime-managed workflow via proprietary runtime."""
+    _exec_runtime("stop", list(ctx.args))
+
+
+def shell(ctx: typer.Context) -> None:
+    """Open runtime shell via proprietary runtime."""
+    _exec_runtime("shell", list(ctx.args))
+
+
+def review(ctx: typer.Context) -> None:
+    """Run review via proprietary runtime."""
+    _exec_runtime("review", list(ctx.args))
+
+
+def code(ctx: typer.Context) -> None:
+    """Run code mode via proprietary runtime."""
+    _exec_runtime("code", list(ctx.args))
+
+
+def requests(ctx: typer.Context) -> None:
+    """Inspect/manage requests via proprietary runtime."""
+    _exec_runtime("requests", list(ctx.args))
+
+
+def apply(ctx: typer.Context) -> None:
+    """Apply pending changes via proprietary runtime."""
+    _exec_runtime("apply", list(ctx.args))
+
+
+def revert(ctx: typer.Context) -> None:
+    """Revert pending changes via proprietary runtime."""
+    _exec_runtime("revert", list(ctx.args))
+
+
+def status(ctx: typer.Context) -> None:
+    """Show runtime status via proprietary runtime."""
+    _exec_runtime("status", list(ctx.args))
+
+
+def diff(ctx: typer.Context) -> None:
+    """Show diff via proprietary runtime."""
+    _exec_runtime("diff", list(ctx.args))
+
+
+def gc(ctx: typer.Context) -> None:
+    """Run runtime GC/cleanup."""
+    _exec_runtime("gc", list(ctx.args))
+
+
+def check(ctx: typer.Context) -> None:
+    """Run checks via proprietary runtime."""
+    _exec_runtime("check", list(ctx.args))
+
+
+def doctor(ctx: typer.Context) -> None:
+    """Run diagnostics via proprietary runtime."""
+    _exec_runtime("doctor", list(ctx.args))
+
+
+def config(ctx: typer.Context) -> None:
+    """Manage config via proprietary runtime."""
+    _exec_runtime("config", list(ctx.args))

refactorai_cli-0.2.9/refactorai_cli/main.py

@@ -0,0 +1,69 @@
+"""`refactor` CLI entry point."""
+
+from __future__ import annotations
+
+import typer
+
+from refactorai_cli import __version__
+from refactorai_cli.commands import auth_cmds, engine_cmds, model_cmds, runtime_cmds, runtime_proxy_cmds, setup_cmds
+
+app = typer.Typer(
+    name="refactor",
+    help="Local-first AI code review and refactor, run from your project folder.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"refactor {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the CLI version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """refactor CLI."""
+
+
+# Auth (R7.1)
+app.command()(auth_cmds.login)
+app.command()(auth_cmds.whoami)
+
+# Project / run surface (proxied to activated runtime artifact)
+_RUNTIME_CTX = {"allow_extra_args": True, "ignore_unknown_options": True}
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.init)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.start)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.stop)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.shell)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.review)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.code)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.requests)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.apply)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.revert)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.status)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.diff)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.gc)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.check)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.doctor)
+app.command(context_settings=_RUNTIME_CTX)(runtime_proxy_cmds.config)
+
+app.command()(setup_cmds.setup)
+
+# Runtime/engine/model operations.
+app.add_typer(runtime_cmds.app, name="runtime")
+app.add_typer(engine_cmds.app, name="engine")
+app.add_typer(model_cmds.app, name="model")
+
+
+if __name__ == "__main__":
+    app()

{refactorai_cli-0.2.7 → refactorai_cli-0.2.9}/refactorai_cli.egg-info/PKG-INFO

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

{refactorai_cli-0.2.7 → refactorai_cli-0.2.9}/refactorai_cli.egg-info/SOURCES.txt

@@ -26,4 +26,5 @@ refactorai_cli/commands/model_cmds.py
 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-0.2.7/refactorai_cli/main.py

@@ -1,160 +0,0 @@
-"""`refactor` CLI entry point."""
-
-from __future__ import annotations
-
-import typer
-
-from refactorai_cli import __version__
-from refactorai_cli.commands import auth_cmds, engine_cmds, model_cmds, runtime_cmds, setup_cmds
-
-app = typer.Typer(
-    name="refactor",
-    help="Local-first AI code review and refactor, run from your project folder.",
-    no_args_is_help=True,
-    add_completion=False,
-)
-
-
-def _version_callback(value: bool) -> None:
-    if value:
-        typer.echo(f"refactor {__version__}")
-        raise typer.Exit()
-
-
-@app.callback()
-def main(
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        help="Show the CLI version and exit.",
-        callback=_version_callback,
-        is_eager=True,
-    ),
-) -> None:
-    """refactor CLI."""
-
-
-def _core_feature_unavailable(feature: str) -> None:
-    typer.echo(
-        f"{feature} is unavailable in this standalone CLI install because "
-        "core runtime modules are not installed in Python. Run `refactor setup` "
-        "to complete machine bootstrap, then retry."
-    )
-    raise typer.Exit(code=2)
-
-
-try:
-    from refactorai_cli.commands import run_cmds as _run_cmds
-except ModuleNotFoundError:
-    _run_cmds = None
-
-try:
-    from refactorai_cli.commands import rules_cmds as _rules_cmds
-except ModuleNotFoundError:
-    _rules_cmds = None
-
-
-# Auth (R7.1)
-app.command()(auth_cmds.login)
-app.command()(auth_cmds.whoami)
-
-if _run_cmds is not None:
-    # Project / run surface
-    app.command()(_run_cmds.init)
-    app.command()(_run_cmds.start)
-    app.command()(_run_cmds.stop)
-    app.command()(_run_cmds.shell)
-    app.command()(_run_cmds.review)
-    app.command()(_run_cmds.code)
-    app.command()(_run_cmds.requests)
-    app.command()(_run_cmds.apply)
-    app.command()(_run_cmds.revert)
-    app.command()(_run_cmds.status)
-    app.command()(_run_cmds.diff)
-    app.command()(_run_cmds.gc)
-    app.command()(_run_cmds.check)
-    app.command()(_run_cmds.doctor)
-    app.command()(_run_cmds.config)
-else:
-    @app.command("init")
-    def _init_stub() -> None:
-        _core_feature_unavailable("`refactor init`")
-
-    @app.command("start")
-    def _start_stub() -> None:
-        _core_feature_unavailable("`refactor start`")
-
-    @app.command("stop")
-    def _stop_stub() -> None:
-        _core_feature_unavailable("`refactor stop`")
-
-    @app.command("shell")
-    def _shell_stub() -> None:
-        _core_feature_unavailable("`refactor shell`")
-
-    @app.command("review")
-    def _review_stub() -> None:
-        _core_feature_unavailable("`refactor review`")
-
-    @app.command("code")
-    def _code_stub() -> None:
-        _core_feature_unavailable("`refactor code`")
-
-    @app.command("requests")
-    def _requests_stub() -> None:
-        _core_feature_unavailable("`refactor requests`")
-
-    @app.command("apply")
-    def _apply_stub() -> None:
-        _core_feature_unavailable("`refactor apply`")
-
-    @app.command("revert")
-    def _revert_stub() -> None:
-        _core_feature_unavailable("`refactor revert`")
-
-    @app.command("status")
-    def _status_stub() -> None:
-        _core_feature_unavailable("`refactor status`")
-
-    @app.command("diff")
-    def _diff_stub() -> None:
-        _core_feature_unavailable("`refactor diff`")
-
-    @app.command("gc")
-    def _gc_stub() -> None:
-        _core_feature_unavailable("`refactor gc`")
-
-    @app.command("check")
-    def _check_stub() -> None:
-        _core_feature_unavailable("`refactor check`")
-
-    @app.command("doctor")
-    def _doctor_stub() -> None:
-        _core_feature_unavailable("`refactor doctor`")
-
-    @app.command("config")
-    def _config_stub() -> None:
-        _core_feature_unavailable("`refactor config`")
-
-app.command()(setup_cmds.setup)
-
-# Runtime/engine/model operations.
-if _rules_cmds is not None:
-    app.add_typer(_rules_cmds.app, name="rules")
-else:
-    rules_stub_app = typer.Typer(help="Rules commands unavailable in this install.")
-
-    @rules_stub_app.callback(invoke_without_command=True)
-    def _rules_stub_callback() -> None:
-        _core_feature_unavailable("`refactor rules`")
-
-    app.add_typer(rules_stub_app, name="rules")
-
-app.add_typer(runtime_cmds.app, name="runtime")
-app.add_typer(engine_cmds.app, name="engine")
-app.add_typer(model_cmds.app, name="model")
-
-
-if __name__ == "__main__":
-    app()