gitgrip 1.5.0__py3-none-any.whl

gr2/python_cli/branch.py

@@ -0,0 +1,67 @@
+"""Native `branch` command (grip#752 slice 1, D3).
+
+Create/switch, --base support (grip#746: gr1's `gr branch` has no base-ref
+argument, forcing raw-git fallbacks), existing-branch-switches-not-errors
+(mirrors gr1's grip#401 fix), worktree-conflict detection (mirrors gr1's
+real, cited pain -- grip#750).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .gitops import git
+
+
+class BranchError(Exception):
+    pass
+
+
+def _branch_exists(repo: Path, name: str) -> bool:
+    proc = git(repo, "rev-parse", "--verify", f"refs/heads/{name}")
+    return proc.returncode == 0
+
+
+def _ref_exists(repo: Path, ref: str) -> bool:
+    proc = git(repo, "rev-parse", "--verify", ref)
+    return proc.returncode == 0
+
+
+def _raise_for_checkout_failure(name: str, stderr: str) -> None:
+    if "is already used by worktree at" in stderr:
+        marker = "worktree at '"
+        start = stderr.find(marker)
+        if start != -1:
+            start += len(marker)
+            end = stderr.find("'", start)
+            worktree_path = stderr[start:end] if end != -1 else "another worktree"
+            raise BranchError(
+                f"Branch '{name}' is checked out in another worktree at '{worktree_path}'. "
+                f"Use that worktree or choose a different branch name."
+            )
+        raise BranchError(f"Branch '{name}' is already checked out in another worktree.")
+    raise BranchError(stderr.strip())
+
+
+def create_branch(repo: Path, name: str, base: str | None = None) -> None:
+    """Create and switch to branch `name` in `repo`.
+
+    If `name` already exists, switch to it instead of erroring (grip#401).
+    If `base` is given, the branch is created (or reset, if it already
+    exists) to point at `base` -- resolved per-repo, matching `git checkout
+    -B`'s own create-or-reset semantics. A missing `base` ref raises
+    immediately, before any git mutation -- never a silent fallback to HEAD
+    (grip#746's acceptance criteria).
+    """
+    if base is not None and not _ref_exists(repo, base):
+        raise BranchError(f"base ref '{base}' does not exist in {repo}")
+
+    if base is not None:
+        proc = git(repo, "checkout", "-B", name, base)
+    elif _branch_exists(repo, name):
+        proc = git(repo, "checkout", name)
+    else:
+        proc = git(repo, "checkout", "-b", name)
+
+    if proc.returncode != 0:
+        _raise_for_checkout_failure(name, proc.stderr)

gr2/python_cli/channel_bridge.py

@@ -0,0 +1,131 @@
+"""gr2 channel bridge consumer.
+
+Translates outbox events into channel messages per the mapping table in
+HOOK-EVENT-CONTRACT.md section 8. Uses cursor-based consumption from
+events.read_events_detailed(), which also reports lines it could not read.
+
+The bridge is a pure function layer: format_event() maps an event dict to
+a message string (or None), and run_bridge() orchestrates cursor reads and
+posts via a caller-provided post_fn. This keeps the MCP/recall_channel
+dependency out of the module and makes it fully testable.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from .events import read_events_detailed, warn_unreadable
+
+
+_CONSUMER_NAME = "channel_bridge"
+
+
+def format_event(event: dict[str, object]) -> str | None:
+    """Apply the section 8 mapping table to produce a channel message.
+
+    Returns None if the event type is not mapped (silently dropped).
+    """
+    etype = event.get("type", "")
+
+    if etype == "lane.created":
+        return (
+            f"{event['actor']} created lane {event['lane_name']}"
+            f" [{event.get('lane_type', 'unknown')}]"
+            f" repos={event.get('repos', [])}"
+        )
+
+    if etype == "lane.entered":
+        return f"{event['actor']} entered {event['owner_unit']}/{event['lane_name']}"
+
+    if etype == "lane.exited":
+        return f"{event['actor']} exited {event['owner_unit']}/{event['lane_name']}"
+
+    if etype == "pr.created":
+        repos = event.get("repos", [])
+        if isinstance(repos, list) and repos and isinstance(repos[0], dict):
+            repo_names = [r.get("repo", "") for r in repos]
+        else:
+            repo_names = repos
+        return (
+            f"{event['actor']} opened PR group {event['pr_group_id']}: {repo_names}"
+        )
+
+    if etype == "pr.merged":
+        return f"{event['actor']} merged PR group {event['pr_group_id']}"
+
+    if etype == "pr.checks_failed":
+        failed = event.get("failed_checks", [])
+        return f"CI failed on {event['repo']}#{event['pr_number']}: {failed}"
+
+    if etype == "hook.failed":
+        # Only blocking hook failures produce channel messages.
+        if event.get("on_failure") != "block":
+            return None
+        return (
+            f"Hook {event['hook_name']} failed in {event['repo']}"
+            f" (blocking): {event.get('stderr_tail', '')}"
+        )
+
+    if etype == "sync.conflict":
+        files = event.get("conflicting_files", [])
+        return f"Sync conflict in {event['repo']}: {files}"
+
+    if etype == "lease.force_broken":
+        return (
+            f"Lease on {event['lane_name']} force-broken"
+            f" by {event['broken_by']}: {event.get('reason', '')}"
+        )
+
+    if etype == "failure.resolved":
+        return (
+            f"{event['resolved_by']} resolved failure"
+            f" {event['operation_id']} on {event['lane_name']}"
+        )
+
+    if etype == "lease.reclaimed":
+        return (
+            f"Stale lease on {event['lane_name']} reclaimed"
+            f" (was held by {event['previous_holder']})"
+        )
+
+    # Unmapped event type: silently dropped.
+    return None
+
+
+def run_bridge(
+    workspace_root: Path,
+    *,
+    post_fn: Callable[[str], object],
+) -> int:
+    """Read new events from the outbox and post mapped messages.
+
+    Uses the 'channel_bridge' cursor. Returns the number of messages posted.
+    The post_fn receives formatted message strings; the caller decides how to
+    deliver them (recall_channel, print, log, etc.).
+    """
+    read = read_events_detailed(workspace_root, _CONSUMER_NAME)
+    # An unreadable outbox line is a message that never reaches a channel, and
+    # the bridge is the only place that says so.
+    #
+    # It is reported on EVERY read, not once: the cursor filter compares seq
+    # against the cursor and only lines that PARSE have a usable seq, so an
+    # unreadable line can never be advanced past, wherever it sits in the file
+    # (witnessed terminal AND mid-file). An UNTERMINATED record never reaches
+    # this report at all: the reader splits on b"\n", so a COMPLETE record whose
+    # only loss was its terminator is the final chunk and parses on the spot --
+    # before any emit, repair or no repair (W11, and its truncated control).
+    # What seam repair protects is the NEXT append, which would otherwise be
+    # glued onto it. So everything reported here is a TRUNCATED record, and for
+    # those the report is permanent: a bridge polling in a loop warns every
+    # cycle until someone repairs the file. That cost is real and is recorded
+    # as a residual.
+    #
+    # stderr keeps stdout parseable for callers that consume the posted count.
+    warn_unreadable(read)
+    posted = 0
+    for event in read.events:
+        msg = format_event(event)
+        if msg is not None:
+            post_fn(msg)
+            posted += 1
+    return posted