refactorai-cli 0.7.6__tar.gz → 0.7.7__tar.gz

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.6
+Version: 0.7.7
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ 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: refactorai-core>=3.2.18
+Requires-Dist: refactorai-core>=3.2.19
 
 # refactorai-cli
 

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.7.6"
+version = "0.7.7"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ dependencies = [
   "httpx>=0.27.0",
   "rich>=13.7.0",
   "PyYAML>=6.0.1",
-  "refactorai-core>=3.2.18",
+  "refactorai-core>=3.2.19",
 ]
 
 [project.scripts]

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/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.6"
+__version__ = "0.7.7"

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/refactorai_cli/cloud_rr.py

@@ -31,6 +31,7 @@ import re
 import shlex
 import shutil
 import subprocess
+import tomllib
 from pathlib import Path
 from typing import Callable
 
@@ -516,6 +517,7 @@ def _provision_toolchain(
     *,
     consent_cb: Callable[[dict], bool] | None,
     progress_cb: Callable[[dict], None] | None,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
 ) -> tuple[dict | None, str]:
     """Provision managed runtimes for every missing binary in ``test_command``.
 
@@ -568,11 +570,323 @@ def _provision_toolchain(
             continue
         _emit(progress_cb, phase="rr", event="toolchain_ready", runtime=runtime)
         merged_env = _merge_toolchain_env(merged_env, env)
-        _restore_dependencies(execution_root, runtime, merged_env, progress_cb, config=config)
+        _restore_dependencies(
+            execution_root, runtime, merged_env, progress_cb,
+            config=config, dep_locator_cb=dep_locator_cb,
+        )
 
     return merged_env, " ".join(n for n in notes if n).strip()
 
 
+# Conventional pip requirements files, base first so dev/test variants layer on
+# top. A project may ship several; all present ones are installed.
+_PY_REQUIREMENTS_FILES = (
+    "requirements.txt",
+    "requirements-dev.txt",
+    "requirements_dev.txt",
+    "dev-requirements.txt",
+    "dev_requirements.txt",
+    "requirements-test.txt",
+    "requirements_test.txt",
+    "test-requirements.txt",
+    "test_requirements.txt",
+)
+# Conventional PEP 621 optional-dependency (extras) groups that hold test deps.
+_PY_TEST_EXTRA_CANDIDATES = ("test", "tests", "dev", "develop", "testing", "dev-test")
+
+
+def _leading_binary(command: str) -> str:
+    """First executable token of a command (``""`` when unparseable/empty)."""
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return ""
+    return parts[0] if parts else ""
+
+
+def _load_pyproject(pyproject: Path) -> dict:
+    """Parse ``pyproject.toml`` into a dict (``{}`` on any read/parse failure)."""
+    try:
+        with pyproject.open("rb") as fh:
+            data = tomllib.load(fh)
+    except (OSError, tomllib.TOMLDecodeError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _configured_deps_install(config: dict) -> list[str]:
+    """Explicit developer-specified install commands (escape hatch).
+
+    ``verification.deps_install`` may be a string or list of shell commands. When
+    set it is honored verbatim and short-circuits auto-detection, so nonstandard
+    dependency layouts always have a deterministic path.
+    """
+    verification = (config or {}).get("verification")
+    if not isinstance(verification, dict):
+        return []
+    raw = verification.get("deps_install")
+    if isinstance(raw, str):
+        raw = [raw]
+    if not isinstance(raw, list):
+        return []
+    return [str(cmd).strip() for cmd in raw if str(cmd).strip()]
+
+
+def _resolve_test_extras(config: dict, pyproject_data: dict) -> list[str]:
+    """Resolve pip extras that carry test deps.
+
+    Explicit ``verification.extras`` wins (developer intent, possibly nonstandard
+    names). Otherwise auto-detect conventionally named extras that actually exist
+    under ``[project.optional-dependencies]`` so ``pip install -e .[test]`` pulls
+    the test dependencies without configuration.
+    """
+    verification = (config or {}).get("verification")
+    if isinstance(verification, dict):
+        raw = verification.get("extras")
+        if isinstance(raw, str):
+            raw = [raw]
+        if isinstance(raw, list):
+            explicit = [str(e).strip() for e in raw if str(e).strip()]
+            if explicit:
+                return explicit
+
+    project = pyproject_data.get("project") if isinstance(pyproject_data, dict) else None
+    optional = project.get("optional-dependencies") if isinstance(project, dict) else None
+    if not isinstance(optional, dict):
+        return []
+    present = {str(name).strip().lower(): str(name) for name in optional.keys()}
+    return [present[name] for name in _PY_TEST_EXTRA_CANDIDATES if name in present]
+
+
+def _python_restore_commands(project_root: Path, config: dict) -> list[tuple[str, str]]:
+    """Deterministically resolve ordered python dependency-install commands.
+
+    Detection (no LLM, no fabricated packages) covers the common declaration
+    sites: the ``requirements*.txt`` family, a ``requirements/`` directory, tool
+    managed projects (Poetry/uv/PDM via lockfile or ``[tool.*]``), and PEP 621 /
+    setuptools projects (editable install with auto-detected test extras). An
+    explicit ``verification.deps_install`` overrides everything.
+    """
+    configured = _configured_deps_install(config)
+    if configured:
+        return [(f"deps_install[{i}]", cmd) for i, cmd in enumerate(configured, start=1)]
+
+    cmds: list[tuple[str, str]] = []
+    seen: set[str] = set()
+
+    def _add(label: str, command: str) -> None:
+        if command not in seen:
+            seen.add(command)
+            cmds.append((label, command))
+
+    # a) requirements* files, then a requirements/ directory layout.
+    for name in _PY_REQUIREMENTS_FILES:
+        if (project_root / name).is_file():
+            _add(name, f"python -m pip install -r {name}")
+    req_dir = project_root / "requirements"
+    if req_dir.is_dir():
+        for child in sorted(req_dir.glob("*.txt")):
+            rel = child.relative_to(project_root).as_posix()
+            _add(rel, f"python -m pip install -r {rel}")
+
+    pyproject = project_root / "pyproject.toml"
+    pyproject_data = _load_pyproject(pyproject) if pyproject.is_file() else {}
+    tool = pyproject_data.get("tool") if isinstance(pyproject_data, dict) else {}
+    tool = tool if isinstance(tool, dict) else {}
+
+    # b) tool-managed projects: prefer the project's own resolver for dev deps.
+    #    These are best-effort and skipped at run time when the tool is absent.
+    tool_managed = False
+    if (project_root / "poetry.lock").is_file() or "poetry" in tool:
+        _add("poetry", "poetry install --with dev --no-root")
+        tool_managed = True
+    elif (project_root / "uv.lock").is_file() or "uv" in tool:
+        _add("uv", "uv sync --all-extras")
+        tool_managed = True
+    elif (project_root / "pdm.lock").is_file() or "pdm" in tool:
+        _add("pdm", "pdm install -d")
+        tool_managed = True
+
+    # c) PEP 621 / setuptools editable install with test extras (pip fallback that
+    #    always works with the toolchain-provisioned python).
+    has_setuptools_manifest = (
+        pyproject.is_file()
+        or (project_root / "setup.py").is_file()
+        or (project_root / "setup.cfg").is_file()
+    )
+    if has_setuptools_manifest and not tool_managed:
+        extras = _resolve_test_extras(config, pyproject_data)
+        target = "." if not extras else f".[{','.join(extras)}]"
+        _add("project", f'python -m pip install -e "{target}"')
+
+    return cmds
+
+
+# --- 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
+# never fabricate a package or a shell command.
+_LLM_LOCATABLE_KINDS = {"pip-requirements", "pip-editable", "poetry", "uv", "pdm"}
+
+
+def _llm_dep_discovery_enabled(config: dict) -> bool:
+    """Whether the cloud dependency-file locator fallback is allowed (default on)."""
+    verification = (config or {}).get("verification")
+    if isinstance(verification, dict) and "llm_dep_discovery" in verification:
+        return bool(verification.get("llm_dep_discovery"))
+    return True
+
+
+def _list_repo_files(project_root: Path, *, max_files: int = 400) -> list[str]:
+    """Bounded, skip-aware listing of repo-relative file paths (for the locator)."""
+    root = Path(project_root)
+    out: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [
+            d for d in dirnames if d not in _SKIP_DIRS and d not in _WORKSPACE_EXCLUDE and not d.startswith(".")
+        ]
+        for name in sorted(filenames):
+            rel = (Path(dirpath) / name).relative_to(root).as_posix()
+            out.append(rel)
+            if len(out) >= max_files:
+                return out
+    return out
+
+
+def _locate_dependency_files_via_cloud(
+    *,
+    project_root: Path,
+    constitution,
+    execution_mode: str,
+    auth_ctx,
+    model_hint: str | None,
+    apply_byok_payload: Callable[[dict, object], None] | None,
+) -> list[dict]:
+    """Ask the server which files declare dependencies (best-effort, structured).
+
+    Returns a list of ``{"path", "kind"}`` entries (unvalidated). Any transport/
+    parse/auth issue returns ``[]`` so the caller safely falls back to deferral.
+    The model is given only a file listing + manifest snippets and must return
+    *locations*, never install commands or package names.
+    """
+    manifests = _collect_test_manifests(project_root)
+    listing = _list_repo_files(project_root)
+    if not listing:
+        return []
+    documents = manifests + [{"path": "__file_listing__", "content": "\n".join(listing)}]
+    payload = {
+        "stage": "rr_locate_deps",
+        "constitution_hash": constitution.content_hash,
+        "constitution_body": getattr(constitution, "body", "") or "",
+        "model_hint": model_hint,
+        "documents": documents,
+        "execution_mode": execution_mode,
+    }
+    if execution_mode == "cloud_byok" and apply_byok_payload is not None:
+        apply_byok_payload(payload, constitution)
+    idem = hashlib.sha256(
+        "|".join(
+            [auth_ctx.account_id, execution_mode, constitution.content_hash, "rr_locate_deps"]
+        ).encode("utf-8")
+    ).hexdigest()
+    try:
+        resp = httpx.post(
+            f"{platform_url()}/v1/inference/refactor",
+            headers={
+                "Authorization": f"Bearer {auth_ctx.key.key}",
+                "Content-Type": "application/json",
+                "Idempotency-Key": idem,
+            },
+            json=payload,
+            timeout=45.0,
+        )
+    except httpx.HTTPError:
+        return []
+    if resp.status_code != 200:
+        return []
+    try:
+        data = resp.json() if resp.content else {}
+    except ValueError:
+        return []
+    entries = (data or {}).get("dependency_files")
+    if not isinstance(entries, list):
+        return []
+    out: list[dict] = []
+    for entry in entries:
+        if isinstance(entry, dict) and entry.get("path") and entry.get("kind"):
+            out.append({"path": str(entry["path"]).strip(), "kind": str(entry["kind"]).strip().lower()})
+    return out
+
+
+def _validate_located_command(project_root: Path, entry: dict) -> tuple[str, str] | None:
+    """Map a validated ``{path, kind}`` locator entry to an install command.
+
+    Defense-in-depth: the ``kind`` must be allowlisted and the referenced path
+    must resolve *inside* the project root and exist on disk. Anything else is
+    rejected (returns ``None``) so a bad suggestion can never run.
+    """
+    kind = str(entry.get("kind", "")).strip().lower()
+    raw_path = str(entry.get("path", "")).strip().replace("\\", "/")
+    if kind not in _LLM_LOCATABLE_KINDS or not raw_path:
+        return None
+    root = Path(project_root).resolve()
+    candidate = (root / raw_path).resolve()
+    try:
+        candidate.relative_to(root)  # reject absolute / `..` escapes
+    except ValueError:
+        return None
+    if not candidate.exists():
+        return None
+
+    rel = candidate.relative_to(root).as_posix()
+    # Directory context for editable/tool installs (parent dir of a manifest file).
+    work_dir = candidate if candidate.is_dir() else candidate.parent
+    rel_dir = work_dir.relative_to(root).as_posix()
+    cd_prefix = "" if rel_dir in ("", ".") else f'cd "{rel_dir}" && '
+
+    if kind == "pip-requirements":
+        if not candidate.is_file():
+            return None
+        return (f"located:{rel}", f'python -m pip install -r "{rel}"')
+    if kind == "pip-editable":
+        return (f"located:{rel_dir or '.'}", f'{cd_prefix}python -m pip install -e "."')
+    if kind == "poetry":
+        return (f"located:poetry:{rel_dir or '.'}", f"{cd_prefix}poetry install --with dev --no-root")
+    if kind == "uv":
+        return (f"located:uv:{rel_dir or '.'}", f"{cd_prefix}uv sync --all-extras")
+    if kind == "pdm":
+        return (f"located:pdm:{rel_dir or '.'}", f"{cd_prefix}pdm install -d")
+    return None
+
+
+def _located_restore_commands(
+    project_root: Path,
+    *,
+    constitution,
+    execution_mode: str,
+    auth_ctx,
+    model_hint: str | None,
+    apply_byok_payload: Callable[[dict, object], None] | None,
+) -> list[tuple[str, str]]:
+    """Resolve LLM-located dependency install commands (validated + deduped)."""
+    located = _locate_dependency_files_via_cloud(
+        project_root=project_root,
+        constitution=constitution,
+        execution_mode=execution_mode,
+        auth_ctx=auth_ctx,
+        model_hint=model_hint,
+        apply_byok_payload=apply_byok_payload,
+    )
+    cmds: list[tuple[str, str]] = []
+    seen: set[str] = set()
+    for entry in located:
+        resolved = _validate_located_command(project_root, entry)
+        if resolved and resolved[1] not in seen:
+            seen.add(resolved[1])
+            cmds.append(resolved)
+    return cmds
+
+
 def _restore_dependencies(
     project_root: Path,
     runtime: str,
@@ -580,6 +894,7 @@ def _restore_dependencies(
     progress_cb: Callable[[dict], None] | None,
     *,
     config: dict,
+    dep_locator_cb: Callable[[Path], list[tuple[str, str]]] | None = None,
 ) -> None:
     """Restore project dependencies with the provisioned toolchain (best effort).
 
