methodproof 0.8.1__tar.gz → 0.8.3__tar.gz

{methodproof-0.8.1 → methodproof-0.8.3}/PKG-INFO

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

{methodproof-0.8.1 → methodproof-0.8.3}/methodproof/graph.py

@@ -36,20 +36,19 @@ def build(session_id: str) -> dict[str, int]:
     db.execute(
         "DELETE FROM causal_links WHERE source_id IN "
         "(SELECT id FROM events WHERE session_id = ?)", (session_id,))
-    stats["causal"] += _link(db, session_id, "llm_prompt", "llm_completion",
-                              "RECEIVED", 60, match_model=True)
-    stats["causal"] += _link(db, session_id, "llm_completion", "file_edit",
-                              "INFORMED", 60)
-    stats["causal"] += _link(db, session_id, "web_search", "web_visit",
-                              "LED_TO", 120)
-    stats["causal"] += _link(db, session_id, "browser_search", "browser_visit",
-                              "LED_TO", 120)
+    stats["causal"] += _link_nearest(db, session_id, "llm_prompt",
+                                      "llm_completion", "RECEIVED", "model")
+    stats["causal"] += _link_until_next(db, session_id, "llm_completion",
+                                         "file_edit", "INFORMED")
+    stats["causal"] += _link_until_next(db, session_id, "web_search",
+                                         "web_visit", "LED_TO")
+    stats["causal"] += _link_until_next(db, session_id, "browser_search",
+                                         "browser_visit", "LED_TO")
     stats["causal"] += _link_pasted(db, session_id)
-    # Agent causal links (OpenClaw / agent gateways)
-    stats["causal"] += _link(db, session_id, "agent_prompt", "agent_completion",
-                              "RECEIVED", 120, match_model=True)
-    stats["causal"] += _link(db, session_id, "agent_completion", "file_edit",
-                              "INFORMED", 60)
+    stats["causal"] += _link_nearest(db, session_id, "agent_prompt",
+                                      "agent_completion", "RECEIVED", "model")
+    stats["causal"] += _link_until_next(db, session_id, "agent_completion",
+                                         "file_edit", "INFORMED")
 
     # Resources
     for e in events:
@@ -95,39 +94,87 @@ def build(session_id: str) -> dict[str, int]:
     return stats
 
 
-def _link(
+def _link_nearest(
     db: object, sid: str, src_type: str, tgt_type: str,
-    rel: str, window_sec: int, match_model: bool = False,
+    rel: str, match_field: str | None = None,
 ) -> int:
-    model_clause = (
-        "AND json_extract(mp_json(s.metadata), '$.model') = json_extract(mp_json(t.metadata), '$.model')"
-        if match_model else ""
-    )
-    sql = f"""
-    INSERT OR IGNORE INTO causal_links (source_id, target_id, type)
-    SELECT s.id, t.id, ?
-    FROM events s JOIN events t ON t.session_id = s.session_id
-    WHERE s.session_id = ? AND s.type = ? AND t.type = ?
-      AND t.timestamp > s.timestamp
-      AND (t.timestamp - s.timestamp) <= ?
-      {model_clause}
-    """
-    return db.execute(sql, (rel, sid, src_type, tgt_type, window_sec)).rowcount
+    """1:1 nearest-neighbor pairing. No time window."""
+    rows = db.execute(
+        "SELECT id, type, timestamp, metadata FROM events "
+        "WHERE session_id = ? AND type IN (?, ?) ORDER BY timestamp",
+        (sid, src_type, tgt_type),
+    ).fetchall()
+    claimed: set[str] = set()
+    pairs: list[tuple[str, str, str]] = []
+    for src in rows:
+        if src["type"] != src_type:
+            continue
+        src_val = _decompress_meta(src["metadata"]).get(match_field) if match_field else None
+        for tgt in rows:
+            if tgt["type"] != tgt_type or tgt["id"] in claimed or tgt["timestamp"] <= src["timestamp"]:
+                continue
+            if match_field and _decompress_meta(tgt["metadata"]).get(match_field) != src_val:
+                continue
+            pairs.append((src["id"], tgt["id"], rel))
+            claimed.add(tgt["id"])
+            break
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type) "
+            "VALUES (?, ?, ?)", pairs)
+    return len(pairs)
+
+
+def _link_until_next(
+    db: object, sid: str, src_type: str, tgt_type: str, rel: str,
+) -> int:
+    """Link source to all targets until the next source event."""
+    rows = db.execute(
+        "SELECT id, type FROM events "
+        "WHERE session_id = ? AND type IN (?, ?) ORDER BY timestamp",
+        (sid, src_type, tgt_type),
+    ).fetchall()
+    pairs: list[tuple[str, str, str]] = []
+    current_src: str | None = None
+    for ev in rows:
+        if ev["type"] == src_type:
+            current_src = ev["id"]
+        elif current_src:
+            pairs.append((current_src, ev["id"], rel))
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type) "
+            "VALUES (?, ?, ?)", pairs)
+    return len(pairs)
 
 
 def _link_pasted(db: object, sid: str) -> int:
