methodproof 0.8.3__tar.gz → 0.8.5__tar.gz

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.8.3
+Version: 0.8.5
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: cryptography>=43.0
+Requires-Python: >=3.12
+Requires-Dist: cryptography>=46.0.7
 Requires-Dist: keyring>=25.0
 Requires-Dist: rich>=13.7
 Requires-Dist: sqlcipher3>=0.6
@@ -13,7 +13,7 @@ Requires-Dist: textual>=0.59
 Requires-Dist: watchdog>=4.0
 Requires-Dist: websocket-client>=1.7
 Provides-Extra: proxy
-Requires-Dist: mitmproxy>=10.0; extra == 'proxy'
+Requires-Dist: mitmproxy>=12.2.2; extra == 'proxy'
 Description-Content-Type: text/markdown
 
 <p align="center">

{methodproof-0.8.3 → methodproof-0.8.5}/methodproof/__init__.py

@@ -1,3 +1,3 @@
 """MethodProof — see how you code."""
 
-__version__ = "0.8.1"
+__version__ = "0.8.2"

{methodproof-0.8.3 → methodproof-0.8.5}/methodproof/agents/watcher.py

@@ -40,8 +40,15 @@ IGNORE_PATTERNS = re.compile(
     r"|\.build/|DerivedData/|Pods/"
     # Build output / artifacts
     r"|dist/|build/|\.output/"
-    # Logs and locks
-    r"|\.lock$|\.log$)"
+    # Logs and locks — runtime log output, never engineering source.
+    # ``/logs/`` excludes any file under a ``logs/`` directory regardless
+    # of extension. The prior ``\.log$`` check was too narrow — session
+    # 8c21 had 15,269 file_edit events captured on
+    # ``methodproof-platform/logs/methodproof-platform.jsonl`` (the
+    # platform's own runtime log, NOT ``.log`` extension) which polluted
+    # both the thread and step distributions. Any project with a
+    # ``logs/`` subdirectory for runtime output inherits the exclusion.
+    r"|/logs/|\.lock$|\.log$)"
 )
 
 

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

@@ -16,6 +16,22 @@ except ImportError:
     analyze_prompt = lambda _: {}
     compose_summary = lambda _: ""
 