@@ -646,49 +961,67 @@ def _restore_dependencies(
                 detail=f"{install_command} finished with errors: {detail}",
             )
     elif runtime == "python":
-        if (project_root / "requirements.txt").is_file():
+        steps = _python_restore_commands(project_root, config)
+        if not steps and dep_locator_cb is not None and _llm_dep_discovery_enabled(config):
+            # Deterministic detection found nothing in the conventional locations.
+            # Ask the server to point at where deps are declared (nonstandard
+            # layouts); the returned locations are re-validated on disk before use.
+            located = dep_locator_cb(project_root)
+            if located:
+                _emit(
+                    progress_cb,
+                    phase="rr",
+                    event="toolchain_provisioning",
+                    detail=(
+                        f"no conventional manifests found; using {len(located)} "
+                        "cloud-located dependency source(s)"
+                    ),
+                )
+                steps = located
+        if not steps:
             _emit(
                 progress_cb,
                 phase="rr",
                 event="toolchain_provisioning",
-                detail="step 1/1: pip install -r requirements.txt (streaming output below)",
-            )
-            ok, detail = _run_command_with_progress(
-                project_root,
-                "python -m pip install -r requirements.txt",
-                env=env,
-                progress_cb=progress_cb,
-                label="pip",
-                timeout=1800,
+                detail="no python dependency manifests detected; skipping restore",
             )
