methodproof 0.7.37__tar.gz → 0.7.38__tar.gz

{methodproof-0.7.37 → methodproof-0.7.38}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.7.38] — 2026-04-12
+
+### Added
+- **Structural hunk capture on `file_edit` and `git_commit`** — watcher parses `@@ -old,count +new,count @@` headers from `git diff --unified=0` and `git show --format= --unified=0 <sha>` and emits them as `hunks: [{old_start, old_count, new_start, new_count}, ...]` on `file_edit` metadata and `file_hunks: {path: [hunks, ...]}` on `git_commit` metadata. Pure range data — no code content, no identifiers. Stays inside the structural-capture boundary alongside `lines_added` / `lines_removed`.
+- **Journal-mode hunk content** — when `code_capture` consent is on (Pro tier, journal mode), each hunk additionally carries a `lines: ["+foo", "-bar", ...]` field with the actual diff lines for that hunk, capped at 2000 lines per event. Gated by the same consent flag that gates the raw `diff` field.
+- **`base.is_content_captured()`** — public helper in `methodproof/agents/base.py` exposing the `code_capture` capture-flag check so agents can decide what content to include without reaching into private module state.
+
+### Why
+Enables the platform's post-processing pipeline to distinguish `SUPERSEDES` (later commit replaces 100% of an earlier commit's added lines on each shared path) from `EXTENSION_TO` (anything less — the default) without ever needing the raw diff content. See `methodproof` changelog v0.6.30.
+
 ## [0.7.37] — 2026-04-12
 
 ### Changed

