gitgrip 1.5.0__py3-none-any.whl

gr2/overlay/cross_repo.py

@@ -0,0 +1,124 @@
+"""Cross-repo atomic overlay activation with rollback."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gr2.overlay.activate import (
+    OverlayActivationError,
+    activate_overlay,
+    deactivate_overlay,
+)
+from gr2.overlay.types import OverlayRef
+
+
+@dataclass(frozen=True)
+class RepoOverlayTarget:
+    repo_name: str
+    checkout_root: Path
+    overlay_store: Path
+    overlay_ref: OverlayRef
+    overlay_source_kind: str
+    overlay_source_value: str | None
+    overlay_signer: str | None
+
+
+@dataclass
+class CrossRepoActivationResult:
+    status: str
+    completed_repos: list[str] = field(default_factory=list)
+    rolled_back_repos: list[str] = field(default_factory=list)
+
+
+class CrossRepoActivationError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        error_code: str,
+        failing_repo: str,
+        rolled_back_repos: list[str],
+    ) -> None:
+        super().__init__(message)
+        self.error_code = error_code
+        self.failing_repo = failing_repo
+        self.rolled_back_repos = rolled_back_repos
+
+
+def activate_overlays_atomically(
+    targets: list[RepoOverlayTarget],
+) -> CrossRepoActivationResult:
+    snapshots: dict[str, dict[str, str]] = {}
+    applied: list[RepoOverlayTarget] = []
+
+    for target in targets:
+        snapshots[target.repo_name] = _snapshot(target.checkout_root)
+
+    try:
+        for target in targets:
+            activate_overlay(
+                workspace_root=target.checkout_root,
+                overlay_store=target.overlay_store,
+                overlay_ref=target.overlay_ref,
+                overlay_source_kind=target.overlay_source_kind,
+                overlay_source_value=target.overlay_source_value,
+                overlay_signer=target.overlay_signer,
+            )
+            applied.append(target)
+    except OverlayActivationError as e:
+        failing_target = target
+        rolled_back: list[str] = []
+
+        for prev in reversed(applied):
+            _restore_snapshot(prev.checkout_root, snapshots[prev.repo_name])
+            rolled_back.append(prev.repo_name)
+        rolled_back.reverse()
+
+        if _snapshot(failing_target.checkout_root) != snapshots[failing_target.repo_name]:
+            _restore_snapshot(failing_target.checkout_root, snapshots[failing_target.repo_name])
+            rolled_back.append(failing_target.repo_name)
+
+        raise CrossRepoActivationError(
+            str(e),
+            error_code=e.error_code,
+            failing_repo=failing_target.repo_name,
+            rolled_back_repos=rolled_back,
+        ) from e
+
+    return CrossRepoActivationResult(
+        status="ok",
+        completed_repos=[t.repo_name for t in applied],
+    )
+
+
+def _snapshot(root: Path) -> dict[str, bytes]:
+    result: dict[str, bytes] = {}
+    for path in sorted(root.rglob("*")):
+        if path.is_file():
+            result[str(path.relative_to(root))] = path.read_bytes()
+    return result
+
+
+def _restore_snapshot(root: Path, snapshot: dict[str, bytes | str]) -> None:
+    current_files = set()
+    for path in root.rglob("*"):
+        if path.is_file():
+            current_files.add(str(path.relative_to(root)))
+
+    for rel_path in current_files - set(snapshot.keys()):
+        target = root / rel_path
+        target.unlink()
+
+    for rel_path, content in snapshot.items():
+        target = root / rel_path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if isinstance(content, str):
+            target.write_text(content)
+        else:
+            target.write_bytes(content)
+
+    for dirpath in sorted(root.rglob("*"), reverse=True):
+        if dirpath.is_dir() and not any(dirpath.iterdir()):
+            dirpath.rmdir()

gr2/overlay/drivers.py

@@ -0,0 +1,113 @@
+"""Curated overlay merge drivers: deep, prepend, union."""
+
+from __future__ import annotations
+
+import json
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+import yaml
+
+from gr2.overlay.types import OverlayRef
+
+CURATED_DRIVERS: dict[str, str] = {
+    "overlay-deep": "deep",
+    "overlay-prepend": "prepend",
+    "overlay-union": "union",
+}
+
+
+def install_driver_registry() -> None:
+    home = Path(os.environ["HOME"])
+    gitconfig = home / ".gitconfig"
+
+    existing = gitconfig.read_text() if gitconfig.exists() else ""
+
+    sections: list[str] = []
+    for driver_name in CURATED_DRIVERS:
+        header = f'[merge "{driver_name}"]'
+        if header not in existing:
+            sections.append(
+                f"{header}\n"
+                f"\tname = {driver_name}\n"
+                f"\tdriver = gr2-overlay-driver {driver_name} %O %A %B %P\n"
+            )
+
+    if sections:
+        with gitconfig.open("a") as f:
+            f.write("\n".join(sections) + "\n")
+
+
+def invoke_driver(
+    driver_name: str,
+    ancestor: Path,
+    current: Path,
+    other: Path,
+    relative_path: str,
+    *,
+    source_overlay: OverlayRef,
+    trusted_overlay_sources: set[str],
+) -> None:
+    if driver_name not in CURATED_DRIVERS:
+        raise ValueError(f"Unknown overlay driver: {driver_name}")
+
+    if source_overlay.ref_path not in trusted_overlay_sources:
+        raise PermissionError(f"Overlay source {source_overlay.ref_path} is not in the allowlist")
+
+    handlers = {
+        "overlay-deep": _driver_deep,
+        "overlay-prepend": _driver_prepend,
+        "overlay-union": _driver_union,
+    }
+    handlers[driver_name](ancestor, current, other, relative_path)
+
+
+def _driver_deep(ancestor: Path, current: Path, other: Path, relative_path: str) -> None:
+    suffix = Path(relative_path).suffix
+
+    if suffix == ".toml":
+        current_data = tomllib.loads(current.read_text())
+        other_data = tomllib.loads(other.read_text())
+        merged = _deep_merge(current_data, other_data)
+        current.write_bytes(tomli_w.dumps(merged).encode())
+    elif suffix in {".yml", ".yaml"}:
+        current_data = yaml.safe_load(current.read_text()) or {}
+        other_data = yaml.safe_load(other.read_text()) or {}
+        merged = _deep_merge(current_data, other_data)
+        current.write_text(yaml.dump(merged, default_flow_style=False))
+    elif suffix == ".json":
+        current_data = json.loads(current.read_text())
+        other_data = json.loads(other.read_text())
+        merged = _deep_merge(current_data, other_data)
+        current.write_text(json.dumps(merged, indent=2) + "\n")
+
+
+def _deep_merge(base: dict[str, Any], overlay: dict[str, Any]) -> dict[str, Any]:
+    result = dict(base)
+    for key, value in overlay.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _driver_prepend(ancestor: Path, current: Path, other: Path, relative_path: str) -> None:
+    current.write_text(other.read_text() + current.read_text())
+
+
+def _driver_union(ancestor: Path, current: Path, other: Path, relative_path: str) -> None:
+    current_lines = current.read_text().splitlines()
+    other_lines = other.read_text().splitlines()
+
+    seen = set(current_lines)
+    result = list(current_lines)
+    for line in other_lines:
+        if line not in seen:
+            result.append(line)
+            seen.add(line)
+
+    current.write_text("\n".join(result) + "\n" if result else "")

gr2/overlay/introspection.py

@@ -0,0 +1,155 @@
+"""Overlay introspection: stack, trace, why, impact, status queries."""
+
+from __future__ import annotations
+
+import subprocess
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from gr2.overlay.types import OverlayRef
+
+GRIP_DIR = ".grip"
+
+
+def overlay_stack(
+    workspace_root: Path,
+    overlay_store: Path,
+    json_output: bool,
+) -> str | dict[str, Any]:
+    stack_file = workspace_root / GRIP_DIR / "overlay-stack.toml"
+    data = _load_toml(stack_file)
+
+    active_refs = data.get("active", [])
+    available_refs = data.get("available", [])
+
+    active_entries = [_ref_entry(r) for r in active_refs]
+    available_entries = [_ref_entry(r) for r in available_refs]
+
+    if json_output:
+        return {"active": active_entries, "available": available_entries}
+
+    lines = ["Active overlays:"]
+    for entry in active_entries:
+        lines.append(f"  {entry['author']}/{entry['name']} ({entry['ref']})")
+    lines.append("Available overlays:")
+    for entry in available_entries:
+        lines.append(f"  {entry['author']}/{entry['name']} ({entry['ref']})")
+    return "\n".join(lines)
+
+
+def overlay_trace(
+    workspace_root: Path,
+    overlay_store: Path,
+    file_path: str,
+    json_output: bool,
+) -> str | dict[str, Any]:
+    attr_file = workspace_root / GRIP_DIR / "overlay-attribution.toml"
+    data = _load_toml(attr_file)
+
+    file_data = data.get("files", {}).get(file_path, {})
+    regions = file_data.get("lines", [])
+
+    if json_output:
+        return {"file": file_path, "regions": regions}
+
+    lines = [f"Trace for {file_path}:"]
+    for region in regions:
+        lines.append(f"  lines {region['start']}-{region['end']}: {region['ref']}")
+    return "\n".join(lines)
+
+
+def overlay_why(
+    workspace_root: Path,
+    overlay_store: Path,
+    file_path: str,
+    json_output: bool,
+) -> str | dict[str, Any]:
+    why_file = workspace_root / GRIP_DIR / "overlay-why.toml"
+    data = _load_toml(why_file)
+
+    file_data = data.get("files", {}).get(file_path, {})
+    rule = file_data.get("rule", "")
+    reason = file_data.get("reason", "")
+    ref = file_data.get("ref", "")
+
+    if json_output:
+        return {"rule": rule, "reason": reason, "ref": ref}
+
+    return f"{file_path}: rule={rule}, reason={reason} (ref={ref})"
+
+
+def overlay_impact(
+    overlay_store: Path,
+    overlay_ref: OverlayRef,
+    json_output: bool,
+) -> str | dict[str, Any]:
+    files = _read_overlay_file_list(overlay_store, overlay_ref)
+
+    if json_output:
+        return {"files": files}
+
+    lines = [f"Files touched by {overlay_ref.author}/{overlay_ref.name}:"]
+    for f in files:
+        lines.append(f"  {f}")
+    return "\n".join(lines)
+
+
+def overlay_status(
+    workspace_root: Path,
+    overlay_store: Path,
+    json_output: bool,
+) -> str | dict[str, Any]:
+    status_file = workspace_root / GRIP_DIR / "overlay-status.toml"
+    data = _load_toml(status_file)
+
+    active = data.get("active", [])
+    available = data.get("available", [])
+    applied = data.get("applied", [])
+
+    if json_output:
+        return {"active": active, "available": available, "applied": applied}
+
+    lines = [
+        "Active: " + ", ".join(active) if active else "Active: (none)",
+        "Available: " + ", ".join(available) if available else "Available: (none)",
+        "Applied: " + ", ".join(applied) if applied else "Applied: (none)",
+    ]
+    return "\n".join(lines)
+
+
+def _ref_entry(ref_path: str) -> dict[str, str]:
+    parts = ref_path.replace("refs/overlays/", "").split("/", 1)
+    author = parts[0] if parts else ""
+    name = parts[1] if len(parts) > 1 else ""
+    return {"ref": ref_path, "author": author, "name": name}
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    text = path.read_text()
+    if not text.strip():
+        return {}
+    return tomllib.loads(text)
+
+
+def _read_overlay_file_list(overlay_store: Path, overlay_ref: OverlayRef) -> list[str]:
+    tag_oid = _git_output(overlay_store, "rev-parse", overlay_ref.ref_path)
+    structured_tree_oid = _git_output(overlay_store, "rev-parse", f"{tag_oid}^{{tree}}")
+    wt_line = _git_output(overlay_store, "ls-tree", structured_tree_oid, "working_tree_tree")
+    working_tree_oid = wt_line.split()[2]
+    ls_output = _git_output(overlay_store, "ls-tree", "-r", "--name-only", working_tree_oid)
+    if not ls_output:
+        return []
+    return sorted(ls_output.splitlines())
+
+
+def _git_output(git_dir: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", f"--git-dir={git_dir}", *args],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip()

gr2/overlay/language_drivers.py

@@ -0,0 +1,115 @@
+"""AST-based language-aware merge drivers for overlay composition."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+class PythonCompositionConflict(Exception):
+    def __init__(self, symbol: str) -> None:
+        super().__init__(
+            f"Composition conflict: both base and overlay modify '{symbol}'"
+        )
+        self.error_code = "composition_conflict"
+        self.symbol = symbol
+
+
+def merge_python_overlay(
+    *,
+    ancestor: Path,
+    current: Path,
+    other: Path,
+    relative_path: str,
+) -> None:
+    if not relative_path.endswith(".py"):
+        raise ValueError("Python driver only supports .py paths")
+
+    ancestor_tree = ast.parse(ancestor.read_text())
+    current_tree = ast.parse(current.read_text())
+    other_tree = ast.parse(other.read_text())
+
+    ancestor_imports, ancestor_defs = _split_nodes(ancestor_tree)
+    current_imports, current_defs = _split_nodes(current_tree)
+    other_imports, other_defs = _split_nodes(other_tree)
+
+    merged_imports = _union_imports(current_imports, other_imports)
+    merged_defs = _merge_definitions(ancestor_defs, current_defs, other_defs)
+
+    merged_module = ast.Module(body=merged_imports + merged_defs, type_ignores=[])
+    ast.fix_missing_locations(merged_module)
+    current.write_text(ast.unparse(merged_module) + "\n")
+
+
+def _split_nodes(
+    tree: ast.Module,
+) -> tuple[list[ast.stmt], dict[str, ast.stmt]]:
+    imports: list[ast.stmt] = []
+    defs: dict[str, ast.stmt] = {}
+    for node in tree.body:
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            imports.append(node)
+        else:
+            name = _node_name(node)
+            if name:
+                defs[name] = node
+    return imports, defs
+
+
+def _node_name(node: ast.stmt) -> str | None:
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+        return node.name
+    if isinstance(node, ast.Assign):
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            return node.targets[0].id
+    if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+        return node.target.id
+    return None
+
+
+def _union_imports(
+    current: list[ast.stmt], other: list[ast.stmt]
+) -> list[ast.stmt]:
+    seen: set[str] = set()
+    result: list[ast.stmt] = []
+    for node in current + other:
+        key = ast.dump(node)
+        if key not in seen:
+            seen.add(key)
+            result.append(node)
+    return result
+
+
+def _merge_definitions(
+    ancestor: dict[str, ast.stmt],
+    current: dict[str, ast.stmt],
+    other: dict[str, ast.stmt],
+) -> list[ast.stmt]:
+    all_names = list(dict.fromkeys(list(current.keys()) + list(other.keys())))
+    result: list[ast.stmt] = []
+
+    for name in all_names:
+        a_node = ancestor.get(name)
+        c_node = current.get(name)
+        o_node = other.get(name)
+
+        a_dump = ast.dump(a_node) if a_node else None
+        c_dump = ast.dump(c_node) if c_node else None
+        o_dump = ast.dump(o_node) if o_node else None
+
+        current_changed = c_dump != a_dump
+        other_changed = o_dump != a_dump
+
+        if current_changed and other_changed and c_node and o_node:
+            if isinstance(o_node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                result.append(o_node)
+            else:
+                raise PythonCompositionConflict(name)
+        elif o_node and other_changed:
+            result.append(o_node)
+        elif c_node:
+            result.append(c_node)
+        elif o_node:
+            result.append(o_node)
+
+    return result