refactorai-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/PKG-INFO

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

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/pyproject.toml

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

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/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.6.0"
+__version__ = "0.7.0"

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/refactorai_cli/cloud_rr.py

@@ -68,6 +68,13 @@ from refactorai_cli.auth import ensure_authenticated
 from refactorai_cli.settings import platform_url
 
 _ENV_ASSIGN_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=.*$")
+_WORKSPACE_DIRNAME = "workspace"
+_WORKSPACE_NAME = "host"
+_WORKSPACE_CACHE_DIRNAME = "cache"
+# Directory names never mirrored into (or pruned from) the managed workspace:
+# git metadata, the central store, and heavy dependency dirs that are restored
+# in-workspace and cached across runs.
+_WORKSPACE_EXCLUDE = {".git", ".refactor", "node_modules"}
 
 # Manifest/config files that reveal how a project runs its tests. Sent (truncated)
 # to the server for agentic test-command discovery when deterministic detection
@@ -105,7 +112,7 @@ def _read_source(project_root: Path, rel: str) -> str:
 
 
 def _run_test(
-    project_root: Path, test_command: str | None, *, env: dict | None = None
+    execution_root: Path, test_command: str | None, *, env: dict | None = None
 ) -> tuple[bool, str]:
     """Run the configured test command on the host; (passed, detail).
 
@@ -127,7 +134,7 @@ def _run_test(
         proc = subprocess.run(
             command,
             shell=True,
-            cwd=str(project_root),
+            cwd=str(execution_root),
             capture_output=True,
             text=True,
             timeout=600,
@@ -141,7 +148,7 @@ def _run_test(
 
 
 def _run_command_with_progress(
-    project_root: Path,
+    execution_root: Path,
     command: str,
     *,
     env: dict | None = None,
@@ -158,7 +165,7 @@ def _run_command_with_progress(
         proc = subprocess.Popen(
             command,
             shell=True,
-            cwd=str(project_root),
+            cwd=str(execution_root),
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
@@ -403,13 +410,24 @@ def _write_json_atomic(path: Path, payload: dict) -> None:
 
 
 def _node_lockfile(project_root: Path) -> Path | None:
-    for name in ("package-lock.json", "npm-shrinkwrap.json"):
+    for name in ("pnpm-lock.yaml", "yarn.lock", "package-lock.json", "npm-shrinkwrap.json"):
         path = project_root / name
         if path.is_file():
             return path
     return None
 
 
+def _node_install_command(project_root: Path) -> tuple[str, str]:
+    lockfile = _node_lockfile(project_root)
+    if lockfile is None:
+        return "npm", "npm install"
+    if lockfile.name == "pnpm-lock.yaml":
+        return "corepack", "corepack pnpm install --frozen-lockfile"
+    if lockfile.name == "yarn.lock":
+        return "corepack", "corepack yarn install --immutable"
+    return "npm", "npm ci"
+
+
 def _node_deps_state_path(project_root: Path) -> Path:
     return resolve_store_dir(project_root) / "toolchain-state" / "node-deps.json"
 
@@ -492,7 +510,7 @@ def _merge_toolchain_env(base: dict | None, new: dict) -> dict:
 
 
 def _provision_toolchain(
-    project_root: Path,
+    execution_root: Path,
     test_command: str | None,
     config: dict,
     *,
@@ -517,6 +535,10 @@ def _provision_toolchain(
     from refactor_core.host_toolchain import binary_to_runtime, guidance_for_binary
 
     def _on_progress(msg: str) -> None:
+        # Warm-path reuse is expected on every run; suppress it to keep cloud RR
+        # progress noise low while still surfacing real downloads/extracts.
+        if str(msg).startswith("reusing "):
+            return
         _emit(progress_cb, phase="rr", event="toolchain_provisioning", detail=msg)
 
     merged_env: dict | None = None
@@ -546,7 +568,7 @@ def _provision_toolchain(
             continue
         _emit(progress_cb, phase="rr", event="toolchain_ready", runtime=runtime)
         merged_env = _merge_toolchain_env(merged_env, env)
-        _restore_dependencies(project_root, runtime, merged_env, progress_cb, config=config)
+        _restore_dependencies(execution_root, runtime, merged_env, progress_cb, config=config)
 
     return merged_env, " ".join(n for n in notes if n).strip()
 
@@ -574,8 +596,7 @@ def _restore_dependencies(
         )
         return
     if runtime == "node" and (project_root / "package.json").is_file():
-        lockfile = _node_lockfile(project_root)
-        install_command = "npm ci" if lockfile is not None else "npm install"
+        install_binary, install_command = _node_install_command(project_root)
         marker_payload: dict | None = None
         if policy == "auto":
             should_restore, reason, marker_payload = _should_restore_node_dependencies(
@@ -595,6 +616,17 @@ def _restore_dependencies(
             event="toolchain_provisioning",
             detail=f"step 1/1: {install_command} (streaming output below)",
         )
+        if not _binary_on_path(install_binary, env=env):
+            _emit(
+                progress_cb,
+                phase="rr",
+                event="toolchain_provisioning",
+                detail=(
+                    f"skipping node dependency restore: '{install_binary}' is not available "
+                    f"for {install_command}"
+                ),
+            )
+            return
         ok, detail = _run_command_with_progress(
             project_root,
             install_command,
@@ -700,6 +732,184 @@ def _collect_test_manifests(
     return docs
 
 
+def _workspace_root(project_root: Path) -> Path:
+    return resolve_store_dir(project_root) / _WORKSPACE_DIRNAME / _WORKSPACE_NAME
+
+
+def _workspace_cache_root(project_root: Path) -> Path:
+    return resolve_store_dir(project_root) / _WORKSPACE_CACHE_DIRNAME
+
+
+def _workspace_env(project_root: Path, base_env: dict | None) -> dict | None:
+    env = dict(base_env) if base_env is not None else None
+    cache_root = _workspace_cache_root(project_root)
+    npm_cache = cache_root / "npm"
+    yarn_cache = cache_root / "yarn"
+    pnpm_store = cache_root / "pnpm-store"
+    for directory in (npm_cache, yarn_cache, pnpm_store):
+        with contextlib.suppress(OSError):
+            directory.mkdir(parents=True, exist_ok=True)
+    if env is None:
+        return None
+    env.setdefault("npm_config_cache", str(npm_cache))
+    env.setdefault("YARN_CACHE_FOLDER", str(yarn_cache))
+    env.setdefault("PNPM_STORE_DIR", str(pnpm_store))
+    return env
+
+
+def _has_excluded_component(rel: Path, exclude: set[str]) -> bool:
+    return any(part in exclude for part in rel.parts)
+
+
+def _needs_copy(src: Path, dst: Path) -> bool:
+    """True when ``dst`` is missing or differs from ``src`` (size/mtime)."""
+    try:
+        s = src.stat()
+    except OSError:
+        return False
+    try:
+        d = dst.stat()
+    except OSError:
+        return True
+    return int(s.st_mtime) != int(d.st_mtime) or s.st_size != d.st_size
+
+
+def _sync_working_tree(
+    src: Path, dst: Path, *, exclude: set[str], skip_abs: set[Path]
+) -> None:
+    """Incrementally mirror the working tree ``src`` into ``dst``.
+
+    Copies tracked *and* untracked files (so gitignored inputs a test needs — a
+    local ``.env``, fixtures — are present) while skipping heavy/managed dirs
+    (``exclude`` by name, ``skip_abs`` by absolute path). Unchanged files are
+    left alone (size+mtime check) so re-runs are cheap, and files deleted in the
+    source are removed from the mirror. Excluded dirs (e.g. the workspace's own
+    ``node_modules``) are never copied *or* deleted, so dependency caches persist.
+    """
+    src = Path(src)
+    dst = Path(dst)
+    dst.mkdir(parents=True, exist_ok=True)
+
+    seen_files: set[str] = set()
+    seen_dirs: set[str] = set()
+    for root, dirs, files in os.walk(src):
+        root_path = Path(root)
+        # Prune excluded/managed dirs in place so os.walk never descends them.
+        dirs[:] = [
+            d
+            for d in dirs
+            if d not in exclude and (root_path / d).resolve() not in skip_abs
+        ]
+        rel_root = root_path.relative_to(src)
+        for d in dirs:
+            rel = rel_root / d
+            seen_dirs.add(rel.as_posix())
+            with contextlib.suppress(OSError):
+                (dst / rel).mkdir(parents=True, exist_ok=True)
+        for f in files:
+            rel = rel_root / f
+            seen_files.add(rel.as_posix())
+            source_file = src / rel
+            target_file = dst / rel
+            if _needs_copy(source_file, target_file):
+                with contextlib.suppress(OSError):
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(source_file, target_file)
+
+    # Deletion phase: drop mirror entries whose source no longer exists, never
+    # touching anything under an excluded component (node_modules, caches, .git).
+    for root, dirs, files in os.walk(dst, topdown=False):
+        rel_root = Path(root).relative_to(dst)
+        if _has_excluded_component(rel_root, exclude):
+            continue
+        for f in files:
+            rel = rel_root / f
+            if _has_excluded_component(rel, exclude):
+                continue
+            if rel.as_posix() not in seen_files:
+                with contextlib.suppress(OSError):
+                    (Path(root) / f).unlink()
+        for d in dirs:
+            if d in exclude:
+                continue
+            rel = rel_root / d
+            if rel.as_posix() not in seen_dirs:
+                with contextlib.suppress(OSError):
+                    (Path(root) / d).rmdir()
+
+
+def _prepare_managed_workspace(project_root: Path, *, progress_cb: Callable[[dict], None] | None) -> Path:
+    """Mirror the project's working tree into the managed workspace and return it.
+
+    The mirror (not a HEAD worktree) reflects exactly what the developer has on
+    disk, so behavior verification matches reality even with uncommitted or
+    gitignored files. Installs/tests run here; the real repo is never touched.
+    """
+    workspace = _workspace_root(project_root)
+    with contextlib.suppress(OSError):
+        workspace.parent.mkdir(parents=True, exist_ok=True)
+    skip_abs: set[Path] = set()
+    with contextlib.suppress(Exception):
+        skip_abs.add(resolve_store_dir(project_root).resolve())
+    with contextlib.suppress(Exception):
+        skip_abs.add(workspace.resolve())
+    try:
+        _sync_working_tree(
+            project_root, workspace, exclude=set(_WORKSPACE_EXCLUDE), skip_abs=skip_abs
+        )
+    except OSError as exc:
+        raise CloudRRError(f"failed to prepare managed workspace: {exc}") from exc
+    _emit(
+        progress_cb,
+        phase="rr",
+        event="workspace_ready",
+        detail=f"managed workspace ready at {workspace}",
+    )
+    return workspace
+
+
+def prune_workspace(project_root: Path, *, include_cache: bool = False) -> list[str]:
+    """Remove the managed workspace mirror (and optionally its dep caches).
+
+    Returns the list of removed absolute paths. Safe to call when nothing has
+    been provisioned yet (returns an empty list).
+    """
+    removed: list[str] = []
+    base = resolve_store_dir(project_root) / _WORKSPACE_DIRNAME
+    if base.exists():
+        shutil.rmtree(base, ignore_errors=True)
+        removed.append(str(base))
+    if include_cache:
+        cache = _workspace_cache_root(project_root)
+        if cache.exists():
+            shutil.rmtree(cache, ignore_errors=True)
+            removed.append(str(cache))
+    return removed
+
+
+def workspace_paths(project_root: Path) -> dict:
+    """Return the managed workspace + cache locations for ``project_root``."""
+    return {
+        "workspace": _workspace_root(project_root),
+        "cache": _workspace_cache_root(project_root),
+    }
+
+
+def _git_status_porcelain(project_root: Path) -> str:
+    try:
+        proc = subprocess.run(
+            ["git", "-C", str(project_root), "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except (subprocess.SubprocessError, OSError):
+        return ""
+    if proc.returncode != 0:
+        return ""
+    return (proc.stdout or "").strip()
+
+
 def _discover_test_command_via_cloud(
     *,
     project_root: Path,
@@ -967,6 +1177,18 @@ def run_cloud_refactor_requests(
     if requests is None:
         requests = pending_requests(project_root)
 
+    run_store = create_run(project_root)
+    run_id = run_store.run_id
+    resolved_model = model_hint or str(
+        constitution.get_setting("model_id", "managed-default") or "managed-default"
+    )
+    outcomes: list[dict] = []
+    counts = {"applied": 0, "denied": 0, "failed": 0, "deferred": 0}
+    notes: list[str] = []
+    stopped = False
+    stop_reason = ""
+    model_id = resolved_model
+
     _emit(
         progress_cb,
         phase="rr",
@@ -975,18 +1197,51 @@ def run_cloud_refactor_requests(
         test_command=test_command or "",
         execution_env="cloud",
     )
+    execution_root = _prepare_managed_workspace(project_root, progress_cb=progress_cb)
+    status_before = _git_status_porcelain(project_root)
 
     # Managed host toolchain: when the resolved command's runtime is missing from
     # 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).
     toolchain_env, toolchain_note = _provision_toolchain(
-        project_root,
+        execution_root,
         test_command,
         config,
         consent_cb=toolchain_consent_cb,
         progress_cb=progress_cb,
     )
+    toolchain_env = _workspace_env(project_root, toolchain_env)
+    status_after_toolchain = _git_status_porcelain(project_root)
+    if status_after_toolchain != status_before:
+        reason = (
+            "managed workspace invariant violated: toolchain/dependency setup changed the project "
+            "working tree before any RR patch was applied; aborting run."
+        )
+        _emit(
+            progress_cb,
+            phase="rr",
+            event="workspace_dirty_abort",
+            reason=reason,
+        )
+        notes = []
+        if testcmd_note:
+            notes.append(testcmd_note)
+        if toolchain_note:
+            notes.append(toolchain_note)
+        notes.append(reason)
+        return _build_artifact(
+            run_store,
+            run_id,
+            constitution,
+            model_id,
+            outcomes,
+            counts,
+            notes,
+            stopped=True,
+            stop_reason=reason,
+            test_command=test_command,
+        )
 
     # python3-only hosts: rewrite a bare `python` test command to `python3` when
     # we did NOT provision a managed runtime (managed provisioning already
@@ -1003,23 +1258,10 @@ def run_cloud_refactor_requests(
                 previous=test_command,
             )
             test_command = normalized
-
-    run_store = create_run(project_root)
-    run_id = run_store.run_id
-    resolved_model = model_hint or str(
-        constitution.get_setting("model_id", "managed-default") or "managed-default"
-    )
-
-    outcomes: list[dict] = []
-    counts = {"applied": 0, "denied": 0, "failed": 0, "deferred": 0}
-    notes: list[str] = []
     if testcmd_note:
         notes.append(testcmd_note)
     if toolchain_note:
         notes.append(toolchain_note)
-    stopped = False
-    stop_reason = ""
-    model_id = resolved_model
 
     if not requests:
         return _build_artifact(
@@ -1130,7 +1372,7 @@ def run_cloud_refactor_requests(
             current_rr_id = action.get("rr_id", "") or current_rr_id
             _emit(progress_cb, phase="rr", event="test_generating", rr_id=current_rr_id)
             _write_generated_test(project_root, current_rr_id, action, by_id)
-            passed, detail = _run_test(project_root, test_command, env=toolchain_env)
+            passed, detail = _run_test(execution_root, test_command, env=toolchain_env)
             _emit(progress_cb, phase="rr", event="baseline_test", rr_id=current_rr_id,
                   passed=passed, detail=detail,
                   execution_env="host+toolchain" if toolchain_env else "host")
@@ -1207,7 +1449,12 @@ def run_cloud_refactor_requests(
                         approved=True,
                     )
                 passed, detail, files = _apply_and_verify(
-                    project_root, run_store.run_dir, diff_text, test_command, env=toolchain_env
+                    project_root,
+                    execution_root,
+                    run_store.run_dir,
+                    diff_text,
+                    test_command,
+                    env=toolchain_env,
                 )
                 pending.applied = True
                 if passed:
@@ -1307,7 +1554,13 @@ def _write_generated_test(project_root: Path, rr_id: str, action: dict, by_id: d
 
 
 def _apply_and_verify(
-    project_root: Path, run_dir: Path, diff_text: str, test_command, *, env: dict | None = None
+    project_root: Path,
+    execution_root: Path,
+    run_dir: Path,
+    diff_text: str,
+    test_command,
+    *,
+    env: dict | None = None,
 ) -> tuple[bool, str, list[str]]:
     """Apply the diff (with backup), run the test; revert on red.
 
