gitgrip 1.5.0__py3-none-any.whl

gr2/python_cli/commit.py

@@ -0,0 +1,199 @@
+"""Native commit creation for the Python gr2 CLI.
+
+Single-repository by default; lane-aware across a materialized lane's repos
+when a workspace + owner unit are supplied (impedance B).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gr2.prototypes import lane_workspace_prototype as lane_proto
+
+from .gitops import git
+
+
+class CommitError(Exception):
+    pass
+
+
+class NothingToCommitError(CommitError):
+    pass
+
+
+@dataclass(frozen=True)
+class CommitReceipt:
+    commit_sha: str
+    message: str
+    amended: bool
+
+
+def _head_sha(repo: Path, *, required: bool) -> str | None:
+    try:
+        result = git(repo, "rev-parse", "--verify", "HEAD")
+    except OSError as exc:
+        raise CommitError(f"failed to resolve HEAD in {repo}: {exc}") from exc
+    sha = result.stdout.strip() if result.returncode == 0 else ""
+    if required and not sha:
+        raise CommitError("git commit succeeded but the resulting HEAD could not be verified")
+    return sha or None
+
+
+def _staged_changes_exist(repo: Path) -> bool:
+    try:
+        probe = git(repo, "diff", "--cached", "--quiet", "--exit-code")
+    except OSError as exc:
+        raise CommitError(f"failed to inspect the staged index in {repo}: {exc}") from exc
+    if probe.returncode == 0:
+        return False
+    if probe.returncode == 1:
+        return True
+    detail = (probe.stderr or probe.stdout).strip()
+    raise CommitError(detail or f"staged-index probe failed with exit {probe.returncode}")
+
+
+def _refuse_review_ephemeral_repo(repo: Path) -> None:
+    """A review-ephemeral lane repo carries a review record naming its kind. Refuse
+    a commit into it directly (the reviewer's cwd is inside the review lane), so a
+    review lane never becomes a work lane through the single-repo path."""
+    import json as _json
+    record = Path(repo) / ".git" / "grip-review.json"
+    try:
+        kind = _json.loads(record.read_text()).get("lane_kind")
+    except (OSError, ValueError):
+        return
+    if kind == "review-ephemeral":
+        raise CommitError(
+            f"{repo} is a review-ephemeral review lane (read-only, disposable): it "
+            "cannot be committed to. A review lane never becomes a work lane."
+        )
+
+
+def create_commit(repo: Path, message: str, *, amend: bool = False) -> CommitReceipt:
+    """Create a commit and return the immutable commit ID observed afterward.
+
+    A normal commit first asks the index whether a staged diff exists. It never
+    classifies "nothing to commit" by localized or version-dependent prose.
+    Amend is allowed without a new staged diff because changing only the prior
+    commit message is a valid amend operation.
+    """
+    if not message:
+        raise CommitError("commit message must not be empty")
+    _refuse_review_ephemeral_repo(repo)
+    if not amend and not _staged_changes_exist(repo):
+        raise NothingToCommitError("no staged changes to commit")
+
+    head_before = _head_sha(repo, required=False)
+
+    args = ["commit"]
+    if amend:
+        args.append("--amend")
+    args.extend(["-m", message])
+    try:
+        committed = git(repo, *args)
+    except OSError as exc:
+        raise CommitError(f"failed to launch git commit in {repo}: {exc}") from exc
+    if committed.returncode != 0:
+        detail = (committed.stderr or committed.stdout).strip()
+        raise CommitError(detail or f"git commit failed with exit {committed.returncode}")
+
+    commit_sha = _head_sha(repo, required=True)
+    assert commit_sha is not None
+    if commit_sha == head_before:
+        raise CommitError(
+            f"git commit returned success but HEAD did not advance from {head_before}"
+        )
+    return CommitReceipt(commit_sha=commit_sha, message=message, amended=amend)
+
+
+# --- lane-aware commit (impedance B) --------------------------------------
+
+
+@dataclass(frozen=True)
+class LaneRepoCommit:
+    repo: str
+    status: str  # "committed" | "skipped_empty" | "failed"
+    commit_sha: str | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class LaneCommitReport:
+    owner_unit: str
+    lane_name: str
+    lane_kind: str
+    results: list[LaneRepoCommit] = field(default_factory=list)
+
+    @property
+    def any_committed(self) -> bool:
+        return any(r.status == "committed" for r in self.results)
+
+    @property
+    def any_failed(self) -> bool:
+        return any(r.status == "failed" for r in self.results)
+
+
+def _lane_repo_targets(
+    workspace_root: Path, owner_unit: str, lane_name: str, doc: dict
+) -> list[tuple[str, Path]]:
+    """(repo_key, repo_root) for each repo the lane commit should touch.
+
+    A bound lane is single-repo: its one repo lives in the author's bound
+    worktree, not under the lane state tree. A materialized lane commits each
+    of its repos/<key> checkouts.
+    """
+    kind = doc.get("lane_kind", "materialized")
+    repos = list(doc.get("repos", []))
+    if kind == "bound":
+        worktree = doc.get("bound_worktree")
+        if not worktree:
+            raise CommitError(
+                f"bound lane {owner_unit}/{lane_name} records no bound_worktree"
+            )
+        key = repos[0] if repos else "bound"
+        return [(key, Path(worktree))]
+    lane_root = lane_proto.lane_dir(workspace_root, owner_unit, lane_name)
+    return [(repo, lane_root / "repos" / repo) for repo in repos]
+
+
+def commit_lane(
+    workspace_root: Path,
+    owner_unit: str,
+    message: str,
+    *,
+    lane_name: str | None = None,
+    amend: bool = False,
+) -> LaneCommitReport:
+    """Commit each repo of a lane under one message.
+
+    Repos with an empty staged index are skipped and reported (never an empty
+    commit). A repo whose commit fails is recorded as failed and does NOT roll
+    back the repos already committed; the report names it so the caller can act.
+    Bound lanes stay single-repo (the bound worktree).
+    """
+    if not message:
+        raise CommitError("commit message must not be empty")
+    workspace_root = Path(workspace_root).resolve()
+    if lane_name is None:
+        lane_name = lane_proto.require_current_lane(workspace_root, owner_unit)["lane_name"]
+    doc = lane_proto.load_lane_doc(workspace_root, owner_unit, lane_name)
+    kind = doc.get("lane_kind", "materialized")
+    if kind == "review-ephemeral":
+        raise CommitError(
+            f"lane {owner_unit}/{lane_name} is a review-ephemeral lane (read-only, "
+            "disposable): it cannot be committed to. A review lane never becomes a "
+            "work lane; exit the review and open a work lane to make changes."
+        )
+
+    results: list[LaneRepoCommit] = []
+    for repo_key, repo_root in _lane_repo_targets(workspace_root, owner_unit, lane_name, doc):
+        try:
+            if not amend and not _staged_changes_exist(repo_root):
+                results.append(LaneRepoCommit(repo_key, "skipped_empty"))
+                continue
+            receipt = create_commit(repo_root, message, amend=amend)
+            results.append(LaneRepoCommit(repo_key, "committed", commit_sha=receipt.commit_sha))
+        except CommitError as exc:
+            results.append(LaneRepoCommit(repo_key, "failed", error=str(exc)))
+    return LaneCommitReport(owner_unit=owner_unit, lane_name=lane_name, lane_kind=kind, results=results)

gr2/python_cli/config.py

@@ -0,0 +1,291 @@
+"""Config base + overlay model: Docker OverlayFS analogy for workspace config.
+
+Base layer: TOML files (cold, human-authored, git-reviewed)
+Overlay layer: JSON files (hot, agent-writable)
+Reads: overlay first, base fallback
+Writes: overlay only
+_base_sha: overlay tracks which base version it extends
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+import toml
+
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+
+class BaseStaleError(Exception):
+    """Raised when overlay's _base_sha doesn't match current base content."""
+
+
+class PolicyViolationError(Exception):
+    """Raised when a write is blocked by the active policy."""
+
+
+# ---------------------------------------------------------------------------
+# Policies
+# ---------------------------------------------------------------------------
+
+
+class WritePolicy(ABC):
+    @abstractmethod
+    def can_write(self, agent: str, section: str, key: str) -> bool: ...
+
+
+class FreeWritePolicy(WritePolicy):
+    def can_write(self, agent: str, section: str, key: str) -> bool:
+        return True
+
+
+class OwnWriteOnlyPolicy(WritePolicy):
+    """Agents can only write to their own section (agents.<name>, prompts.<name>).
+
+    Shared sections (spawn, tools, etc.) are writable by anyone.
+    """
+
+    _SCOPED_PREFIXES = ("agents.", "prompts.")
+
+    def can_write(self, agent: str, section: str, key: str) -> bool:
+        for prefix in self._SCOPED_PREFIXES:
+            if section.startswith(prefix):
+                section_owner = section[len(prefix) :].split(".")[0]
+                return section_owner == agent
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _base_sha(content: str) -> str:
+    return hashlib.sha256(content.encode()).hexdigest()
+
+
+def _deep_merge(base: dict, overlay: dict) -> dict:
+    """Recursively merge overlay into base. Overlay wins on conflict."""
+    result = deepcopy(base)
+    for key, val in overlay.items():
+        if key == "_base_sha":
+            continue
+        if key in result and isinstance(result[key], dict) and isinstance(val, dict):
+            result[key] = _deep_merge(result[key], val)
+        else:
+            result[key] = deepcopy(val)
+    return result
+
+
+def _resolve_dotted_key(data: dict, key: str) -> Any:
+    parts = key.split(".")
+    current: Any = data
+    for part in parts:
+        if not isinstance(current, dict) or part not in current:
+            return None
+        current = current[part]
+    return current
+
+
+def _set_nested(data: dict, dotted_section: str, key: str, value: Any) -> None:
+    parts = dotted_section.split(".")
+    current = data
+    for part in parts:
+        if part not in current or not isinstance(current[part], dict):
+            current[part] = {}
+        current = current[part]
+    current[key] = value
+
+
+def _overlay_stem(base_path: Path) -> str:
+    return base_path.stem
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def config_apply(base_path: Path, overlay_dir: Path) -> dict:
+    """Materialize TOML base into JSON overlay with _base_sha.
+
+    If overlay already exists, merges new base keys into it while
+    preserving existing overlay modifications.
+    """
+    base_content = base_path.read_text()
+    base_data = toml.loads(base_content)
+    sha = _base_sha(base_content)
+
+    overlay_dir.mkdir(parents=True, exist_ok=True)
+    overlay_path = overlay_dir / f"{_overlay_stem(base_path)}.json"
+
+    if overlay_path.exists():
+        existing = json.loads(overlay_path.read_text())
+        existing.pop("_base_sha", None)
+        merged = _deep_merge(base_data, existing)
+    else:
+        merged = deepcopy(base_data)
+
+    merged["_base_sha"] = sha
+    overlay_path.write_text(json.dumps(merged, indent=2) + "\n")
+    return {k: v for k, v in merged.items() if k != "_base_sha"}
+
+
+def config_show(
+    base_path: Path,
+    overlay_dir: Path,
+    key: str | None = None,
+    *,
+    strict: bool = False,
+) -> Any:
+    """Read config with overlay-first, base-fallback resolution.
+
+    If key is None, returns the full merged dict.
+    If key is a dotted path (e.g. "agents.opus.model"), resolves to that value.
+    Returns None for missing keys.
+    """
+    base_content = base_path.read_text()
+    base_data = toml.loads(base_content)
+
+    overlay_path = overlay_dir / f"{_overlay_stem(base_path)}.json"
+    overlay_data: dict = {}
+
+    if overlay_path.exists():
+        overlay_data = json.loads(overlay_path.read_text())
+        if strict:
+            stored_sha = overlay_data.get("_base_sha", "")
+            current_sha = _base_sha(base_content)
+            if stored_sha != current_sha:
+                raise BaseStaleError(
+                    f"Overlay _base_sha ({stored_sha[:12]}...) does not match "
+                    f"current base ({current_sha[:12]}...)"
+                )
+
+    clean_overlay = {k: v for k, v in overlay_data.items() if k != "_base_sha"}
+    merged = _deep_merge(base_data, clean_overlay)
+
+    # Include prompt overlays in the merged view
+    prompts_dir = overlay_dir / "prompts"
+    if prompts_dir.is_dir():
+        prompts: dict[str, Any] = merged.get("prompts", {})
+        for pf in sorted(prompts_dir.glob("*.json")):
+            agent_name = pf.stem
+            agent_prompts = json.loads(pf.read_text())
+            if agent_name in prompts and isinstance(prompts[agent_name], dict):
+                prompts[agent_name] = _deep_merge(prompts[agent_name], agent_prompts)
+            else:
+                prompts[agent_name] = agent_prompts
+        if prompts:
+            merged["prompts"] = prompts
+
+    if key is None:
+        return merged
+    return _resolve_dotted_key(merged, key)
+
+
+def overlay_write(
+    overlay_dir: Path,
+    section: str,
+    key: str,
+    value: Any,
+    *,
+    agent: str = "",
+    policy: WritePolicy | None = None,
+    prompt_overlay: bool = False,
+) -> None:
+    """Write a value to the overlay. Respects policy enforcement.
+
+    If prompt_overlay is True, writes to prompts/{agent_name}.json instead
+    of the main overlay file.
+    """
+    if policy is not None and agent:
+        if not policy.can_write(agent=agent, section=section, key=key):
+            raise PolicyViolationError(
+                f"Agent '{agent}' cannot write to section '{section}' "
+                f"under {policy.__class__.__name__}"
+            )
+
+    if prompt_overlay:
+        parts = section.split(".")
+        if len(parts) >= 2 and parts[0] == "prompts":
+            agent_name = parts[1]
+            prompts_dir = overlay_dir / "prompts"
+            prompts_dir.mkdir(parents=True, exist_ok=True)
+            prompt_path = prompts_dir / f"{agent_name}.json"
+
+            data: dict = {}
+            if prompt_path.exists():
+                data = json.loads(prompt_path.read_text())
+            data[key] = value
+            prompt_path.write_text(json.dumps(data, indent=2) + "\n")
+            return
+
+    overlay_path = overlay_dir / "agents.json"
+    if not overlay_path.exists():
+        raise FileNotFoundError(
+            f"Overlay file not found: {overlay_path}. Run config_apply first."
+        )
+
+    data = json.loads(overlay_path.read_text())
+    _set_nested(data, section, key, value)
+    overlay_path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def config_restore(workspace: Path, ref: str, overlay_dir: Path) -> dict:
+    """Restore overlay files from a grip commit's config/ subtree."""
+    from gr2.python_cli.grip import _grip_git
+
+    proc = _grip_git(workspace, "ls-tree", f"{ref}:config")
+    if proc.returncode != 0:
+        return {}
+
+    overlay_dir.mkdir(parents=True, exist_ok=True)
+    restored: dict[str, str] = {}
+
+    for line in proc.stdout.strip().splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        meta, name = parts[0], parts[1]
+        obj_type = meta.split()[1]
+
+        if obj_type == "blob":
+            blob = _grip_git(workspace, "show", f"{ref}:config/{name}")
+            if blob.returncode == 0:
+                (overlay_dir / name).write_text(blob.stdout)
+                restored[name] = "restored"
+        elif obj_type == "tree" and name == "prompts":
+            _restore_prompts(workspace, ref, overlay_dir)
+
+    return restored
+
+
+def _restore_prompts(workspace: Path, ref: str, overlay_dir: Path) -> None:
+    from gr2.python_cli.grip import _grip_git
+
+    prompts_dir = overlay_dir / "prompts"
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    proc = _grip_git(workspace, "ls-tree", f"{ref}:config/prompts")
+    if proc.returncode != 0:
+        return
+
+    for line in proc.stdout.strip().splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        name = parts[1]
+        blob = _grip_git(workspace, "show", f"{ref}:config/prompts/{name}")
+        if blob.returncode == 0:
+            (prompts_dir / name).write_text(blob.stdout)