-            if not ok:
+            return
+        total = len(steps)
+        for idx, (label, command) in enumerate(steps, start=1):
+            leading = _leading_binary(command)
+            if leading and not _binary_on_path(leading, env=env):
                 _emit(
                     progress_cb,
                     phase="rr",
                     event="toolchain_provisioning",
-                    detail=f"pip install finished with errors: {detail}",
+                    detail=(
+                        f"skipping {label} restore: '{leading}' is not available "
+                        f"for {command}"
+                    ),
                 )
-        elif (project_root / "pyproject.toml").is_file() or (project_root / "setup.py").is_file():
+                continue
             _emit(
                 progress_cb,
                 phase="rr",
                 event="toolchain_provisioning",
-                detail="step 1/1: pip install -e . (streaming output below)",
+                detail=f"step {idx}/{total}: {command} (streaming output below)",
             )
             ok, detail = _run_command_with_progress(
                 project_root,
-                "python -m pip install -e .",
+                command,
                 env=env,
                 progress_cb=progress_cb,
                 label="pip",
                 timeout=1800,
             )
             if not ok:
+                # Non-fatal: later sources may still supply the missing deps, and
+                # the baseline test surfaces the real error if they don't.
                 _emit(
                     progress_cb,
                     phase="rr",
                     event="toolchain_provisioning",
-                    detail=f"pip install finished with errors: {detail}",
+                    detail=f"{command} finished with errors: {detail}",
                 )
 
 