-    """browser_copy → file_edit: ≤30s, content length within 20%."""
-    sql = """
-    INSERT OR IGNORE INTO causal_links (source_id, target_id, type, confidence)
-    SELECT s.id, t.id, 'PASTED_FROM', 0.7
-    FROM events s JOIN events t ON t.session_id = s.session_id
-    WHERE s.session_id = ? AND s.type = 'browser_copy' AND t.type = 'file_edit'
-      AND t.timestamp > s.timestamp AND (t.timestamp - s.timestamp) <= 30
-      AND abs(json_extract(mp_json(t.metadata), '$.lines_added') * 40.0
-            - json_extract(mp_json(s.metadata), '$.text_length'))
-          < json_extract(mp_json(s.metadata), '$.text_length') * 0.2
-    """
-    return db.execute(sql, (sid,)).rowcount
+    """browser_copy → nearest file_edit with content length within 20%."""
+    rows = db.execute(
+        "SELECT id, type, timestamp, metadata FROM events "
+        "WHERE session_id = ? AND type IN ('browser_copy', 'file_edit') "
+        "ORDER BY timestamp", (sid,),
+    ).fetchall()
+    claimed: set[str] = set()
+    pairs: list[tuple[str, str]] = []
+    for src in rows:
+        if src["type"] != "browser_copy":
+            continue
+        src_len = _decompress_meta(src["metadata"]).get("text_length", 0)
+        if not src_len:
+            continue
+        for tgt in rows:
+            if tgt["type"] != "file_edit" or tgt["id"] in claimed or tgt["timestamp"] <= src["timestamp"]:
+                continue
+            if abs(_decompress_meta(tgt["metadata"]).get("lines_added", 0) * 40 - src_len) < src_len * 0.2:
+                pairs.append((src["id"], tgt["id"]))
+                claimed.add(tgt["id"])
+                break
+    if pairs:
+        db.executemany(
+            "INSERT OR IGNORE INTO causal_links (source_id, target_id, type, confidence) "
+            "VALUES (?, ?, 'PASTED_FROM', 0.7)", pairs)
+    return len(pairs)
 
 
 def _link_action_resources(db: object, sid: str) -> None:

{methodproof-0.8.1 → methodproof-0.8.3}/methodproof/hooks/claude_code.py

@@ -76,6 +76,8 @@ _TYPE_MAP = {
     # Worktree
     "WorktreeCreate": "worktree_create",
     "WorktreeRemove": "worktree_remove",
+    # Notifications
+    "Notification": "notification",
 }
 
 _TOOL = "claude_code"
@@ -139,9 +141,33 @@ _META_EXTRACTORS = {
     "ElicitationResult": lambda d: {"tool": _TOOL},
     "WorktreeCreate": lambda d: {"tool": _TOOL, "worktree_path": d.get("worktree_path", "")},
     "WorktreeRemove": lambda d: {"tool": _TOOL, "worktree_path": d.get("worktree_path", "")},
+    "Notification": lambda d: {
+        "tool": _TOOL,
+        "title": d.get("title", ""),
+        "message": d.get("message", d.get("text", ""))[:1000],
+        "notification_type": d.get("type", d.get("notification_type", "")),
+    },
 }
 
 
+def _extract_recap(transcript_path: str) -> str | None:
+    """Grep transcript for the last ※ recap: line. Journal mode only."""
+    import pathlib
+    tp = pathlib.Path(transcript_path)
+    if not tp.exists():
+        return None
+    try:
+        text = tp.read_text(errors="replace")
+    except OSError:
+        return None
+    last_recap = None
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("※ recap:") or stripped.startswith("recap:"):
+            last_recap = stripped.removeprefix("※ ").removeprefix("recap:").strip()
+    return last_recap
+
+
 def main() -> None:
     try:
         data = json.load(sys.stdin)
@@ -154,7 +180,20 @@ def main() -> None:
     meta = extractor(data) if extractor else {"tool": _TOOL, "event": event}
     ts = time.time()
 
