refactorai-cli 0.7.23__tar.gz → 0.7.25__tar.gz

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/PKG-INFO

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

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/pyproject.toml

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

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/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.23"
+__version__ = "0.7.25"

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/refactorai_cli/cloud_rr.py

@@ -769,6 +769,62 @@ def _python_restore_commands(project_root: Path, config: dict) -> list[tuple[str
     return cmds
 
 
+def resolve_dependency_commands(
+    project_root: Path,
+    *,
+    config: dict,
+    runtimes: tuple[str, ...] | None = None,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
+) -> list[tuple[str, str]]:
+    """Ordered ``(label, shell-command)`` dependency-install steps for a project.
+
+    Single source of truth shared by the managed-host restore
+    (:func:`_restore_dependencies`) and the container sandbox preflight, so both
+    resolve dependencies identically instead of re-implementing per-ecosystem
+    heuristics. Resolution tiers (docs/35):
+
+    1. **Escape hatch** -- ``verification.deps_install`` is honored verbatim and
+       overrides everything, so nonstandard layouts have a deterministic path.
+    2. **Deterministic detection** -- lockfile-aware node install
+       (:func:`_node_install_command`) and the python manifest family
+       (:func:`_python_restore_commands`: requirements*, ``requirements/``,
+       Poetry/uv/PDM, PEP 621 extras).
+    3. **Validated agentic fallback** -- when python detection finds nothing and
+       ``dep_locator_cb`` is supplied (and not disabled via
+       ``verification.llm_dep_discovery``), the locator points at *where* deps are
+       declared; the callback re-validates every path/kind on disk before
+       returning a command (never a fabricated package or raw LLM command).
+
+    ``runtimes`` scopes detection (e.g. ``("node",)`` for an ``npm`` test
+    command); ``None`` considers both node and python.
+    """
+    configured = _configured_deps_install(config)
+    if configured:
+        return [(f"deps_install[{i}]", cmd) for i, cmd in enumerate(configured, start=1)]
+
+    selected = runtimes if runtimes is not None else ("node", "python")
+    out: list[tuple[str, str]] = []
+    seen: set[str] = set()
+
+    def _add(label: str, command: str) -> None:
+        if command not in seen:
+            seen.add(command)
+            out.append((label, command))
+
+    if "node" in selected and (project_root / "package.json").is_file():
+        _, node_command = _node_install_command(project_root)
+        _add("node", node_command)
+
+    if "python" in selected:
+        steps = _python_restore_commands(project_root, config)
+        if not steps and dep_locator_cb is not None and _llm_dep_discovery_enabled(config):
+            steps = dep_locator_cb(project_root)
+        for label, command in steps:
+            _add(label, command)
+
+    return out
+
+
 # --- LLM locator fallback (find WHERE deps are declared; never WHAT) --------- #
 # The model only points at existing files/dirs + a kind label; deterministic code
 # maps kind -> install command and re-verifies the path on disk. The model can

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/refactorai_cli/commands/run_cmds.py

@@ -931,9 +931,15 @@ def _cloud_inference(
     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"
-    )
+    # Managed modes are platform-selected: never derive a model hint from local
+    # config (the server picks the provider/model from the admin managed-inference
+    # config and ignores any client hint). Only BYOK reads a local model_id.
+    if execution_mode == "cloud_managed":
+        model_hint_value = model_hint or "managed-default"
+    else:
+        model_hint_value = model_hint or str(
+            constitution.get_setting("model_id", "managed-default") or "managed-default"
+        )
 
     # Split the indexed documents into context-safe batches so a large first
     # review is never sent as one oversized request that blows the read timeout.
@@ -1770,48 +1776,95 @@ def _command_binary(command: str) -> str | None:
     return tokens[0] if tokens else None
 
 
-def _install_plan_for_missing_binary(
-    *, project_root: Path, binary: str, installer: str | None
-) -> list[str]:
-    """Return a conservative install plan for missing toolchain commands."""
+def _binary_runtimes(binary: str) -> tuple[str, ...]:
+    """Map a test-command binary to the language runtime(s) whose dependencies it
+    needs, so dependency resolution is scoped to the relevant ecosystem."""
+    b = (binary or "").strip().lower()
+    if b in {"npm", "node", "npx", "yarn", "pnpm", "corepack"}:
+        return ("node",)
+    if b in {"python", "python3", "pip", "pip3", "pytest"}:
+        return ("python",)
+    return ()
+
+
+def _toolchain_pkg_command(*, binary: str, installer: str | None) -> str:
+    """Finite, bounded language-runtime provisioning for the sandbox image.
+
+    This is the one place that legitimately enumerates (a small, closed set of
+    language runtimes) -- installing the interpreter/toolchain the test command
+    needs. Dependency *resolution* is NOT done here; it is delegated to the shared
+    ``cloud_rr`` resolver so no per-project dependency logic is hardcoded.
+    """
     if not installer:
-        return []
-    pkg_cmd = ""
+        return ""
+    is_node = binary in {"npm", "node", "npx", "yarn", "pnpm"}
+    is_python = binary in {"python", "python3", "pip", "pip3", "pytest"}
     if installer == "apk":
-        if binary in {"npm", "node"}:
-            pkg_cmd = "apk add --no-cache nodejs npm"
-        elif binary in {"python", "python3", "pip", "pip3", "pytest"}:
-            pkg_cmd = "apk add --no-cache python3 py3-pip"
+        if is_node:
+            return "apk add --no-cache nodejs npm"
+        if is_python:
+            return "apk add --no-cache python3 py3-pip"
     elif installer == "apt-get":
-        if binary in {"npm", "node"}:
-            pkg_cmd = "apt-get update && apt-get install -y nodejs npm"
-        elif binary in {"python", "python3", "pip", "pip3", "pytest"}:
-            pkg_cmd = "apt-get update && apt-get install -y python3 python3-pip"
+        if is_node:
+            return "apt-get update && apt-get install -y nodejs npm"
+        if is_python:
+            return "apt-get update && apt-get install -y python3 python3-pip"
     elif installer in {"dnf", "yum"}:
-        if binary in {"npm", "node"}:
-            pkg_cmd = f"{installer} install -y nodejs npm"
-        elif binary in {"python", "python3", "pip", "pip3", "pytest"}:
-            pkg_cmd = f"{installer} install -y python3 python3-pip"
+        if is_node:
+            return f"{installer} install -y nodejs npm"
+        if is_python:
+            return f"{installer} install -y python3 python3-pip"
+    return ""
+
+
+def _install_plan_for_missing_binary(
+    *,
+    project_root: Path,
+    binary: str,
+    installer: str | None,
+    config: dict | None = None,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
+) -> list[str]:
+    """Install plan for a missing test-command binary: provision the language
+    runtime, then restore dependencies via the shared resolver.
+
+    Two clearly separated concerns:
+
+    * **Toolchain provisioning** (:func:`_toolchain_pkg_command`) -- a small,
+      finite map of language -> package-manager install for the container image.
+    * **Dependency restore** (:func:`cloud_rr.resolve_dependency_commands`) -- the
+      SAME resolver the cloud/managed-host path uses, so the sandbox honors the
+      ``verification.deps_install`` escape hatch, lockfile-aware node installs,
+      the full python manifest family (requirements*/Poetry/uv/PDM/PEP 621
+      extras), and the validated agentic fallback. Previously this path hardcoded
+      ``npm install`` / ``pip install -r requirements.txt``, which both rewrote
+      committed lockfiles and failed to scale to other ecosystems.
+    """
+    if not installer:
+        return []
+    from refactorai_cli.cloud_rr import resolve_dependency_commands
+
     plan: list[str] = []
+    pkg_cmd = _toolchain_pkg_command(binary=binary, installer=installer)
     if pkg_cmd:
         plan.append(pkg_cmd)
-    # Dependency restore after toolchain install. Use the SAME lockfile-aware
-    # installer as the cloud/managed path (single source of truth in
-    # ``cloud_rr._node_install_command``) so sandbox preflight never rewrites a
-    # committed lockfile: ``npm ci`` / ``yarn install --immutable`` /
-    # ``pnpm install --frozen-lockfile`` when a lockfile is present, falling back
-    # to ``npm install`` only for a lockfile-less project. Historically this path
-    # hardcoded ``npm install``, which regenerated ``package-lock.json`` /
-    # ``yarn.lock`` in the mounted tree and left the working tree dirty (blocking
-    # the refactor-branch flow); unifying on the lockfile-aware command removes
-    # that divergence at the source.
-    if (project_root / "package.json").is_file():
-        from refactorai_cli.cloud_rr import _node_install_command
 
-        _, node_install_cmd = _node_install_command(project_root)
-        plan.append(node_install_cmd)
-    elif (project_root / "requirements.txt").is_file():
-        plan.append("pip install -r requirements.txt")
+    dep_commands = [
+        cmd
+        for _label, cmd in resolve_dependency_commands(
+            project_root,
+            config=config or {},
+            runtimes=_binary_runtimes(binary),
+            dep_locator_cb=dep_locator_cb,
+        )
+    ]
+    # yarn/pnpm run through Corepack (the modern, version-pinned launcher). Minimal
+    # base images ship Node + npm but omit the corepack shim, so provision it on
+    # demand before any corepack command -- else the step dies with
+    # ``sh: corepack: not found``. Idempotent: skipped when already on PATH.
+    if any(cmd.startswith("corepack") for cmd in dep_commands):
+        plan.append("command -v corepack >/dev/null 2>&1 || npm install -g corepack")
+    plan.extend(dep_commands)
     return plan
 
 
@@ -2017,8 +2070,14 @@ def _sandbox_preflight(
     runtime: str | None = None,
     container_name: str | None = None,
     workdir: str | None = None,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
 ) -> tuple[bool, str]:
-    """Run sandbox preflight and optionally perform approved install plan."""
+    """Run sandbox preflight and optionally perform approved install plan.
+
+    ``dep_locator_cb`` is the optional validated agentic dependency-file locator
+    (see :func:`cloud_rr.resolve_dependency_commands`); when omitted, dependency
+    resolution uses the escape hatch + deterministic detection only.
+    """
     _sr = _sandbox_runtime()
     command_exists_in_container = _sr.command_exists_in_container
     command_exists_in_sandbox = _sr.command_exists_in_sandbox
@@ -2121,7 +2180,11 @@ def _sandbox_preflight(
     if missing_binary:
         plan.extend(
             _install_plan_for_missing_binary(
-                project_root=project_root, binary=missing_binary, installer=installer
+                project_root=project_root,
+                binary=missing_binary,
+                installer=installer,
+                config=config_settings,
+                dep_locator_cb=dep_locator_cb,
             )
         )
     lsp_plan, unsupported_lsp = _install_plan_for_missing_lsp(
@@ -2317,6 +2380,44 @@ def _sandbox_lifecycle(project_config) -> str:
     return lifecycle if lifecycle in {"per_project", "per_run"} else "per_project"
 
 
+def _build_sandbox_dep_locator(
+    project_root: Path, constitution, provider: str | None
+) -> Callable[[Path], list[tuple[str, str]]] | None:
+    """Best-effort validated agentic dependency-file locator for sandbox preflight.
+
+    Returns a ``callback(root) -> [(label, command)]`` that asks the platform
+    *where* dependencies are declared (nonstandard layouts), re-validating every
+    path/kind on disk before use -- the same locator the cloud RR loop uses
+    (docs/35). Returns ``None`` when a locator cannot be built (e.g. auth/context
+    unavailable), in which case preflight silently uses the escape hatch +
+    deterministic detection only. Never raises.
+    """
+    try:
+        from refactorai_cli.cloud_rr import _located_restore_commands
+
+        variant = _execution_variant(constitution)
+        execution_mode = platform_inference_mode(variant) or variant or "cloud_managed"
+        auth_ctx = ensure_authenticated(project_root)
+        model_hint = provider or str(constitution.get_setting("model_id", "") or "") or None
+
+        def _locator(root: Path) -> list[tuple[str, str]]:
+            try:
+                return _located_restore_commands(
+                    root,
+                    constitution=constitution,
+                    execution_mode=execution_mode,
+                    auth_ctx=auth_ctx,
+                    model_hint=model_hint,
+                    apply_byok_payload=_apply_byok_payload,
+                )
+            except Exception:
+                return []
+
+        return _locator
+    except Exception:
+        return None
+
+
 def _ensure_sandbox_ready(
     *,
     project_root: Path,
@@ -2325,8 +2426,13 @@ def _ensure_sandbox_ready(
     auto_approve_install: bool = False,
     no_install: bool = False,
     continue_on_preflight_failure: bool = False,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
 ) -> dict | None:
-    """Ensure sandbox lifecycle + preflight for stage execution."""
+    """Ensure sandbox lifecycle + preflight for stage execution.
+
+    ``dep_locator_cb`` is forwarded to preflight as the validated agentic
+    dependency-file locator (best-effort; ``None`` disables that fallback tier).
+    """
     _sr = _sandbox_runtime()
     resolve_runtime = _sr.resolve_runtime
     sandbox_name = _sr.sandbox_name
@@ -2379,6 +2485,7 @@ def _ensure_sandbox_ready(
         runtime=resolved_runtime,
         container_name=str(state.get("container_name", "") or ""),
         workdir=str(state.get("workdir") or workdir),
+        dep_locator_cb=dep_locator_cb,
     )
     if not preflight_ok:
         if continue_on_preflight_failure:
@@ -3728,6 +3835,9 @@ def code(
                     stage="code",
                     auto_approve_install=auto_approve,
                     no_install=False,
+                    dep_locator_cb=_build_sandbox_dep_locator(
+                        project_root, constitution, provider
+                    ),
                 )
             else:
                 variant = _execution_variant(constitution)

{refactorai_cli-0.7.23 → refactorai_cli-0.7.25}/refactorai_cli.egg-info/PKG-INFO

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