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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.3.13
+Version: 0.4.1
 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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.3.13"
+version = "0.4.1"
 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.1}/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.1"

refactorai_cli-0.4.1/refactorai_cli/commands/hook_cmds.py

@@ -0,0 +1,229 @@
+"""`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
+
+
+def perform_install(
+    root: Path, *, hooks_dir: str | None = None, force: bool = False
+) -> dict:
+    """Install the post-commit hook + wire ``core.hooksPath`` (no printing/exit).
+
+    Returns a result dict with ``status`` in ``{installed, exists_foreign, error}``
+    plus ``rel_dir``, ``hook_file`` and a human ``message``. Shared by the
+    ``hook install`` command and ``refactor init`` so both stay in lockstep.
+    """
+    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:
+        return {
+            "status": "exists_foreign",
+            "rel_dir": rel_dir,
+            "hook_file": hook_file,
+            "message": f"a post-commit hook already exists at {hook_file}",
+        }
+
+    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:
+        return {"status": "error", "rel_dir": rel_dir, "hook_file": None, "message": str(exc)}
+
+    if not git_scope.set_config(root, "core.hooksPath", rel_dir):
+        return {
+            "status": "error",
+            "rel_dir": rel_dir,
+            "hook_file": hook_file,
+            "message": "could not set core.hooksPath",
+        }
+
+    return {
+        "status": "installed",
+        "rel_dir": rel_dir,
+        "hook_file": hook_file,
+        "message": f"installed post-commit hook -> {hook_file}",
+    }
+
+
+@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()))
+    result = perform_install(root, hooks_dir=hooks_dir, force=force)
+
+    if result["status"] == "exists_foreign":
+        console.print(
+            f"[yellow]hook:[/yellow] {result['message']}.\n"
+            "Re-run with [bold]--force[/bold] to overwrite, or point --hooks-dir elsewhere."
+        )
+        raise typer.Exit(code=1)
+    if result["status"] == "error":
+        console.print(f"[red]hook: could not install:[/red] {result['message']}")
+        raise typer.Exit(code=1)
+
+    console.print(
+        f"[green]Installed[/green] post-commit hook -> {result['hook_file']}\n"
+        f"[dim]core.hooksPath = {result['rel_dir']}[/dim]\n"
+        "Every commit now enqueues a local review event. "
+        "Open the Refactor Terminal with `refactor watch`."
+    )
+
+
+@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 ""