refactorai-cli 0.3.13__tar.gz → 0.4.0__tar.gz

{refactorai_cli-0.3.13 → refactorai_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.3.13
+Version: 0.4.0
 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.1.1
+Requires-Dist: refactorai-core>=3.2.0
 
 # refactorai-cli
 

{refactorai_cli-0.3.13 → refactorai_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.3.13"
+version = "0.4.0"
 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.1.1",
+  "refactorai-core>=3.2.0",
 ]
 
 [project.scripts]

{refactorai_cli-0.3.13 → refactorai_cli-0.4.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.3.13"
+__version__ = "0.4.0"

refactorai_cli-0.4.0/refactorai_cli/commands/hook_cmds.py

@@ -0,0 +1,197 @@
+"""`refactor hook` commands: local commit-trigger install + enqueue (docs/41 `R28`).
+
+Phase 2 of the commit-triggered Refactor Terminal. ``install`` wires a
+non-blocking ``post-commit`` git hook (via ``core.hooksPath``) that enqueues each
+commit; ``enqueue`` is what that hook calls; ``status``/``uninstall`` manage it.
+
+The hook and these commands live in the thin CLI (not the proprietary runtime)
+so enqueuing is fast, offline, and never requires auth or a project config.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from refactorai_cli import commit_queue, git_scope
+
+console = Console()
+app = typer.Typer(
+    name="hook",
+    help="Manage the local commit-triggered review hook (docs/41).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+_HOOK_MARKER = "RefactorAI post-commit hook"
+_DEFAULT_HOOKS_DIR = ".githooks"
+
+# Non-blocking + fail-open: capture HEAD, then detach the enqueue so `git commit`
+# returns immediately. Skip-detection (merge/rebase/opt-out) happens in `enqueue`.
+_POST_COMMIT_SCRIPT = """#!/usr/bin/env bash
+# RefactorAI post-commit hook (docs/41 R28, Phase 2).
+# Non-blocking + fail-open: this hook must never delay or fail `git commit`.
+if ! command -v refactor >/dev/null 2>&1; then
+  exit 0
+fi
+_refactor_sha="$(git rev-parse HEAD 2>/dev/null)"
+if [ -z "$_refactor_sha" ]; then
+  exit 0
+fi
+# Detach so the commit returns instantly; the enqueue does its own skip checks.
+( refactor hook enqueue --sha "$_refactor_sha" >/dev/null 2>&1 & ) >/dev/null 2>&1 || true
+exit 0
+"""
+
+
+def _require_repo(project_root: Path) -> str:
+    root = git_scope.repo_root(project_root)
+    if not root:
+        console.print("[red]hook:[/red] not inside a git repository.")
+        raise typer.Exit(code=1)
+    return root
+
+
+@app.command("install")
+def install(
+    hooks_dir: str | None = typer.Option(
+        None,
+        "--hooks-dir",
+        help=f"Directory to hold git hooks (default: existing core.hooksPath or {_DEFAULT_HOOKS_DIR}).",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Overwrite an existing non-RefactorAI post-commit hook.",
+    ),
+) -> None:
+    """Install the non-blocking post-commit hook and wire ``core.hooksPath``."""
+    root = Path(_require_repo(Path.cwd()))
+
+    existing_path = git_scope.get_config(root, "core.hooksPath")
+    if hooks_dir:
+        rel_dir = hooks_dir
+    elif existing_path:
+        rel_dir = existing_path
+    else:
+        rel_dir = _DEFAULT_HOOKS_DIR
+
+    hooks_path = (root / rel_dir).resolve()
+    hook_file = hooks_path / "post-commit"
+
+    if hook_file.exists() and _HOOK_MARKER not in _safe_read(hook_file) and not force:
+        console.print(
+            f"[yellow]hook:[/yellow] a post-commit hook already exists at {hook_file}.\n"
+            "Re-run with [bold]--force[/bold] to overwrite, or point --hooks-dir elsewhere."
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        hooks_path.mkdir(parents=True, exist_ok=True)
+        hook_file.write_text(_POST_COMMIT_SCRIPT, encoding="utf-8")
+        hook_file.chmod(hook_file.stat().st_mode | 0o755)
+    except OSError as exc:
+        console.print(f"[red]hook: could not write hook:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if not git_scope.set_config(root, "core.hooksPath", rel_dir):
+        console.print("[red]hook: could not set core.hooksPath.[/red]")
+        raise typer.Exit(code=1)
+
+    console.print(
+        f"[green]Installed[/green] post-commit hook -> {hook_file}\n"
+        f"[dim]core.hooksPath = {rel_dir}[/dim]\n"
+        "Every commit now enqueues a local review event. "
+        "Open the Refactor Terminal with `refactor watch` (coming in Phase 3)."
+    )
+
+
+@app.command("uninstall")
+def uninstall(
+    reset_hooks_path: bool = typer.Option(
+        False,
+        "--reset-hooks-path",
+        help="Also unset core.hooksPath (only do this if RefactorAI set it).",
+    ),
+) -> None:
+    """Remove the RefactorAI post-commit hook."""
+    root = Path(_require_repo(Path.cwd()))
+    rel_dir = git_scope.get_config(root, "core.hooksPath") or _DEFAULT_HOOKS_DIR
+    hook_file = (root / rel_dir / "post-commit").resolve()
+
+    removed = False
+    if hook_file.exists() and _HOOK_MARKER in _safe_read(hook_file):
+        try:
+            hook_file.unlink()
+            removed = True
+        except OSError as exc:
+            console.print(f"[red]hook: could not remove hook:[/red] {exc}")
+            raise typer.Exit(code=1) from exc
+
+    if reset_hooks_path:
+        git_scope.unset_config(root, "core.hooksPath")
+
+    if removed:
+        console.print("[green]Removed[/green] the RefactorAI post-commit hook.")
+    else:
+        console.print("[dim]hook: no RefactorAI post-commit hook found to remove.[/dim]")
+
+
+@app.command("enqueue")
+def enqueue(
+    sha: str = typer.Option("HEAD", "--sha", help="Commit SHA/ref to enqueue."),
+    verbose: bool = typer.Option(False, "--verbose", help="Print the enqueue result."),
+) -> None:
+    """Enqueue a commit event (invoked by the post-commit hook). Always exits 0."""
+    project_root = Path(os.environ.get("REFACTOR_PROJECT_ROOT") or Path.cwd())
+    try:
+        enqueued, reason, event = commit_queue.enqueue_commit_event(project_root, sha)
+    except Exception as exc:  # fail-open: never let enqueue affect the commit flow
+        if verbose:
+            console.print(f"[yellow]hook enqueue error (ignored):[/yellow] {exc}")
+        return
+    if verbose:
+        if enqueued and event:
+            console.print(
+                f"[green]enqueued[/green] {event['sha'][:10]} "
+                f"({len(event['changed_files'])} changed file(s)) -> "
+                f"{commit_queue.queue_path(project_root)}"
+            )
+        else:
+            console.print(f"[dim]hook: not enqueued ({reason}).[/dim]")
+
+
+@app.command("status")
+def status() -> None:
+    """Show hook installation state and the pending commit-event count."""
+    root_str = git_scope.repo_root(Path.cwd())
+    if not root_str:
+        console.print("[yellow]hook:[/yellow] not inside a git repository.")
+        raise typer.Exit(code=1)
+    root = Path(root_str)
+
+    rel_dir = git_scope.get_config(root, "core.hooksPath")
+    hook_file = (root / (rel_dir or _DEFAULT_HOOKS_DIR) / "post-commit").resolve()
+    is_ours = hook_file.exists() and _HOOK_MARKER in _safe_read(hook_file)
+    q_path = commit_queue.queue_path(root)
+
+    console.print(f"Repository: [bold]{root}[/bold]")
+    console.print(f"core.hooksPath: {rel_dir or '[dim](unset)[/dim]'}")
+    if is_ours:
+        console.print(f"post-commit hook: [green]installed[/green] ({hook_file})")
+    elif hook_file.exists():
+        console.print(f"post-commit hook: [yellow]present but not RefactorAI[/yellow] ({hook_file})")
+    else:
+        console.print("post-commit hook: [red]not installed[/red] (run `refactor hook install`)")
+    console.print(f"Queue: {q_path}")
+    console.print(f"Pending events: [bold]{commit_queue.pending_count(root)}[/bold]")
+
+
+def _safe_read(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except OSError:
+        return ""

{refactorai_cli-0.3.13 → refactorai_cli-0.4.0}/refactorai_cli/commands/run_cmds.py

@@ -1800,6 +1800,134 @@ def shell(
     raise typer.Exit(code=1)
 
 
+def _graph_expand_hops(constitution) -> int:
+    """Graph expansion depth for commit scope (constitution intelligence)."""
+    intel = constitution.get_setting("intelligence", {}) if constitution else {}
+    if isinstance(intel, dict):
+        try:
+            return max(0, int(intel.get("graph_expand_hops", 1) or 1))
+        except (TypeError, ValueError):
+            return 1
+    return 1
+
+
+def _associated_files_for(project_root: Path, changed: list[str], hops: int) -> list[str]:
+    """Files graph-associated with ``changed`` via the persisted symbol graph.
+
+    Best-effort: returns ``[]`` when no graph is available or the changed files
+    have no matching symbols, so review simply falls back to the changed files.
+    """
+    if not changed:
+        return []
+    try:
+        from refactor_core.codeintel.context import associated_files
+        from refactor_core.codeintel.graph import SymbolGraph
+        from refactor_core.store import read_symbol_graph
+
+        graph_dict = read_symbol_graph(project_root)
+        if not graph_dict:
+            return []
+        graph = SymbolGraph.from_dict(graph_dict)
+        return associated_files(graph, changed, hops=hops)
+    except Exception:
+        return []
+
+
+def _resolve_commit_scope(
+    *,
+    project_root: Path,
+    constitution,
+    commit: str | None,
+    changed: bool,
+    intent: str | None,
+) -> dict | None:
+    """Resolve commit/working-tree scope for a review (docs/41 `R28`, Phase 1).
+
+    Returns ``None`` when no scoping was requested. Otherwise a dict with:
+    ``scope_paths`` (changed + associated, or ``None`` for a full-project
+    baseline), ``changed_paths``, ``intent`` (canonical contract or ``None``),
+    ``summary`` (one-line intent), and ``note`` (human scope description).
+    """
+    if not commit and not changed:
+        return None
+
+    from refactorai_cli import git_scope
+    from refactor_core.intent import capture as intent_capture
+
+    if not git_scope.is_git_repo(project_root):
+        console.print("[yellow]review: --commit/--changed requires a git repository; ignoring scope.[/yellow]")
+        return None
+
+    sources: list[dict] = []
+    changed_files: list[str] = []
+    full_project = False
+    scope_label = ""
+
+    if commit:
+        sha = git_scope.resolve_sha(project_root, commit)
+        if not sha:
+            console.print(f"[red]review: could not resolve commit '{commit}'.[/red]")
+            raise typer.Exit(code=2)
+        subject, message = git_scope.commit_message(project_root, sha)
+        if subject or message:
+            sources.append(
+                {"type": "commit_message", "title": subject, "text": message, "ref": sha}
+            )
+        if git_scope.is_first_commit(project_root, sha):
+            full_project = True
+            scope_label = f"first commit {sha[:10]} -> full project"
+        else:
+            changed_files = git_scope.commit_changed_files(project_root, sha)
+            scope_label = f"commit {sha[:10]}"
+    elif changed:
+        changed_files = git_scope.working_tree_changed_files(project_root)
+        scope_label = "working tree"
+
+    if intent and intent.strip():
+        sources.append({"type": "agent_prompt", "text": intent.strip()})
+
+    canonical = intent_capture.derive_contract(sources) if sources else None
+    summary = intent_capture.summarize_intent(canonical)
+
+    if full_project:
+        return {
+            "scope_paths": None,
+            "changed_paths": None,
+            "intent": canonical,
+            "summary": summary,
+            "note": scope_label,
+        }
+
+    # Restrict to files that still exist so a deleted path never becomes a target.
+    existing_changed = [p for p in changed_files if (project_root / p).is_file()]
+    if not existing_changed:
+        console.print(
+            f"[dim]review: no reviewable changed files in {scope_label}; "
+            "falling back to full target.[/dim]"
+        )
+        return {
+            "scope_paths": None,
+            "changed_paths": None,
+            "intent": canonical,
+            "summary": summary,
+            "note": f"{scope_label} (no changed files)",
+        }
+
+    associated = _associated_files_for(project_root, existing_changed, _graph_expand_hops(constitution))
+    scope_paths: list[str] = []
+    for path in [*existing_changed, *associated]:
+        if path not in scope_paths:
+            scope_paths.append(path)
+
+    return {
+        "scope_paths": scope_paths,
+        "changed_paths": existing_changed,
+        "intent": canonical,
+        "summary": summary,
+        "note": f"{scope_label}: {len(existing_changed)} changed + {len(associated)} associated",
+    }
+
+
 def review(
     target: str = typer.Argument(".", help="File, directory, or symbol to review."),
     provider: str | None = typer.Option(
@@ -1817,6 +1945,25 @@ def review(
         "--force",
         help="Run review even if unapplied patches exist from a prior code run.",
     ),
+    commit: str | None = typer.Option(
+        None,
+        "--commit",
+        help="Scope the review to a commit's changed files + graph-associated "
+        "files (local only, docs/41). Use a SHA/ref; the repo root commit falls "
+        "back to a full-project review.",
+    ),
+    changed: bool = typer.Option(
+        False,
+        "--changed",
+        help="Scope the review to the working tree's changed files + "
+        "graph-associated files (local only).",
+    ),
+    intent: str | None = typer.Option(
+        None,
+        "--intent",
+        help="Explicit intent for this change (agent-supplied). Merged with any "
+        "commit-message-derived intent to guide the review.",
+    ),
     compliance_framework: list[str] | None = typer.Option(
         None,
         "--compliance-framework",
@@ -1878,6 +2025,29 @@ def review(
         console.print(f"[yellow]review: compliance warning:[/yellow] {warning}")
     register_project(project_root, constitution_hash=constitution.content_hash)
     _maybe_build_graph(project_root, project_config)
+
+    # Commit-scoped local review (docs/41 `R28`). Local-only: the cloud path does
+    # not carry an explicit file scope, so scoping + cloud mode is rejected early.
+    if (commit or changed) and _is_cloud_mode(constitution):
+        console.print(
+            "[red]review: --commit/--changed is local-only[/red] and is not "
+            f"supported in {_cloud_execution_mode(constitution)} mode."
+        )
+        raise typer.Exit(code=2)
+    scope = _resolve_commit_scope(
+        project_root=project_root,
+        constitution=constitution,
+        commit=commit,
+        changed=changed,
+        intent=intent,
+    )
+    scope_paths = scope.get("scope_paths") if scope else None
+    changed_paths = scope.get("changed_paths") if scope else None
+    if scope:
+        console.print(f"[cyan]review scope[/cyan]: {scope['note']}")
+        if scope.get("summary"):
+            console.print(f"[dim]intent:[/dim] {scope['summary']}")
+
     sandbox_ctx = None
 
     try:
@@ -1926,7 +2096,11 @@ def review(
                     cli_mode=mode,
                     progress_cb=progress_cb,
                     step_limit_cb=_step_limit_prompt("review"),
+                    scope_paths=scope_paths,
+                    changed_paths=changed_paths,
                 )
+            if scope and scope.get("summary"):
+                artifact.notes.append(f"Commit-scoped review intent: {scope['summary']}")
         preflight_warning = ""
         if isinstance(sandbox_ctx, dict):
             preflight_warning = str(sandbox_ctx.get("preflight_warning") or "").strip()
@@ -2026,6 +2200,24 @@ def code(
         "--mode",
         help="Execution mode: auto | agentic | planner (default resolves from capability).",
     ),
+    commit: str | None = typer.Option(
+        None,
+        "--commit",
+        help="Scope to a commit's changed + graph-associated files and (re)create "
+        "that commit's refactor requests before resolving them (local only, docs/41). "
+        "Used by the Refactor Terminal's [r] action.",
+    ),
+    changed: bool = typer.Option(
+        False,
+        "--changed",
+        help="Scope to the working tree's changed + graph-associated files (local only).",
+    ),
+    intent: str | None = typer.Option(
+        None,
+        "--intent",
+        help="Explicit intent for this change (agent-supplied), merged with any "
+        "commit-message-derived intent to guide the review that creates requests.",
+    ),
     auto_approve: bool = typer.Option(
         False,
         "--auto-approve",
@@ -2106,6 +2298,31 @@ def code(
         console.print(f"[yellow]code: compliance warning:[/yellow] {warning}")
     register_project(project_root, constitution_hash=constitution.content_hash)
     _maybe_build_graph(project_root, project_config)
+
+    # Commit-scoped resolve (docs/41 `R28`, Phase 4). Local-only, symmetric to
+    # `review`. When scoped, we (re)create THIS commit's requests via a scoped
+    # review-first so `[r]` in the Refactor Terminal resolves the selected
+    # commit's requests rather than a stale pending set.
+    if (commit or changed) and _is_cloud_mode(constitution):
+        console.print(
+            "[red]code: --commit/--changed is local-only[/red] and is not "
+            f"supported in {_cloud_execution_mode(constitution)} mode."
+        )
+        raise typer.Exit(code=2)
+    code_scope = _resolve_commit_scope(
+        project_root=project_root,
+        constitution=constitution,
+        commit=commit,
+        changed=changed,
+        intent=intent,
+    )
+    code_scope_paths = code_scope.get("scope_paths") if code_scope else None
+    code_changed_paths = code_scope.get("changed_paths") if code_scope else None
+    if code_scope:
+        console.print(f"[cyan]code scope[/cyan]: {code_scope['note']}")
+        if code_scope.get("summary"):
+            console.print(f"[dim]intent:[/dim] {code_scope['summary']}")
+
     sandbox_ctx = None
 
     try:
@@ -2138,9 +2355,16 @@ def code(
         cloud_review_findings: list[Finding] = []
 
         # If no pending refactor requests exist, run review first to create them.
-        requests = pending_requests(project_root)
+        # A commit/working-tree scope always forces a fresh scoped review so the
+        # requests match the selected commit (docs/41 `R28`, Phase 4).
+        requests = [] if code_scope else pending_requests(project_root)
         if not requests:
-            console.print("[dim]code: no pending refactor requests; running review first...[/dim]")
+            if code_scope:
+                console.print(
+                    f"[dim]code: creating refactor requests for {code_scope['note']}...[/dim]"
+                )
+            else:
+                console.print("[dim]code: no pending refactor requests; running review first...[/dim]")
             if cloud:
                 review_artifact = _cloud_inference(
                     stage="review",
@@ -2166,6 +2390,8 @@ def code(
                         cli_mode=mode,
                         progress_cb=review_progress,
                         step_limit_cb=_step_limit_prompt("review"),
+                        scope_paths=code_scope_paths,
+                        changed_paths=code_changed_paths,
                     )
             review_store = create_run(project_root, run_id=review_artifact.run_id)
             review_store.write_artifact(review_artifact, target=target, status="completed")