@@ -1325,17 +1578,24 @@ def _apply_and_verify(
     if not changes:
         return False, "diff produced no file changes", []
     changed_files = list(changes.keys())
+    verify_backup_dir = run_dir / "workspace-backup"
+    verify_backup_dir.mkdir(parents=True, exist_ok=True)
     try:
-        apply_changes(project_root, run_dir, changes)
+        apply_changes(execution_root, verify_backup_dir, changes)
     except Exception as exc:
         return False, f"apply failed: {exc}", changed_files
-    passed, detail = _run_test(project_root, test_command, env=env)
+    passed, detail = _run_test(execution_root, test_command, env=env)
     if not passed:
         try:
-            revert_from_backup(project_root, run_dir)
+            revert_from_backup(execution_root, verify_backup_dir)
         except Exception as exc:  # keep going; report both
             detail = f"{detail}; revert error: {exc}"
-    return passed, detail, changed_files
+        return passed, detail, changed_files
+    try:
+        apply_changes(project_root, run_dir, changes)
+    except Exception as exc:
+        return False, f"apply to project failed after successful verify: {exc}", changed_files
+    return True, detail, changed_files
 
 
 def _record_outcome(project_root, by_id, rr_id, verdict, message, attempts,

refactorai_cli-0.7.0/refactorai_cli/commands/workspace_cmds.py

@@ -0,0 +1,79 @@
+"""Managed per-project workspace commands: inspect and prune.
+
+Cloud modes run dependency install + tests inside a managed workspace mirror
+under the central store (``~/.refactor/projects/<id>/workspace``) so the real
+repo is never mutated. These commands let developers see and reclaim that space.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from refactorai_cli import cloud_rr
+
+console = Console()
+app = typer.Typer(help="Inspect and manage the per-project managed workspace.")
+
+
+def _dir_size_bytes(path: Path) -> int:
+    total = 0
+    for root, _dirs, files in os.walk(path):
+        for name in files:
+            try:
+                total += (Path(root) / name).stat().st_size
+            except OSError:
+                continue
+    return total
+
+
+def _human(num_bytes: int) -> str:
+    size = float(num_bytes)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.0f}{unit}" if unit == "B" else f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}TB"
+
+
+@app.command("list")
+def list_workspace() -> None:
+    """Show the managed workspace + dependency cache for this project."""
+    paths = cloud_rr.workspace_paths(Path.cwd())
+    table = Table(title="Managed workspace")
+    table.add_column("kind")
+    table.add_column("exists")
+    table.add_column("size")
+    table.add_column("path", overflow="fold")
+    for kind in ("workspace", "cache"):
+        path = Path(paths[kind])
+        exists = path.is_dir()
+        size = _human(_dir_size_bytes(path)) if exists else "-"
+        table.add_row(kind, "yes" if exists else "no", size, str(path))
+    console.print(table)
+
+
+@app.command("prune")
+def prune_workspace(
+    cache: bool = typer.Option(
+        False, "--cache", help="Also remove the dependency cache (npm/yarn/pnpm)."
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Remove the managed workspace mirror to reclaim disk space."""
+    target = "workspace + dependency cache" if cache else "workspace"
+    if not yes:
+        confirm = typer.prompt(f"Remove managed {target} for this project? (y/N)", default="N")
+        if confirm.strip().lower() not in {"y", "yes"}:
+            console.print("[dim]Aborted.[/dim]")
+            raise typer.Exit(code=0)
+    removed = cloud_rr.prune_workspace(Path.cwd(), include_cache=cache)
+    if not removed:
+        console.print("[dim]Nothing to remove.[/dim]")
+        return
+    for path in removed:
+        console.print(f"[green]removed[/green] {path}")

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/refactorai_cli/main.py

@@ -23,6 +23,7 @@ from refactorai_cli.commands import (
     setup_cmds,
     toolchains_cmds,
     watch_cmds,
+    workspace_cmds,
 )
 
 app = typer.Typer(
@@ -153,6 +154,9 @@ app.add_typer(cloud_cmds.app, name="cloud")
 # Managed host toolchains (R24 Phase 2).
 app.add_typer(toolchains_cmds.app, name="toolchains")
 
+# Managed per-project workspace (isolated install/test mirror).
+app.add_typer(workspace_cmds.app, name="workspace")
+
 # Local commit-triggered review hook (R28 Phase 2, docs/41).
 app.add_typer(hook_cmds.app, name="hook")
 

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/refactorai_cli.egg-info/PKG-INFO

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

{refactorai_cli-0.6.0 → refactorai_cli-0.7.0}/refactorai_cli.egg-info/SOURCES.txt

@@ -46,4 +46,5 @@ refactorai_cli/commands/runtime_cmds.py
 refactorai_cli/commands/runtime_proxy_cmds.py
 refactorai_cli/commands/setup_cmds.py
 refactorai_cli/commands/toolchains_cmds.py
-refactorai_cli/commands/watch_cmds.py
+refactorai_cli/commands/watch_cmds.py
+refactorai_cli/commands/workspace_cmds.py