-    payload = json.dumps({"events": [{"type": etype, "timestamp": ts, "metadata": meta}]}).encode()
+    events_out = [{"type": etype, "timestamp": ts, "metadata": meta}]
+
+    # On Stop, grep transcript for recap (journal mode only)
+    transcript_path = data.get("transcript_path", "")
+    if event == "Stop" and transcript_path:
+        recap = _extract_recap(transcript_path)
+        if recap:
+            events_out.append({
+                "type": "context_recap",
+                "timestamp": ts,
+                "metadata": {"tool": _TOOL, "recap": recap[:2000]},
+            })
+
+    payload = json.dumps({"events": events_out}).encode()
     req = urllib.request.Request(
         "http://localhost:9877/events", data=payload,
         headers={"Content-Type": "application/json"}, method="POST",

{methodproof-0.8.1 → methodproof-0.8.3}/methodproof/hooks/claude_code.sh

@@ -125,6 +125,15 @@ if command -v jq >/dev/null 2>&1; then
     Stop)
       TYPE="agent_turn_end"
       META='{"tool":"claude_code"}'
+      # Extract recap from transcript if available (journal mode)
+      TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null)
+      if [ -n "$TRANSCRIPT" ] && [ -f "$TRANSCRIPT" ]; then
+        RECAP=$(grep -E '※ recap:|^recap:' "$TRANSCRIPT" | tail -1 | sed 's/^.*※ recap: *//;s/^recap: *//' | head -c 2000)
+        if [ -n "$RECAP" ]; then
+          RECAP_ESCAPED=$(echo "$RECAP" | jq -Rs '.' 2>/dev/null || echo '""')
+          RECAP_EVENT=",{\"type\":\"context_recap\",\"timestamp\":$TS,\"metadata\":{\"tool\":\"claude_code\",\"recap\":$RECAP_ESCAPED}}"
+        fi
+      fi
       ;;
     StopFailure)
       TYPE="agent_turn_error"
@@ -162,6 +171,10 @@ if command -v jq >/dev/null 2>&1; then
       TYPE=$(echo "$EVENT" | sed 's/Elicitation$/mcp_elicitation/;s/ElicitationResult/mcp_elicitation_result/')
       META='{"tool":"claude_code"}'
       ;;
+    Notification)
+      TYPE="notification"
+      META=$(echo "$INPUT" | jq -c '{tool: "claude_code", title: (.title // ""), message: ((.message // .text // "")[:1000]), notification_type: (.type // .notification_type // "")}' 2>/dev/null || echo '{"tool":"claude_code"}')
+      ;;
     *)
       TYPE="claude_code_event"
       META="{\"event\":\"$EVENT\"}"
@@ -174,7 +187,7 @@ else
 fi
 
 # Post to bridge with strict 1-second timeout (never block Claude Code)
-PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}]}"
+PAYLOAD="{\"events\":[{\"type\":\"$TYPE\",\"timestamp\":$TS,\"metadata\":$META}${RECAP_EVENT:-}]}"
 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" \

{methodproof-0.8.1 → methodproof-0.8.3}/methodproof/hooks/install.py

@@ -38,6 +38,7 @@ HOOK_EVENTS = [
     "ElicitationResult",         # user responded to MCP
     "WorktreeCreate",            # git worktree created (parallel agent)
     "WorktreeRemove",            # git worktree removed
+    "Notification",              # system notifications (recap, compaction summary, etc.)
 ]
 
 # --- Codex CLI ---

{methodproof-0.8.1 → methodproof-0.8.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.8.1"
+version = "0.8.3"
 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", "sqlcipher3>=0.6"]

{methodproof-0.8.1 → methodproof-0.8.3}/tests/test_graph.py

@@ -93,15 +93,16 @@ def test_led_to_link() -> None:
     assert db.execute("SELECT count(*) FROM causal_links WHERE type='LED_TO'").fetchone()[0] == 1
 
 
-def test_no_link_outside_window() -> None:
-    """completion → edit >60s apart → no INFORMED."""
+def test_informed_bounded_by_next_completion() -> None:
+    """Edit after a second completion links only to the second."""
     sid = _session([
         _event("llm_completion", 100, {"model": "claude"}),
-        _event("file_edit", 200, {"path": "a.py"}),  # 100s gap
+        _event("llm_completion", 200, {"model": "claude"}),
+        _event("file_edit", 250, {"path": "a.py"}),
     ])
     graph.build(sid)
     db = store._db()
-    assert db.execute("SELECT count(*) FROM causal_links WHERE type='INFORMED'").fetchone()[0] == 0
+    assert db.execute("SELECT count(*) FROM causal_links WHERE type='INFORMED'").fetchone()[0] == 1
 
 
 def test_resource_creation() -> None:

methodproof-0.8.1/.code-review-graph/.gitignore

@@ -1,3 +0,0 @@
-# Auto-generated by code-review-graph — do not commit database files.
-# The graph.db contains absolute paths and code structure metadata.
-*