{methodproof-0.7.37 → methodproof-0.7.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.7.37
+Version: 0.7.38
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE

{methodproof-0.7.37 → methodproof-0.7.38}/methodproof/agents/base.py

@@ -125,6 +125,13 @@ def log(level: str, event: str, **kw: object) -> None:
     sys.stderr.write(json.dumps(entry, default=str) + "\n")
 
 
+def is_content_captured() -> bool:
+    """True when code_capture consent is on (journal/Pro mode). Agents use this
+    to decide whether to include line-level diff content alongside structural
+    metadata."""
+    return bool(_capture.get("code_capture", False))
+
+
 def emit(event_type: str, metadata: dict[str, Any]) -> None:
     if not _initialized:
         log("warning", "emit.before_init", type=event_type)

{methodproof-0.7.37 → methodproof-0.7.38}/methodproof/agents/watcher.py

@@ -46,6 +46,99 @@ IGNORE_PATTERNS = re.compile(
 
 
 _MAX_DIFF_BYTES = 50_000
+_MAX_HUNK_LINES = 2_000
+
+_HUNK_HEADER_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+_DIFF_FILE_RE = re.compile(r"^diff --git a/(.+?) b/(.+?)$")
+
+
+def _parse_hunks(diff_text: str, include_lines: bool) -> list[dict[str, object]]:
+    """Parse unified diff text into structured hunks.
+
+    Each hunk: {old_start, old_count, new_start, new_count, [lines]}.
+    Lines are only included when `include_lines` is True (journal / code_capture).
+    """
+    hunks: list[dict[str, object]] = []
+    current: dict[str, object] | None = None
+    total_lines = 0
+    for line in diff_text.splitlines():
+        header = _HUNK_HEADER_RE.match(line)
+        if header:
+            if current is not None:
+                hunks.append(current)
+            current = {
+                "old_start": int(header.group(1)),
+                "old_count": int(header.group(2) or 1),
+                "new_start": int(header.group(3)),
+                "new_count": int(header.group(4) or 1),
+            }
+            if include_lines:
+                current["lines"] = []
+            continue
+        if current is None or not include_lines:
+            continue
+        if not (line.startswith("+") or line.startswith("-")):
+            continue
+        if line.startswith("+++") or line.startswith("---"):
+            continue
+        if total_lines >= _MAX_HUNK_LINES:
+            continue
+        current["lines"].append(line)  # type: ignore[union-attr]
+        total_lines += 1
+    if current is not None:
+        hunks.append(current)
+    return hunks
+
+
+def _parse_show_hunks(
+    show_text: str, include_lines: bool,
+) -> dict[str, list[dict[str, object]]]:
+    """Split `git show --unified=0` output by file and parse hunks per file."""
+    file_hunks: dict[str, list[dict[str, object]]] = {}
+    current_path: str | None = None
+    buffer: list[str] = []
+
+    def _flush() -> None:
+        if current_path and buffer:
+            file_hunks[current_path] = _parse_hunks("\n".join(buffer), include_lines)
+
+    for line in show_text.splitlines():
+        m = _DIFF_FILE_RE.match(line)
+        if m:
+            _flush()
+            current_path = m.group(2)
+            buffer = []
+            continue
+        if current_path is not None:
+            buffer.append(line)
+    _flush()
+    return file_hunks
+
+
+def _git_diff_hunks(repo: str, path: str, include_lines: bool) -> list[dict[str, object]]:
+    """Structured hunks for a pending file_edit. Ranges always; line content when allowed."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "diff", "--unified=0", "--", path],
+            capture_output=True, text=True, timeout=5,
+        )
+        return _parse_hunks(result.stdout[:_MAX_DIFF_BYTES], include_lines)
+    except Exception:
+        return []
+
+
+def _git_show_file_hunks(
+    repo: str, sha: str, include_lines: bool,
+) -> dict[str, list[dict[str, object]]]:
+    """Per-file structured hunks for a commit."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "show", "--format=", "--unified=0", sha],
+            capture_output=True, text=True, timeout=10,
+        )
+        return _parse_show_hunks(result.stdout[:_MAX_DIFF_BYTES * 4], include_lines)
+    except Exception:
+        return {}
 
 
 def _git_diff_stats(repo: str, path: str) -> tuple[int, int]:
@@ -125,10 +218,14 @@ class _Handler(FileSystemEventHandler):
 
         added, removed = _git_diff_stats(self._root, path)
         lang = Path(event.src_path).suffix.lstrip(".")
+        include_lines = base.is_content_captured()
+        hunks = _git_diff_hunks(self._root, path, include_lines)
         meta: dict[str, object] = {
             "path": path, "language": lang,
             "lines_added": added, "lines_removed": removed,
         }
+        if hunks:
+            meta["hunks"] = hunks
         diff = _git_diff_content(self._root, path)
         if diff:
             meta["diff"] = diff
@@ -192,6 +289,10 @@ def _log_commit(watch_dir: str, sha: str) -> None:
         meta["parent_hash"] = parent_hash
     if body and body != subject:
         meta["body"] = body[:2000]
+    include_lines = base.is_content_captured()
+    file_hunks = _git_show_file_hunks(watch_dir, sha, include_lines)
+    if file_hunks:
+        meta["file_hunks"] = file_hunks
     diff = _git_show_diff(watch_dir, sha)
     if diff:
         meta["diff"] = diff

methodproof-0.7.38/methodproof/hooks/gemini_hook.sh

@@ -0,0 +1,123 @@
+#!/bin/sh
+# MethodProof hook for Gemini CLI — captures prompts, tools, model calls, sessions.
+# Receives JSON on stdin. Posts to local bridge. Fails silently.
+# Must complete in <1s to avoid blocking Gemini.
+
+# Skip if no session is running (no pidfile = no daemon = no bridge)
+[ -f "${HOME}/.methodproof/methodproof.pid" ] || exit 0
+
+INPUT=$(cat)
+
+if command -v jq >/dev/null 2>&1; then
+  EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"' 2>/dev/null || echo "unknown")
+else
+  EVENT=$(echo "$INPUT" | grep -o '"hook_event_name":"[^"]*"' | head -1 | cut -d'"' -f4)
+  EVENT=${EVENT:-unknown}
+fi
+
+if date +%s.%N >/dev/null 2>&1 && [ "$(date +%N)" != "%N" ]; then
+  TS=$(date +%s.%N)
+else
+  TS=$(date +%s).000
+fi
+
+if command -v jq >/dev/null 2>&1; then
+  case "$EVENT" in
+    BeforeAgent)
+      TYPE="user_prompt"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        prompt_preview: (.prompt // "" | .[0:200]),
+        prompt_length: (.prompt // "" | length)
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    AfterAgent)
+      TYPE="agent_completion"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        prompt_preview: (.prompt // "" | .[0:200]),
+        response_preview: (.prompt_response // "" | .[0:200]),
+        response_length: (.prompt_response // "" | length)
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    BeforeTool)
+      TYPE="tool_call"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        tool_name: (.tool_name // "unknown"),
+        tool_input_preview: (.tool_input // {} | tostring | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    AfterTool)
+      TYPE="tool_result"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        tool_name: (.tool_name // "unknown"),
+        tool_input_preview: (.tool_input // {} | tostring | .[0:200]),
+        result_preview: (.tool_response // {} | tostring | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    BeforeModel)
+      TYPE="llm_prompt"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        model: "gemini"
+      }' 2>/dev/null || echo '{"tool":"gemini","model":"gemini"}')
+      ;;
+    AfterModel)
+      TYPE="llm_completion"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        model: "gemini"
+      }' 2>/dev/null || echo '{"tool":"gemini","model":"gemini"}')
+      ;;
+    SessionStart)
+      TYPE="gemini_session_start"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        gemini_session_id: (.session_id // ""),
+        cwd: (.cwd // ""),
+        source: (.source // "")
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    SessionEnd)
+      TYPE="gemini_session_end"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        gemini_session_id: (.session_id // ""),
+        reason: (.reason // "")
+      }' 2>/dev/null || echo '{"tool":"gemini"}')
+      ;;
+    PreCompress)
+      TYPE="context_compact_start"
+      META='{"tool":"gemini"}'
+      ;;
+    Notification)
+      TYPE="gemini_event"
+      META=$(echo "$INPUT" | jq -c '{
+        tool: "gemini",
+        event: "notification",
+        notification_type: (.notification_type // ""),
+        message: (.message // "" | .[0:200])
+      }' 2>/dev/null || echo '{"tool":"gemini","event":"notification"}')
+      ;;
+    *)
+      TYPE="gemini_event"
+      META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
+      ;;
+  esac
+else
+  TYPE="gemini_event"
+  META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
+fi
+
+PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}]}"
+RESPONSE=$(curl -s -w "\n%{http_code}" --max-time 1 --connect-timeout 0.5 \
+  -X POST http://localhost:9877/events \
+  -H "Content-Type: application/json" \
+  -d "$PAYLOAD" 2>/dev/null) || true
+HTTP_CODE=$(echo "$RESPONSE" | tail -1)
+if [ -n "$HTTP_CODE" ] && [ "$HTTP_CODE" != "200" ]; then
+  echo "{\"ts\":$TS,\"level\":\"warning\",\"event\":\"hook.post_failed\",\"http_code\":\"$HTTP_CODE\",\"type\":\"$TYPE\",\"payload\":$PAYLOAD}" \
+    >> "${HOME}/.methodproof/hook_errors.log" 2>/dev/null || true
+fi

{methodproof-0.7.37 → methodproof-0.7.38}/methodproof/hooks/install.py

@@ -48,7 +48,11 @@ _CODEX_EVENTS = ["PreToolUse", "PostToolUse", "UserPromptSubmit", "SessionStart"
 # --- Gemini CLI ---
 _GEMINI_DIR = Path.home() / ".gemini"
 _GEMINI_HOOK = _HOOKS_DIR / "gemini_hook.sh"
-_GEMINI_EVENTS = ["BeforeTool", "AfterTool", "SessionStart", "SessionEnd"]
+_GEMINI_EVENTS = [
+    "BeforeTool", "AfterTool", "BeforeAgent", "AfterAgent",
+    "BeforeModel", "AfterModel", "SessionStart", "SessionEnd",
+    "PreCompress", "Notification",
+]
 
 # --- Kiro ---
 _KIRO_DIR = Path.home() / ".kiro"

{methodproof-0.7.37 → methodproof-0.7.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.7.37"
+version = "0.7.38"
 description = "See how you code. Capture and visualize your engineering process."
 requires-python = ">=3.11"
 dependencies = ["watchdog>=4.0", "websocket-client>=1.7", "cryptography>=43.0", "keyring>=25.0", "textual>=0.59", "rich>=13.7"]

methodproof-0.7.37/methodproof/hooks/gemini_hook.sh

@@ -1,58 +0,0 @@
-#!/bin/sh
-# MethodProof hook for Gemini CLI — captures tool calls and sessions.
-# Receives JSON on stdin. Posts to local bridge. Fails silently.
-# Must complete in <1s to avoid blocking Gemini.
-
-INPUT=$(cat)
-
-if command -v jq >/dev/null 2>&1; then
-  EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"' 2>/dev/null || echo "unknown")
-else
-  EVENT=$(echo "$INPUT" | grep -o '"hook_event_name":"[^"]*"' | head -1 | cut -d'"' -f4)
-  EVENT=${EVENT:-unknown}
-fi
-
-if date +%s.%N >/dev/null 2>&1 && [ "$(date +%N)" != "%N" ]; then
-  TS=$(date +%s.%N)
-else
-  TS=$(date +%s).000
-fi
-
-if command -v jq >/dev/null 2>&1; then
-  case "$EVENT" in
-    BeforeTool)
-      TYPE="tool_call"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    AfterTool)
-      TYPE="tool_result"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", tool_name: (.tool_name // "unknown")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    SessionStart)
-      TYPE="gemini_session_start"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", cwd: (.cwd // "")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    SessionEnd)
-      TYPE="gemini_session_end"
-      META=$(echo "$INPUT" | jq -c '{tool: "gemini", reason: (.reason // "")}' 2>/dev/null || echo '{"tool":"gemini"}')
-      ;;
-    *)
-      TYPE="gemini_event"
-      META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
-      ;;
-  esac
-else
-  TYPE="gemini_event"
-  META="{\"tool\":\"gemini\",\"event\":\"$EVENT\"}"
-fi
-
-PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}]}"
-RESPONSE=$(curl -s -w "\n%{http_code}" --max-time 1 --connect-timeout 0.5 \
-  -X POST http://localhost:9877/events \
-  -H "Content-Type: application/json" \
-  -d "$PAYLOAD" 2>/dev/null) || true
-HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-if [ -n "$HTTP_CODE" ] && [ "$HTTP_CODE" != "200" ]; then
-  echo "{\"ts\":$TS,\"level\":\"warning\",\"event\":\"hook.post_failed\",\"http_code\":\"$HTTP_CODE\",\"type\":\"$TYPE\",\"payload\":$PAYLOAD}" \
-    >> "${HOME}/.methodproof/hook_errors.log" 2>/dev/null || true
-fi