@@ -1204,12 +1537,23 @@ def run_cloud_refactor_requests(
     # the host PATH, download a pinned runtime into the central store and run
     # tests with it (no container, no system changes). ``toolchain_env`` is None
     # when nothing was provisioned (already runnable / no managed runtime).
+    def _dep_locator(root: Path) -> list[tuple[str, str]]:
+        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,
+        )
+
     toolchain_env, toolchain_note = _provision_toolchain(
         execution_root,
         test_command,
         config,
         consent_cb=toolchain_consent_cb,
         progress_cb=progress_cb,
+        dep_locator_cb=_dep_locator,
     )
     toolchain_env = _workspace_env(project_root, toolchain_env)
     status_after_toolchain = _git_status_porcelain(project_root)

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/refactorai_cli/commands/run_cmds.py

@@ -1427,6 +1427,7 @@ def 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)
 
     constitution = load_constitution(consti_target)
     register_project(project_root, constitution_hash=constitution.content_hash, project_id=project_id)
@@ -1489,9 +1490,12 @@ def init(
             "(mode=cloud_byok, env-key-first via provider_key; credential_ref is optional fallback)."
         )
     console.print(
-        f"Only {CONSTITUTION_FILENAME} and {CONFIG_FILENAME} are added to your repo. "
-        "Runtime state stays outside the repository."
+        f"Added {CONSTITUTION_FILENAME}. "
+        f"{CONFIG_FILENAME} is treated as local by default and added to .gitignore "
+        "(remove it there if you want to track it)."
     )