+try:
+    from methodproof.hooks import model_cache
+except ImportError:
+    model_cache = None  # type: ignore[assignment]
+
+
+def _current_model(session_id: str) -> str | None:
+    """Return the most recently-seen model for this Claude session, from
+    the per-session cache. None if cache unavailable or no prior update."""
+    if model_cache is None or not session_id:
+        return None
+    try:
+        return model_cache.get_model(session_id)
+    except Exception:
+        return None
+
 def _extract_result_text(response) -> str:
     """Extract plain text from tool_response regardless of shape.
 
@@ -92,25 +108,34 @@ def _tool_input_preview(d: dict) -> str:
     return json.dumps(inp)[:300] if inp else ""
 
 
+def _with_model(meta: dict, d: dict) -> dict:
+    """Attach the session's currently-cached model to a metadata dict.
+    No-op when session_id is missing or cache has no entry."""
+    model = _current_model(d.get("session_id") or "")
+    if model:
+        meta["model"] = model
+    return meta
+
+
 _META_EXTRACTORS = {
-    "UserPromptSubmit": lambda d: {
+    "UserPromptSubmit": lambda d: _with_model({
         "tool": _TOOL,
         "prompt_text": d.get("prompt") or "",
         "prompt_preview": _build_prompt_meta(d.get("prompt") or "").get("prompt_summary", ""),
         "prompt_length": len(d.get("prompt") or ""),
-    },
-    "PreToolUse": lambda d: {
+    }, d),
+    "PreToolUse": lambda d: _with_model({
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
         "tool_input": d.get("tool_input") or {},
         "tool_input_preview": _tool_input_preview(d),
-    },
-    "PostToolUse": lambda d: {
+    }, d),
+    "PostToolUse": lambda d: _with_model({
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True,
         "tool_input": d.get("tool_input") or {},
         "tool_response": d.get("tool_response") or {},
         "tool_input_preview": _tool_input_preview(d),
         "result_preview": _extract_result_text(d.get("tool_response")),
-    },
+    }, d),
     "PostToolUseFailure": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),
         "success": False, "is_interrupt": d.get("is_interrupt", False),
@@ -124,9 +149,9 @@ _META_EXTRACTORS = {
     },
     "TaskCreated": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", ""), "subject": d.get("task_subject", "")},
     "TaskCompleted": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", "")},
-    "SessionStart": lambda d: {"tool": _TOOL, "session_id": d.get("session_id", ""), "cwd": d.get("cwd", "")},
+    "SessionStart": lambda d: _with_model({"tool": _TOOL, "session_id": d.get("session_id", ""), "cwd": d.get("cwd", "")}, d),
     "SessionEnd": lambda d: {"tool": _TOOL, "session_id": d.get("session_id", "")},
-    "Stop": lambda d: {"tool": _TOOL},
+    "Stop": lambda d: _with_model({"tool": _TOOL}, d),
     "StopFailure": lambda d: {"tool": _TOOL, "error": d.get("error", "")},
     "CwdChanged": lambda d: {
         "tool": _TOOL, "cwd": d.get("cwd", ""),
@@ -175,6 +200,24 @@ def main() -> None:
         return
 
     event = data.get("hook_event_name", "unknown")
+    session_id = data.get("session_id") or ""
+    transcript_path = data.get("transcript_path", "")
+
+    # Refresh the per-session model cache before running the metadata extractor
+    # so `_with_model` sees the freshest value. We include PreToolUse because
+    # the first turn's UserPromptSubmit fires before any assistant message is
+    # in the transcript — without a PreToolUse refresh, every tool event in
+    # that first turn lands with no `model` attribution. PostToolUse is left
+    # out: once PreToolUse has refreshed, the cache is warm for the rest of
+    # the turn, and PostToolUse would duplicate the transcript read.
+    if model_cache is not None and transcript_path and session_id and event in (
+        "UserPromptSubmit", "SessionStart", "Stop", "PreToolUse",
+    ):
+        try:
+            model_cache.update_from_transcript(session_id, transcript_path)
+        except Exception:
+            pass  # Cache is best-effort; hook must never raise.
+
     etype = _TYPE_MAP.get(event, "claude_code_event")
     extractor = _META_EXTRACTORS.get(event)
     meta = extractor(data) if extractor else {"tool": _TOOL, "event": event}
@@ -183,7 +226,6 @@ def main() -> None:
     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:
@@ -193,6 +235,13 @@ def main() -> None:
                 "metadata": {"tool": _TOOL, "recap": recap[:2000]},
             })
 
+    # Clean up the cache entry on session end so the file stays bounded.
+    if model_cache is not None and event == "SessionEnd" and session_id:
+        try:
+            model_cache.clear_session(session_id)
+        except Exception:
+            pass
+
     payload = json.dumps({"events": events_out}).encode()
     req = urllib.request.Request(
         "http://localhost:9877/events", data=payload,

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

@@ -8,6 +8,39 @@
 
 INPUT=$(cat)
 
+# Model cache: per-Claude-session model attribution.
+# The transcript JSONL is the only place Claude Code surfaces the active
+# model. Re-reading it on every PreToolUse is too expensive, so we refresh
+# a cache at the cheap once-per-turn waypoints (SessionStart / Stop — and
+# UserPromptSubmit which delegates to the Python hook that updates it too)
+# and read it via a cheap jq lookup on tool events.
+_MP_MODEL_CACHE="${HOME}/.methodproof/hook_state/models.json"
+
+# Read the current model for a session. Fast path — no Python subprocess.
+_mp_read_model() {
+  local sess="$1"
+  [ -z "$sess" ] || [ ! -f "$_MP_MODEL_CACHE" ] && return
+  command -v jq >/dev/null 2>&1 || return
+  jq -r --arg s "$sess" '.[$s].model // empty' "$_MP_MODEL_CACHE" 2>/dev/null
+}
+
+# Refresh the cache by shelling out to the Python module (handles JSON
+# safely + atomic write). Rare — called on SessionStart / Stop only.
+_mp_update_model() {
+  local sess="$1" transcript="$2"
+  [ -z "$sess" ] || [ -z "$transcript" ] && return
+  command -v python3 >/dev/null 2>&1 || return
+  python3 -m methodproof.hooks.model_cache update "$sess" "$transcript" \
+    >/dev/null 2>&1 || true
+}
+
+_mp_clear_model() {
+  local sess="$1"
+  [ -z "$sess" ] && return
+  command -v python3 >/dev/null 2>&1 || return
+  python3 -m methodproof.hooks.model_cache clear "$sess" >/dev/null 2>&1 || true
+}
+
 if command -v jq >/dev/null 2>&1; then
   EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "unknown"' 2>/dev/null || echo "unknown")
 else
@@ -25,6 +58,24 @@ fi
 
 # Build event JSON — use jq if available, else minimal Python
 if command -v jq >/dev/null 2>&1; then
+  # Pull session + transcript once — cache ops + model attribution use both.
+  SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // ""' 2>/dev/null)
+  TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript_path // ""' 2>/dev/null)
+
+  # Refresh model cache at once-per-turn waypoints. Cheap tool events
+  # (PreToolUse / PostToolUse) read the cache without touching the
+  # transcript.
+  case "$EVENT" in
+    SessionStart|Stop)
+      _mp_update_model "$SESSION_ID" "$TRANSCRIPT"
+      ;;
+    SessionEnd)
+      _mp_clear_model "$SESSION_ID"
+      ;;
+  esac
+
+  MP_MODEL=$(_mp_read_model "$SESSION_ID")
+
   case "$EVENT" in
     UserPromptSubmit)
       # Delegate to Python for structural analysis (shell can't do regex classification)
@@ -37,9 +88,10 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     PreToolUse)
       TYPE="tool_call"
-      META=$(echo "$INPUT" | jq -c '{
+      META=$(echo "$INPUT" | jq -c --arg model "$MP_MODEL" '{
         tool: (.tool_name // "unknown"),
         tool_use_id: (.tool_use_id // ""),
+        model: (if $model == "" then null else $model end),
         tool_input: (.tool_input // {}),
         tool_input_preview: (
           (.tool_input // {}) as $ti |
@@ -58,10 +110,11 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     PostToolUse)
       TYPE="tool_result"
-      META=$(echo "$INPUT" | jq -c '{
+      META=$(echo "$INPUT" | jq -c --arg model "$MP_MODEL" '{
         tool: (.tool_name // "unknown"),
         tool_use_id: (.tool_use_id // ""),
         success: true,
+        model: (if $model == "" then null else $model end),
         tool_input: (.tool_input // {}),
         tool_response: (.tool_response // {}),
         tool_input_preview: (
@@ -112,7 +165,11 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     SessionStart)
       TYPE="claude_session_start"
-      META=$(echo "$INPUT" | jq -c '{claude_session_id: (.session_id // ""), cwd: (.cwd // "")}' 2>/dev/null || echo '{}')
+      META=$(echo "$INPUT" | jq -c --arg model "$MP_MODEL" '{
+        claude_session_id: (.session_id // ""),
+        cwd: (.cwd // ""),
+        model: (if $model == "" then null else $model end)
+      }' 2>/dev/null || echo '{}')
       ;;
     PostToolUseFailure)
       TYPE="tool_failure"
@@ -124,7 +181,11 @@ if command -v jq >/dev/null 2>&1; then
       ;;
     Stop)
       TYPE="agent_turn_end"
-      META='{"tool":"claude_code"}'
+      if [ -n "$MP_MODEL" ]; then
+        META="{\"tool\":\"claude_code\",\"model\":\"$MP_MODEL\"}"
+      else
+        META='{"tool":"claude_code"}'
+      fi
       # 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

methodproof-0.8.5/methodproof/hooks/model_cache.py

@@ -0,0 +1,164 @@
+"""Per-session model cache for Claude Code capture.
+
+Claude Code doesn't pass the active model in every hook payload — only the
+transcript JSONL carries it. Re-reading the transcript on every PreToolUse
+would add tens of ms to each hook invocation. This module keeps a tiny
+JSON cache at ``~/.methodproof/hook_state/models.json`` mapping Claude
+session_id → (model, updated_at), refreshed once per turn at the cheap
+waypoints (``SessionStart``, ``UserPromptSubmit``, ``Stop``) and read
+cheaply on every tool event.
+
+Atomic writes via ``tempfile.NamedTemporaryFile`` + ``os.replace`` so
+concurrent hook invocations never corrupt the file.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import tempfile
+import time
+
+
+CACHE_PATH = pathlib.Path.home() / ".methodproof" / "hook_state" / "models.json"
+# How far back to scan a transcript for the last assistant message's model.
+# Transcripts are JSONL append-only, so tail is all we need. 200 lines covers
+# a typical turn plus headroom; we're not trying to reconstruct history.
+_TAIL_BYTES = 64 * 1024
+
+
+def _load() -> dict:
+    try:
+        with CACHE_PATH.open("r") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save(data: dict) -> None:
+    CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    # Atomic write — write to a tmp file in the same dir, rename over.
+    with tempfile.NamedTemporaryFile(
+        mode="w", dir=str(CACHE_PATH.parent), delete=False, suffix=".json",
+    ) as tmp:
+        json.dump(data, tmp)
+        tmp_path = tmp.name
+    os.replace(tmp_path, CACHE_PATH)
+
+
+def _extract_last_model(transcript_path: str) -> str | None:
+    """Read the tail of a transcript JSONL and return the most recent
+    ``model`` field from an assistant message. ``None`` if the transcript
+    is missing, unreadable, or contains no model annotation.
+    """
+    path = pathlib.Path(transcript_path)
+    if not path.is_file():
+        return None
+    try:
+        size = path.stat().st_size
+        with path.open("rb") as f:
+            if size > _TAIL_BYTES:
+                f.seek(size - _TAIL_BYTES)
+                # Drop partial first line after a seek
+                f.readline()
+            blob = f.read().decode("utf-8", errors="replace")
+    except OSError:
+        return None
+
+    last_model: str | None = None
+    for line in blob.splitlines():
+        line = line.strip()
+        if not line or not line.startswith("{"):
+            continue
+        try:
+            rec = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(rec, dict):
+            continue
+        # Claude Code transcript shape: top-level "model" on assistant messages.
+        model = rec.get("model")
+        if isinstance(model, str) and model:
+            last_model = model
+    return last_model
+
+
+def update_from_transcript(session_id: str, transcript_path: str) -> str | None:
+    """Read the transcript tail, extract the most recent model, and persist
+    it in the cache keyed by ``session_id``. Returns the model string (or
+    ``None`` if extraction failed — cache untouched in that case).
+    """
+    if not session_id or not transcript_path:
+        return None
+    model = _extract_last_model(transcript_path)
+    if model is None:
+        return None
+    try:
+        data = _load()
+        data[session_id] = {"model": model, "updated_at": time.time()}
+        _save(data)
+    except OSError:
+        # Cache is best-effort. A write failure must not break the hook.
+        return model
+    return model
+
+
+def get_model(session_id: str) -> str | None:
+    """Return the cached model for ``session_id``, or ``None`` if no cache
+    entry exists. Never raises — the cache is best-effort."""
+    if not session_id:
+        return None
+    try:
+        data = _load()
+    except OSError:
+        return None
+    entry = data.get(session_id)
+    if not isinstance(entry, dict):
+        return None
+    model = entry.get("model")
+    return model if isinstance(model, str) and model else None
+
+
+def clear_session(session_id: str) -> None:
+    """Remove a session's cache entry. Called on ``SessionEnd`` so cache
+    size stays bounded over time."""
+    if not session_id:
+        return
+    try:
+        data = _load()
+        if session_id in data:
+            del data[session_id]
+            _save(data)
+    except OSError:
+        return
+
+
+# CLI entry so the shell hook can do `python3 -m methodproof.hooks.model_cache ...`
+# on rare events (SessionStart / Stop / SessionEnd). The hot read path in shell
+# uses jq directly on the cache file — no Python subprocess needed.
+def _main() -> int:
+    import sys
+    args = sys.argv[1:]
+    if len(args) < 1:
+        return 1
+    cmd = args[0]
+    if cmd == "update" and len(args) == 3:
+        model = update_from_transcript(args[1], args[2])
+        if model:
+            print(model)
+        return 0
+    if cmd == "get" and len(args) == 2:
+        model = get_model(args[1])
+        if model:
+            print(model)
+        return 0
+    if cmd == "clear" and len(args) == 2:
+        clear_session(args[1])
+        return 0
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())

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

@@ -1,17 +1,17 @@
 [project]
 name = "methodproof"
-version = "0.8.3"
+version = "0.8.5"
 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"]
+requires-python = ">=3.12"
+dependencies = ["watchdog>=4.0", "websocket-client>=1.7", "cryptography>=46.0.7", "keyring>=25.0", "textual>=0.59", "rich>=13.7", "sqlcipher3>=0.6"]
 license = "Apache-2.0"
 readme = "README.md"
 
 [project.optional-dependencies]
-proxy = ["mitmproxy>=10.0"]
+proxy = ["mitmproxy>=12.2.2"]
 
 [dependency-groups]
-dev = ["pytest>=8.0", "pytest-cov>=5.0"]
+dev = ["pytest>=9.0.3", "pytest-cov>=5.0"]
 
 [project.scripts]
 methodproof = "methodproof.cli:main"