refactorai-cli 0.4.4__tar.gz → 0.4.8__tar.gz

{refactorai_cli-0.4.4 → refactorai_cli-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.4.4
+Version: 0.4.8
 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.3
+Requires-Dist: refactorai-core>=3.2.5
 
 # refactorai-cli
 

{refactorai_cli-0.4.4 → refactorai_cli-0.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.4.4"
+version = "0.4.8"
 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.3",
+  "refactorai-core>=3.2.5",
 ]
 
 [project.scripts]

{refactorai_cli-0.4.4 → refactorai_cli-0.4.8}/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.4.4"
+__version__ = "0.4.8"

{refactorai_cli-0.4.4 → refactorai_cli-0.4.8}/refactorai_cli/cloud_rr.py

@@ -650,6 +650,7 @@ def run_cloud_refactor_requests(
     approval_cb: Callable[[dict], bool] | None = None,
     apply_byok_payload: Callable[[dict, object], None] | None = None,
     toolchain_consent_cb: Callable[[dict], bool] | None = None,
+    commit_cb: Callable[[object], None] | None = None,
 ) -> RunArtifact:
     """Drive pending RRs through the cloud server-run loop and return a summary.
 
@@ -659,6 +660,11 @@ def run_cloud_refactor_requests(
     shared BYOK resolver injected by the caller to avoid a circular import.
     ``toolchain_consent_cb`` gates first-run managed-toolchain provisioning; when
     None, provisioning proceeds without prompting (e.g. ``--auto-approve``).
+
+    ``commit_cb`` (R29) mirrors the local executor's post-apply hook: it is fired
+    once per RR that reaches ``APPLIED`` so the CLI can record one git commit per
+    resolved request on an isolated refactor branch. Best-effort; git failures
+    never break the cloud RR loop.
     """
     project_root = Path(project_root)
     progress_cb = progress_cb or (lambda e: None)
@@ -867,7 +873,7 @@ def run_cloud_refactor_requests(
             _record_outcome(
                 project_root, by_id, completed_id, verdict, action.get("message", ""),
                 attempts_by_id.get(completed_id, 0 if verdict == "deferred" else 1),
-                outcomes, counts, progress_cb,
+                outcomes, counts, progress_cb, commit_cb=commit_cb,
             )
             if verdict == "failed":
                 stopped = True
@@ -956,7 +962,7 @@ def _apply_and_verify(
 
 
 def _record_outcome(project_root, by_id, rr_id, verdict, message, attempts,
-                    outcomes: list, counts: dict, progress_cb) -> None:
+                    outcomes: list, counts: dict, progress_cb, *, commit_cb=None) -> None:
     status_map = {
         "applied": APPLIED,
         "denied": DENIED,
@@ -968,6 +974,12 @@ def _record_outcome(project_root, by_id, rr_id, verdict, message, attempts,
         rr.status = status_map.get(verdict, rr.status)
         rr.attempt_count = max(int(getattr(rr, "attempt_count", 0) or 0), int(attempts or 0))
         save_request(project_root, rr)
+        # R29: one git commit per applied RR (client-side git policy), best-effort.
+        if commit_cb is not None and rr.status == APPLIED:
+            try:
+                commit_cb(rr)
+            except Exception:
+                pass
     outcomes.append({
         "location": getattr(rr, "location", rr_id) if rr is not None else rr_id,
         "operation_type": getattr(rr, "operation_type", "content_patch") if rr is not None else "content_patch",

refactorai_cli-0.4.8/refactorai_cli/commands/branch_cmds.py

@@ -0,0 +1,340 @@
+"""`refactor branch` commands: manage the local refactor branch (docs/42 `R29`).
+
+Phase 3 of the local refactor-branch flow. After ``refactor code --commit``
+records one commit per resolved request on an isolated ``refactor/<branch>/<sha>``
+branch, these commands let the developer inspect it (``status``), merge it into
+their working branch **locally** (``merge`` — never pushes), or discard it
+(``drop``).
+
+Everything here is local git + the central RR/branch stores; there is no runtime
+or network dependency. ``refactor_core`` imports are lazy so a stale installed
+core can never break loading the CLI.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from refactorai_cli import git_scope, refactor_branch_store
+
+console = Console()
+app = typer.Typer(
+    name="branch",
+    help="Manage the local refactor branch and its per-request commits (docs/42).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _project_repo() -> Path:
+    """Resolve the project root and require a git repo (local-only commands)."""
+    from refactorai_cli.local_constitution import find_config
+
+    cfg = find_config(Path.cwd())
+    if cfg is None:
+        console.print("[yellow]branch:[/yellow] missing refactor.config. Run `refactor init` first.")
+        raise typer.Exit(code=1)
+    root = cfg.parent
+    if not git_scope.is_git_repo(root):
+        console.print("[red]branch:[/red] not inside a git repository.")
+        raise typer.Exit(code=1)
+    return root
+
+
+def _committed_by_branch(project_root: Path) -> dict[str, list]:
+    """Map refactor branch name -> RRs that have a per-request commit on it."""
+    from refactor_core.refactor_requests import list_requests
+
+    out: dict[str, list] = {}
+    for rr in list_requests(project_root):
+        branch = str(getattr(rr, "refactor_branch", "") or "")
+        if branch and getattr(rr, "commit_sha", ""):
+            out.setdefault(branch, []).append(rr)
+    return out
+
+
+def _squash_message(project_root: Path, target: str, source: str) -> str:
+    rr_count = len(_committed_by_branch(project_root).get(target, []))
+    return (
+        f"refactor: squash {target} ({rr_count} request(s)) [skip-refactor]\n\n"
+        f"Squashed refactor commits from {target} into {source}.\n"
+        "Refactor-Trailer: tool=refactorai; kind=squash-merge"
+    )
+
+
+def source_moved_sha(project_root: Path, target: str, source: str) -> str | None:
+    """Return the source tip sha if it advanced past the branch's recorded base.
+
+    ``None`` when the source is unchanged (or unknown). Used to warn before a
+    merge that git will bridge a gap the refactor branch was not built against.
+    """
+    meta = refactor_branch_store.load_branch(project_root, target)
+    recorded = meta.source_sha if meta else ""
+    if not recorded:
+        return None
+    tip = git_scope.resolve_sha(project_root, source)
+    return tip if (tip and tip != recorded) else None
+
+
+def rebase_refactor_branch(project_root: Path, target: str, source: str) -> tuple[bool, str]:
+    """Rebase ``target`` onto ``source`` so it sits atop the current source tip.
+
+    Conflict-safe (auto-aborts). Updates the recorded base sha on success so a
+    subsequent ``source_moved_sha`` check is clean.
+    """
+    ok, output = git_scope.rebase(project_root, source, target)
+    if not ok:
+        return False, output
+    tip = git_scope.resolve_sha(project_root, source)
+    if tip:
+        meta = refactor_branch_store.load_branch(project_root, target)
+        refactor_branch_store.record_branch(
+            project_root,
+            target,
+            source_branch=source,
+            source_sha=tip,
+        )
+    return True, f"rebased {target} onto {source}"
+
+
+def merge_branch(
+    project_root: Path,
+    target: str,
+    *,
+    source: str,
+    squash: bool = False,
+) -> tuple[bool, str]:
+    """Merge ``target`` into ``source`` locally (never pushes). Returns (ok, msg).
+
+    Pure of prompting/printing so it is reused by both the ``merge`` command and
+    the ``code`` finalize step. Ensures we are on ``source`` first; a dirty tree
+    or a conflict returns ``(False, msg)`` and leaves both branches intact.
+    """
+    if not git_scope.branch_exists(project_root, target):
+        return False, f"refactor branch '{target}' does not exist"
+    if not source or not git_scope.branch_exists(project_root, source):
+        return False, f"source branch '{source}' does not exist"
+    current = git_scope.current_branch(project_root)
+    if current != source:
+        if git_scope.is_worktree_dirty(project_root):
+            return False, "working tree is dirty; commit or stash before merging"
+        if not git_scope.checkout(project_root, source):
+            return False, f"could not check out source branch '{source}'"
+    ok, output = git_scope.merge(project_root, target, squash=squash)
+    if not ok:
+        return False, f"merge failed / conflicted: {output}"
+    if squash:
+        sha = git_scope.commit(project_root, _squash_message(project_root, target, source))
+        if not sha:
+            return True, f"nothing to squash-merge from {target}"
+        return True, f"squash-merged {target} into {source} ({sha[:9]})"
+    return True, f"merged {target} into {source}"
+
+
+def drop_branch(
+    project_root: Path,
+    target: str,
+    *,
+    source: str | None = None,
+) -> tuple[bool, str]:
+    """Delete ``target`` and clear its metadata (discards its commits if unmerged).
+
+    Switches off the branch first (to ``source``) when it is checked out. Pure of
+    prompting/printing so both ``drop`` and finalize can reuse it.
+    """
+    if not git_scope.branch_exists(project_root, target):
+        refactor_branch_store.remove_branch(project_root, target)
+        return True, f"'{target}' did not exist; cleared metadata"
+    current = git_scope.current_branch(project_root)
+    if current == target:
+        dest = source
+        if not dest:
+            meta = refactor_branch_store.load_branch(project_root, target)
+            dest = meta.source_branch if meta else ""
+        if not dest or not git_scope.branch_exists(project_root, dest):
+            return False, "on the refactor branch; check out another branch first"
+        if git_scope.is_worktree_dirty(project_root):
+            return False, "working tree is dirty; commit or stash before dropping"
+        if not git_scope.checkout(project_root, dest):
+            return False, f"could not switch off '{target}'"
+    if git_scope.delete_branch(project_root, target, force=True):
+        refactor_branch_store.remove_branch(project_root, target)
+        return True, f"dropped {target}"
+    return False, f"could not delete '{target}'"
+
+
+def _resolve_target_branch(project_root: Path, branch: str | None) -> str:
+    """Pick the refactor branch to act on (explicit, else the single candidate)."""
+    if branch:
+        return branch
+    metas = refactor_branch_store.list_branches(project_root)
+    existing = [m.branch for m in metas if git_scope.branch_exists(project_root, m.branch)]
+    if len(existing) == 1:
+        return existing[0]
+    if len(existing) > 1:
+        console.print("[yellow]branch:[/yellow] multiple refactor branches exist; pass --branch:")
+        for name in existing:
+            console.print(f"  - {name}")
+        raise typer.Exit(code=2)
+    # Fallbacks: a recorded (but now deleted) branch, RR records, or being on one.
+    committed = _committed_by_branch(project_root)
+    if len(committed) == 1:
+        return next(iter(committed))
+    current = git_scope.current_branch(project_root)
+    if current.startswith("refactor/"):
+        return current
+    console.print("[red]branch:[/red] no refactor branch found. Run `refactor code --commit <sha>` first.")
+    raise typer.Exit(code=1)
+
+
+@app.command("status")
+def status() -> None:
+    """Show refactor branches, their source, and per-request commits."""
+    root = _project_repo()
+    current = git_scope.current_branch(root)
+    console.print(f"Repository: [bold]{root}[/bold]")
+    console.print(f"Current branch: [cyan]{current or '(unknown)'}[/cyan]")
+
+    committed = _committed_by_branch(root)
+    metas = {m.branch: m for m in refactor_branch_store.list_branches(root)}
+    names: list[str] = []
+    for name in list(metas.keys()) + list(committed.keys()):
+        if name not in names:
+            names.append(name)
+
+    if not names:
+        console.print("[dim]No refactor branches yet. Use `refactor code --commit <sha>`.[/dim]")
+        return
+
+    for name in names:
+        exists = git_scope.branch_exists(root, name)
+        meta = metas.get(name)
+        source = meta.source_branch if meta else ""
+        rrs = committed.get(name, [])
+        applied = [rr for rr in rrs if not getattr(rr, "reverted", False)]
+        reverted = [rr for rr in rrs if getattr(rr, "reverted", False)]
+        header = f"\n[cyan]{name}[/cyan]"
+        if not exists:
+            header += " [dim](deleted)[/dim]"
+        console.print(
+            f"{header}  [dim]source={source or '?'}  "
+            f"commits={len(applied)}  reverted={len(reverted)}[/dim]"
+        )
+        if not rrs:
+            continue
+        table = Table(show_lines=False)
+        table.add_column("rr_id", no_wrap=True)
+        table.add_column("status", no_wrap=True)
+        table.add_column("commit", no_wrap=True)
+        table.add_column("location")
+        for rr in rrs:
+            table.add_row(
+                rr.rr_id,
+                str(getattr(rr, "status", "")),
+                str(getattr(rr, "commit_sha", "") or "")[:9],
+                getattr(rr, "location", ""),
+            )
+        console.print(table)
+
+
+@app.command("merge")
+def merge(
+    branch: str | None = typer.Option(None, "--branch", help="Refactor branch to merge (default: the single existing one)."),
+    squash: bool = typer.Option(False, "--squash", help="Squash the refactor commits into one on the source branch."),
+    rebase: bool = typer.Option(False, "--rebase", help="If the source branch advanced, rebase the refactor branch onto it before merging."),
+    yes: bool = typer.Option(False, "--yes", help="Skip the confirmation prompt."),
+) -> None:
+    """Merge the refactor branch into its source branch locally (never pushes)."""
+    root = _project_repo()
+    target = _resolve_target_branch(root, branch)
+    if not git_scope.branch_exists(root, target):
+        console.print(f"[red]branch:[/red] refactor branch '{target}' does not exist.")
+        raise typer.Exit(code=1)
+
+    meta = refactor_branch_store.load_branch(root, target)
+    source = meta.source_branch if meta else ""
+    current = git_scope.current_branch(root)
+    if not source or not git_scope.branch_exists(root, source):
+        # Fall back to the current branch when it is not the refactor branch.
+        if current and current != target:
+            source = current
+        else:
+            console.print(
+                "[red]branch:[/red] could not determine the source branch. "
+                "Check out your working branch, then re-run `refactor branch merge`."
+            )
+            raise typer.Exit(code=2)
+
+    # docs/42 Part O: warn when the source branch advanced past the pinned base.
+    moved = source_moved_sha(root, target, source)
+    if moved:
+        recorded = meta.source_sha if meta else ""
+        console.print(
+            f"[yellow]branch:[/yellow] source '{source}' advanced since {target} was "
+            f"created ([dim]{(recorded or '?')[:9]} -> {moved[:9]}[/dim])."
+        )
+        if rebase:
+            console.print(f"[dim]branch: rebasing {target} onto {source}...[/dim]")
+            ok, msg = rebase_refactor_branch(root, target, source)
+            if not ok:
+                console.print(
+                    f"[red]branch: rebase failed / conflicted.[/red]\n[dim]{msg}[/dim]\n"
+                    "[dim]Resolve the refactor branch manually, then re-run merge.[/dim]"
+                )
+                raise typer.Exit(code=1)
+            console.print(f"[green]{msg}.[/green]")
+        else:
+            console.print(
+                "[dim]Pass --rebase to replay the refactor commits on the new tip "
+                "first, or continue to let git bridge the gap.[/dim]"
+            )
+
+    if not yes and sys.stdin.isatty():
+        how = "squash-merge" if squash else "merge"
+        if not typer.confirm(f"{how} {target} into {source} (local, no push)?", default=True):
+            console.print("[dim]branch: merge aborted.[/dim]")
+            raise typer.Exit(code=1)
+
+    ok, message = merge_branch(root, target, source=source, squash=squash)
+    if not ok:
+        console.print(f"[red]branch: {message}[/red]")
+        console.print(
+            "[dim]Resolve conflicts and commit, or run `git merge --abort` to back out. "
+            "Both branches are intact.[/dim]"
+        )
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]{message}[/green] [dim](local only)[/dim]")
+    console.print(
+        f"[dim]The refactor commits are now on {source}. Push when you're ready; "
+        f"drop the branch with `refactor branch drop --branch {target}`.[/dim]"
+    )
+
+
+@app.command("drop")
+def drop(
+    branch: str | None = typer.Option(None, "--branch", help="Refactor branch to drop (default: the single existing one)."),
+    yes: bool = typer.Option(False, "--yes", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete the refactor branch and forget its metadata (discards its commits)."""
+    root = _project_repo()
+    target = _resolve_target_branch(root, branch)
+
+    if not yes and sys.stdin.isatty() and git_scope.branch_exists(root, target):
+        if not typer.confirm(
+            f"drop {target}? This discards its refactor commits (unless already merged).",
+            default=False,
+        ):
+            console.print("[dim]branch: drop aborted.[/dim]")
+            raise typer.Exit(code=1)
+
+    ok, message = drop_branch(root, target)
+    if not ok:
+        console.print(f"[red]branch: {message}.[/red]")
+        raise typer.Exit(code=2 if "check out" in message or "dirty" in message else 1)
+    console.print(f"[green]{message}.[/green]")

refactorai_cli-0.4.8/refactorai_cli/commands/request_cmds.py

@@ -0,0 +1,129 @@
+"""`refactor request` commands: per-request listing + revert (docs/42 `R29`).
+
+Phase 3 of the local refactor-branch flow. ``list`` surfaces each Refactor
+Request with its ``rr_id`` and per-request commit; ``revert --id`` reverses a
+single applied request via ``git revert`` (history-preserving) and marks it
+``reverted``.
+
+Local git + the central RR store only; ``refactor_core`` imports are lazy so a
+stale installed core can never break loading the CLI.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from refactorai_cli import git_scope
+
+console = Console()
+app = typer.Typer(
+    name="request",
+    help="Inspect and revert individual Refactor Requests (docs/42).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _project_repo(*, require_git: bool) -> Path:
+    from refactorai_cli.local_constitution import find_config
+
+    cfg = find_config(Path.cwd())
+    if cfg is None:
+        console.print("[yellow]request:[/yellow] missing refactor.config. Run `refactor init` first.")
+        raise typer.Exit(code=1)
+    root = cfg.parent
+    if require_git and not git_scope.is_git_repo(root):
+        console.print("[red]request:[/red] not inside a git repository.")
+        raise typer.Exit(code=1)
+    return root
+
+
+@app.command("list")
+def list_requests_cmd() -> None:
+    """List Refactor Requests with rr_id, status, and per-request commit."""
+    root = _project_repo(require_git=False)
+    from refactor_core.refactor_requests import list_requests
+
+    rrs = list_requests(root)
+    if not rrs:
+        console.print("[dim]No refactor requests. Run `refactor review` to create them.[/dim]")
+        return
+
+    table = Table(title="Refactor requests", show_lines=False)
+    table.add_column("rr_id", no_wrap=True)
+    table.add_column("status", no_wrap=True)
+    table.add_column("commit", no_wrap=True)
+    table.add_column("branch", no_wrap=True)
+    table.add_column("location")
+    color = {
+        "pending": "yellow",
+        "in_progress": "yellow",
+        "applied": "green",
+        "reverted": "magenta",
+        "denied": "red",
+        "failed": "red",
+        "deferred": "cyan",
+    }
+    for rr in rrs:
+        status = str(getattr(rr, "status", ""))
+        style = color.get(status, "white")
+        table.add_row(
+            rr.rr_id,
+            f"[{style}]{status}[/{style}]",
+            str(getattr(rr, "commit_sha", "") or "")[:9] or "[dim]-[/dim]",
+            str(getattr(rr, "refactor_branch", "") or "") or "[dim]-[/dim]",
+            getattr(rr, "location", ""),
+        )
+    console.print(table)
+
+
+@app.command("revert")
+def revert(
+    id: str = typer.Option(..., "--id", help="rr_id of the request to revert."),
+    yes: bool = typer.Option(False, "--yes", help="Skip the confirmation prompt."),
+) -> None:
+    """Revert a single request's commit via `git revert` and mark it reverted."""
+    root = _project_repo(require_git=True)
+    from refactor_core.refactor_requests import REVERTED, load_request, save_request
+
+    rr = load_request(root, id)
+    if rr is None:
+        console.print(f"[red]request:[/red] no request with rr_id '{id}'.")
+        raise typer.Exit(code=1)
+
+    sha = str(getattr(rr, "commit_sha", "") or "") or (git_scope.commit_sha_for_rr(root, id) or "")
+    if not sha:
+        console.print(
+            f"[red]request:[/red] no per-request commit recorded for '{id}'. "
+            "Only requests resolved on a refactor branch can be reverted this way."
+        )
+        raise typer.Exit(code=1)
+
+    if getattr(rr, "reverted", False):
+        console.print(f"[yellow]request:[/yellow] '{id}' is already reverted.")
+        raise typer.Exit(code=0)
+
+    if not yes and sys.stdin.isatty():
+        if not typer.confirm(
+            f"revert request {id} (commit {sha[:9]}) via git revert?", default=False
+        ):
+            console.print("[dim]request: revert aborted.[/dim]")
+            raise typer.Exit(code=1)
+
+    ok, output = git_scope.revert_commit(root, sha)
+    if not ok:
+        console.print(f"[red]request: git revert failed / conflicted.[/red]\n[dim]{output}[/dim]")
+        console.print(
+            "[dim]Resolve conflicts and commit, or run `git revert --abort` to back out.[/dim]"
+        )
+        raise typer.Exit(code=1)
+
+    rr.reverted = True
+    rr.status = REVERTED
+    save_request(root, rr)
+    console.print(f"[green]Reverted[/green] request {id} (revert of {sha[:9]}).")