+    if gitignore_updated:
+        console.print("[green]Updated[/green] .gitignore with `refactor.config`.")
     if org_cached_meta is not None:
         policy_meta = org_cached_meta.get("policy", {}) if isinstance(org_cached_meta, dict) else {}
         source = str(policy_meta.get("source") or "system_default")
@@ -1596,6 +1600,49 @@ def _inject_project_id(config_text: str, project_id: str) -> str:
     return line + config_text
 
 
+def _ensure_refactor_gitignore(project_root: Path) -> bool:
+    """Ensure ``refactor.config`` is ignored in git for this repository.
+
+    This is idempotent: running ``refactor init`` repeatedly never duplicates
+    entries. Developers can still remove/edit the entry manually if they prefer
+    to track ``refactor.config`` in git.
+    """
+    git_dir = project_root / ".git"
+    if not git_dir.exists():
+        return False
+    gitignore = project_root / ".gitignore"
+    try:
+        existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
+    except OSError:
+        return False
+
+    def _normalize(entry: str) -> str:
+        return str(entry or "").strip().replace("\\", "/").lstrip("./")
+
+    normalized_existing = {
+        _normalize(line)
+        for line in existing.splitlines()
+        if str(line).strip() and not str(line).lstrip().startswith("#")
+    }
+    if "refactor.config" in normalized_existing:
+        return False
+
+    newline = "\r\n" if "\r\n" in existing else "\n"
+    prefix = ""
+    if existing and not existing.endswith(("\n", "\r\n")):
+        prefix = newline
+    block = (
+        f"{prefix}# Refactor local config (remove if you want to track it){newline}"
+        f"refactor.config{newline}"
+    )
+    try:
+        with gitignore.open("a", encoding="utf-8", newline="") as fh:
+            fh.write(block)
+    except OSError:
+        return False
+    return True
+
+
 def _offer_commit_hook(project_root: Path) -> None:
     """Offer to wire the local commit-review hook during `init` (docs/41 `R28`).
 

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.7.6
+Version: 0.7.7
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ 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: refactorai-core>=3.2.18
+Requires-Dist: refactorai-core>=3.2.19
 
 # refactorai-cli
 

{refactorai_cli-0.7.6 → refactorai_cli-0.7.7}/refactorai_cli.egg-info/requires.txt

@@ -2,4 +2,4 @@ typer>=0.12.0
 httpx>=0.27.0
 rich>=13.7.0
 PyYAML>=6.0.1
-refactorai-core>=3.2.18
+refactorai-core>=3.2.19