prizmkit 1.1.124 → 1.1.125

package/bundled/skills/prizmkit-code-review/scripts/workspace_snapshot.py

@@ -1,222 +0,0 @@
-#!/usr/bin/env python3
-"""Generate a deterministic, path-safe workspace manifest for code review."""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-SNAPSHOT_PROTOCOL_VERSION = 1
-
-
-class SnapshotError(RuntimeError):
-    """Raised when the workspace snapshot cannot be generated safely."""
-
-
-def _git(root: Path, *args: str) -> bytes:
-    try:
-        return subprocess.check_output(
-            ["git", "-c", "core.quotepath=false", *args],
-            cwd=root,
-            stderr=subprocess.PIPE,
-        )
-    except (OSError, subprocess.CalledProcessError) as error:
-        detail = getattr(error, "stderr", b"").decode("utf-8", "replace").strip()
-        raise SnapshotError(detail or f"git {' '.join(args)} failed") from error
-
-
-def _decode(value: bytes) -> str:
-    return value.decode("utf-8", "surrogateescape")
-
-
-def _sha256_bytes(value: bytes) -> str:
-    return hashlib.sha256(value).hexdigest()
-
-
-def _file_identity(root: Path, relative_path: str) -> dict[str, Any] | None:
-    path = root / relative_path
-    if not path.is_symlink() and not path.is_file():
-        return None
-    if path.is_symlink():
-        content = os.readlink(path).encode("utf-8", "surrogateescape")
-        kind = "symlink"
-    else:
-        content = path.read_bytes()
-        kind = "file"
-    return {"kind": kind, "sha256": _sha256_bytes(content), "size": len(content)}
-
-
-def _index_identity(root: Path, relative_path: str) -> str | None:
-    try:
-        return _decode(_git(root, "rev-parse", f":{relative_path}")).strip()
-    except SnapshotError:
-        return None
-
-
-def _baseline_identity(root: Path, relative_path: str) -> str | None:
-    try:
-        return _decode(_git(root, "rev-parse", f"HEAD:{relative_path}")).strip()
-    except SnapshotError:
-        return None
-
-
-def _parse_name_status(raw: bytes, layer: str, root: Path) -> list[dict[str, Any]]:
-    fields = raw.rstrip(b"\0").split(b"\0") if raw else []
-    entries: list[dict[str, Any]] = []
-    index = 0
-    while index < len(fields):
-        status = _decode(fields[index])
-        index += 1
-        code = status[:1]
-        if code in {"R", "C"}:
-            if index + 1 >= len(fields):
-                raise SnapshotError("malformed rename or copy record")
-            source = _decode(fields[index])
-            destination = _decode(fields[index + 1])
-            index += 2
-            entry = {
-                "layer": layer,
-                "status": code,
-                "similarity": status[1:] or None,
-                "source_path": source,
-                "path": destination,
-            }
-        else:
-            if index >= len(fields):
-                raise SnapshotError("malformed name-status record")
-            path = _decode(fields[index])
-            index += 1
-            entry = {"layer": layer, "status": code, "path": path}
-
-        entry["worktree_content"] = _file_identity(root, entry["path"])
-        baseline_path = entry.get("source_path", entry["path"])
-        entry["baseline_blob"] = _baseline_identity(root, baseline_path)
-        if layer == "staged" and code != "D":
-            entry["index_blob"] = _index_identity(root, entry["path"])
-        entries.append(entry)
-
-    return entries
-
-
-def _untracked_entries(root: Path) -> list[dict[str, Any]]:
-    raw = _git(root, "ls-files", "--others", "--exclude-standard", "-z")
-    paths = [_decode(field) for field in raw.rstrip(b"\0").split(b"\0") if field]
-    return [
-        {
-            "layer": "untracked",
-            "status": "A",
-            "path": path,
-            "worktree_content": _file_identity(root, path),
-            "baseline_blob": None,
-        }
-        for path in paths
-    ]
-
-
-def _repository_identity(root: Path) -> str:
-    try:
-        remote = _decode(_git(root, "config", "--get", "remote.origin.url")).strip()
-    except SnapshotError:
-        remote = ""
-    return remote or root.name
-
-
-def _supporting_context(root: Path, paths: list[str]) -> list[dict[str, Any]]:
-    records: list[dict[str, Any]] = []
-    for relative_path in sorted(set(paths)):
-        candidate = (root / relative_path).resolve()
-        try:
-            candidate.relative_to(root)
-        except ValueError as error:
-            raise SnapshotError(
-                f"supporting context escapes repository: {relative_path}"
-            ) from error
-        identity = _file_identity(root, relative_path)
-        if identity is None:
-            raise SnapshotError(f"supporting context is not a file: {relative_path}")
-        records.append({"path": relative_path, "content": identity})
-    return records
-
-
-def build_manifest(root: Path, supporting_paths: list[str] | None = None) -> dict[str, Any]:
-    """Return a deterministic manifest for the repository's current logical change."""
-    repository_root = Path(
-        _decode(_git(root, "rev-parse", "--show-toplevel")).strip()
-    ).resolve()
-    baseline = _decode(_git(repository_root, "rev-parse", "HEAD")).strip()
-
-    entries = [
-        *_parse_name_status(
-            _git(repository_root, "diff", "--cached", "--name-status", "-z", "-M"),
-            "staged",
-            repository_root,
-        ),
-        *_parse_name_status(
-            _git(repository_root, "diff", "--name-status", "-z", "-M"),
-            "unstaged",
-            repository_root,
-        ),
-        *_untracked_entries(repository_root),
-    ]
-    entries.sort(
-        key=lambda entry: (
-            entry["path"],
-            entry["layer"],
-            entry.get("source_path", ""),
-        )
-    )
-
-    manifest: dict[str, Any] = {
-        "protocol_version": SNAPSHOT_PROTOCOL_VERSION,
-        "repository_identity": _repository_identity(repository_root),
-        "baseline_identity": baseline,
-        "changes": entries,
-        "supporting_context": _supporting_context(
-            repository_root, supporting_paths or []
-        ),
-    }
-    canonical = json.dumps(
-        manifest,
-        ensure_ascii=True,
-        separators=(",", ":"),
-        sort_keys=True,
-    ).encode("utf-8")
-    manifest["snapshot_identity"] = _sha256_bytes(canonical)
-    return manifest
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--root", default=".", help="path inside the Git repository")
-    parser.add_argument(
-        "--supporting-context",
-        action="append",
-        default=[],
-        metavar="PATH",
-        help="unchanged repository-relative file required for review; repeat as needed",
-    )
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    try:
-        manifest = build_manifest(
-            Path(args.root).resolve(), args.supporting_context
-        )
-    except SnapshotError as error:
-        print(json.dumps({"error": str(error)}, sort_keys=True))
-        return 1
-
-    print(json.dumps(manifest, ensure_ascii=True, indent=2, sort_keys=True))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())