gitvow 0.7.0__tar.gz → 0.7.1__tar.gz

{gitvow-0.7.0/src/gitvow.egg-info → gitvow-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.0
+Version: 0.7.1
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.7.0 → gitvow-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.7.0"
+version = "0.7.1"
 description = "Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies."
 readme = "README.md"
 license = {text = "Apache-2.0"}

gitvow-0.7.1/src/gitvow/transcript.py

@@ -0,0 +1,187 @@
+"""Structural, redacted summary of an agent transcript (Claude Code JSONL). Tool output is never read."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterable
+from typing import Any
+
+from .redact import redact
+
+
+def _detect(first: dict[str, Any]) -> str:
+    """Which agent wrote this transcript: claude (default), codex (rollout records), gemini (chat recording)."""
+    t = first.get("type")
+    if t in ("session_meta", "response_item", "event_msg", "turn_context", "compacted") and "payload" in first:
+        return "codex"
+    if "sessionId" in first and "projectHash" in first:
+        return "gemini"
+    if first.get("type") in ("user", "gemini", "info", "error") and "content" in first and "message" not in first:
+        return "gemini"
+    return "claude"
+
+
+def _text_of(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for c in content:
+            if isinstance(c, dict):
+                if c.get("type") in ("text", "output_text", "input_text") and c.get("text"):
+                    parts.append(str(c["text"]))
+                elif "text" in c and isinstance(c["text"], str):
+                    parts.append(c["text"])
+            elif isinstance(c, str):
+                parts.append(c)
+        return "\n".join(parts)
+    return ""
+
+
+def _patch_files(text: str) -> list[str]:
+    import re
+
+    return re.findall(r"^\*\*\* (?:Update|Add|Delete) File: (.+)$", text or "", re.M)
+
+
+def _codex_tool(name: str, arguments: Any) -> tuple[str, str, list[str]]:
+    """Codex function names -> (gitvow tool, brief argument, files written)."""
+    args: dict[str, Any] = {}
+    if isinstance(arguments, str):
+        try:
+            args = json.loads(arguments) if arguments.strip().startswith("{") else {"input": arguments}
+        except json.JSONDecodeError:
+            args = {"input": arguments}
+    elif isinstance(arguments, dict):
+        args = arguments
+    if name in ("exec_command", "shell", "container.exec", "local_shell"):
+        cmd = args.get("cmd") or args.get("command") or ""
+        cmd = " ".join(cmd) if isinstance(cmd, list) else str(cmd)
+        return "Bash", cmd, []
+    if name == "apply_patch":
+        patch = str(args.get("input") or args.get("patch") or args.get("command") or "")
+        files = _patch_files(patch)
+        return "Edit", files[0] if files else "apply_patch", files
+    return name, json.dumps(args)[:160] if args else "", []
+
+
+def _gemini_tool(name: str, args: Any) -> tuple[str, str, list[str]]:
+    a = args if isinstance(args, dict) else {}
+    if name == "run_shell_command":
+        return "Bash", str(a.get("command") or ""), []
+    if name in ("write_file", "replace", "edit"):
+        fp = str(a.get("file_path") or a.get("path") or "")
+        return ("Write" if name == "write_file" else "Edit"), fp, [fp] if fp else []
+    return name, json.dumps(a)[:160] if a else "", []
+
+
+def summarize(path: str | None, max_tools: int = 500, rules: Iterable[tuple[str, str]] = ()) -> dict[str, Any]:
+    """Structural summary of a transcript. Reads Claude Code, Codex and Gemini CLI formats; tool output is never read."""
+    out: dict[str, Any] = {
+        "turns": 0,
+        "tool_calls": [],
+        "last_assistant_text": "",
+        "files_written": [],
+        "format": "claude",
+    }
+    if not path or not os.path.exists(path):
+        return out
+    rules = list(rules)
+    written: set[str] = set()
+    fmt: str | None = None
+    with open(path, errors="ignore") as fh:
+        for line in fh:
+            try:
+                ev = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(ev, dict):
+                continue
+            if fmt is None:
+                fmt = _detect(ev)
+                out["format"] = fmt
+            if fmt == "codex":
+                _codex_event(ev, out, written, rules, max_tools)
+            elif fmt == "gemini":
+                _gemini_event(ev, out, written, rules, max_tools)
+            else:
+                _claude_event(ev, out, written, rules, max_tools)
+    out["files_written"] = sorted(written)
+    return out
+
+
+def _add_tool(out: dict[str, Any], tool: str, brief: str, rules: list[tuple[str, str]], max_tools: int) -> None:
+    if len(out["tool_calls"]) < max_tools:
+        out["tool_calls"].append({"tool": tool, "arg": redact(str(brief), rules)[:160]})
+
+
+def _claude_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    msg = ev.get("message") or {}
+    role = msg.get("role") or ev.get("type")
+    content = msg.get("content")
+    if role != "assistant":
+        return
+    out["turns"] += 1
+    if isinstance(content, str):
+        if content.strip():
+            out["last_assistant_text"] = redact(content, rules)[:600]
+        return
+    if not isinstance(content, list):
+        return
+    for c in content:
+        if not isinstance(c, dict):
+            continue
+        if c.get("type") == "tool_use":
+            inp = c.get("input") or {}
+            brief = inp.get("command") or inp.get("file_path") or inp.get("query") or inp.get("pattern") or ""
+            _add_tool(out, str(c.get("name")), brief, rules, max_tools)
+            if c.get("name") in ("Edit", "Write", "MultiEdit", "NotebookEdit") and inp.get("file_path"):
+                written.add(str(inp["file_path"]))
+        elif c.get("type") == "text" and str(c.get("text", "")).strip():
+            out["last_assistant_text"] = redact(c["text"], rules)[:600]
+
+
+def _codex_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    t, p = ev.get("type"), ev.get("payload") or {}
+    if not isinstance(p, dict):
+        return
+    if t == "response_item":
+        pt = p.get("type")
+        if pt == "message" and p.get("role") == "assistant":
+            out["turns"] += 1
+            text = _text_of(p.get("content"))
+            if text.strip():
+                out["last_assistant_text"] = redact(text, rules)[:600]
+        elif pt in ("function_call", "custom_tool_call", "local_shell_call"):
+            name = str(p.get("name") or ("local_shell" if pt == "local_shell_call" else ""))
+            arguments = p.get("arguments") if pt == "function_call" else (p.get("input") or p.get("action") or "")
+            tool, brief, files = _codex_tool(name, arguments)
+            _add_tool(out, tool, brief, rules, max_tools)
+            written.update(files)
+    elif t == "event_msg":
+        pt = p.get("type")
+        if pt == "agent_message" and p.get("message"):
+            out["turns"] += 1
+            out["last_assistant_text"] = redact(str(p["message"]), rules)[:600]
+
+
+def _gemini_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    if ev.get("type") != "gemini":
+        return
+    out["turns"] += 1
+    text = _text_of(ev.get("content"))
+    if text.strip():
+        out["last_assistant_text"] = redact(text, rules)[:600]
+    for tc in ev.get("toolCalls") or []:
+        if not isinstance(tc, dict):
+            continue
+        tool, brief, files = _gemini_tool(str(tc.get("name") or ""), tc.get("args"))
+        _add_tool(out, tool, brief, rules, max_tools)
+        written.update(files)

{gitvow-0.7.0 → gitvow-0.7.1/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.0
+Version: 0.7.1
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.7.0 → gitvow-0.7.1}/src/gitvow.egg-info/SOURCES.txt

@@ -34,4 +34,5 @@ tests/test_providers.py
 tests/test_recall.py
 tests/test_redact.py
 tests/test_report.py
-tests/test_snapshots.py
+tests/test_snapshots.py
+tests/test_transcript_formats.py

gitvow-0.7.1/tests/test_transcript_formats.py

@@ -0,0 +1,128 @@
+import json
+
+from gitvow.transcript import summarize
+
+CODEX = [
+    {
+        "timestamp": "t",
+        "type": "session_meta",
+        "payload": {"id": "abc", "cwd": "/r", "cli_version": "0.130.0", "git": {"branch": "main"}},
+    },
+    {"timestamp": "t", "type": "turn_context", "payload": {"cwd": "/r", "model": "gpt-5"}},
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "fix add"}]},
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "message",
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "output_text",
+                    "text": "I will fix add() in calc.py; token ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 stays out.",
+                }
+            ],
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "function_call",
+            "name": "exec_command",
+            "arguments": json.dumps({"cmd": ["git", "status"]}),
+            "call_id": "c1",
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {"type": "function_call_output", "call_id": "c1", "output": "clean SECRET=hunter2 (never read)"},
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "custom_tool_call",
+            "name": "apply_patch",
+            "input": "*** Begin Patch\n*** Update File: calc.py\n-    return a - b\n+    return a + b\n*** End Patch\n",
+            "call_id": "c2",
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "event_msg",
+        "payload": {"type": "agent_message", "message": "Done: fixed add() in calc.py."},
+    },
+    {
+        "timestamp": "t",
+        "type": "event_msg",
+        "payload": {"type": "token_count", "info": {"total_token_usage": {"input_tokens": 10}}},
+    },
+]
+
+GEMINI = [
+    {"sessionId": "g1", "projectHash": "h", "startTime": "t", "lastUpdated": "t", "kind": "main"},
+    {"id": "m1", "timestamp": "t", "type": "user", "content": "fix add"},
+    {
+        "id": "m2",
+        "timestamp": "t",
+        "type": "gemini",
+        "content": [{"text": "Fixing add() in calc.py now."}],
+        "model": "gemini-2.5-pro",
+        "toolCalls": [
+            {"id": "t1", "name": "run_shell_command", "args": {"command": "git status"}, "status": "success"},
+            {
+                "id": "t2",
+                "name": "replace",
+                "args": {"file_path": "/r/calc.py", "old_string": "a - b", "new_string": "a + b"},
+                "status": "success",
+            },
+            {"id": "t3", "name": "write_file", "args": {"file_path": "/r/new.py", "content": "x"}, "status": "success"},
+        ],
+    },
+    {"$set": {"lastUpdated": "t2"}},
+    {"id": "m3", "timestamp": "t", "type": "gemini", "content": "All done in calc.py and new.py."},
+]
+
+
+def _write(tmp_path, name, rows):
+    p = tmp_path / name
+    p.write_text("\n".join(json.dumps(r) for r in rows) + "\n")
+    return str(p)
+
+
+def test_codex_rollout_is_read(tmp_path):
+    s = summarize(_write(tmp_path, "rollout.jsonl", CODEX))
+    assert s["format"] == "codex" and s["turns"] == 2
+    assert [t["tool"] for t in s["tool_calls"]] == ["Bash", "Edit"]
+    assert s["tool_calls"][0]["arg"] == "git status" and s["tool_calls"][1]["arg"] == "calc.py"
+    assert s["files_written"] == ["calc.py"]
+    assert s["last_assistant_text"] == "Done: fixed add() in calc.py."
+    assert "hunter2" not in json.dumps(s)  # tool output is never read
+
+
+def test_gemini_chat_recording_is_read(tmp_path):
+    s = summarize(_write(tmp_path, "session-1.jsonl", GEMINI))
+    assert s["format"] == "gemini" and s["turns"] == 2
+    assert [t["tool"] for t in s["tool_calls"]] == ["Bash", "Edit", "Write"]
+    assert sorted(s["files_written"]) == ["/r/calc.py", "/r/new.py"]
+    assert s["last_assistant_text"] == "All done in calc.py and new.py."
+
+
+def test_claude_format_still_default(transcript):
+    s = summarize(transcript)
+    assert (
+        s["format"] == "claude"
+        and s["tool_calls"][0]["tool"] == "Bash"
+        and "[github-token]" in s["last_assistant_text"]
+    )
+
+
+def test_redaction_applies_to_all_formats(tmp_path):
+    s = summarize(_write(tmp_path, "rollout.jsonl", CODEX[:4]))
+    assert "[github-token]" in s["last_assistant_text"] and "ghp_" not in s["last_assistant_text"]

gitvow-0.7.0/src/gitvow/transcript.py

@@ -1,49 +0,0 @@
-"""Structural, redacted summary of an agent transcript (Claude Code JSONL). Tool output is never read."""
-
-from __future__ import annotations
-
-import json
-import os
-from collections.abc import Iterable
-from typing import Any
-
-from .redact import redact
-
-
-def summarize(path: str | None, max_tools: int = 500, rules: Iterable[tuple[str, str]] = ()) -> dict[str, Any]:
-    out: dict[str, Any] = {"turns": 0, "tool_calls": [], "last_assistant_text": "", "files_written": []}
-    if not path or not os.path.exists(path):
-        return out
-    written: set[str] = set()
-    rules = list(rules)
-    with open(path, errors="ignore") as fh:
-        for line in fh:
-            try:
-                ev = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            msg = ev.get("message") or {}
-            role = msg.get("role") or ev.get("type")
-            content = msg.get("content")
-            if role != "assistant":
-                continue
-            out["turns"] += 1
-            if isinstance(content, str):
-                if content.strip():
-                    out["last_assistant_text"] = redact(content, rules)[:600]
-                continue
-            if not isinstance(content, list):
-                continue
-            for c in content:
-                if not isinstance(c, dict):
-                    continue
-                if c.get("type") == "tool_use" and len(out["tool_calls"]) < max_tools:
-                    inp = c.get("input") or {}
-                    brief = inp.get("command") or inp.get("file_path") or inp.get("query") or inp.get("pattern") or ""
-                    out["tool_calls"].append({"tool": c.get("name"), "arg": redact(str(brief), rules)[:160]})
-                    if c.get("name") in ("Edit", "Write", "MultiEdit", "NotebookEdit") and inp.get("file_path"):
-                        written.add(str(inp["file_path"]))
-                elif c.get("type") == "text" and str(c.get("text", "")).strip():
-                    out["last_assistant_text"] = redact(c["text"], rules)[:600]
-    out["files_written"] = sorted(written)
-    return out