methodproof 0.7.26__tar.gz → 0.7.28__tar.gz

{methodproof-0.7.26 → methodproof-0.7.28}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.7.28] — 2026-04-12
+
+### Added
+- **`cwd` in terminal events** — shell hook (bash/zsh/PowerShell) now writes working directory to `commands.jsonl`; terminal agent reads it into `terminal_cmd` metadata. Requires re-running `mp init` to update the installed hook.
+- **Git commit enrichment** — `git_commit` events now include `author`, `author_email`, `committed_at` (ISO 8601), `parent_hash`, and `body` (full commit message body when it differs from subject). Single `git log` call instead of multiple.
+- **`language` on `file_delete`** — was always empty string; now extracted from file extension same as `file_create`.
+- **`skipped` count in `test_run`** — pytest, jest, and go test output now parsed for skipped test count.
+
+### Fixed
+- **`agent_complete.last_message_preview` not journal-gated** — preview of agent's final message leaked content when journal mode was off. Now stripped with other content fields.
+- **`git_commit.body` not journal-gated** — full commit body (multi-line messages) added to journal gate.
+
+## [0.7.27] — 2026-04-12
+
+### Fixed
+- **`result_preview` was Python repr for structured tool responses** — `str([{"type": "text", "text": "..."}])` produced unreadable output for Read/Grep/Glob tools. `_extract_result_text` now handles all three shapes Claude Code sends: plain string (Bash/Write/Edit), content block list (Read/Grep/Glob), and dict.
+
 ## [0.7.26] — 2026-04-12
 
 ### Fixed

{methodproof-0.7.26 → methodproof-0.7.28}/PKG-INFO

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

{methodproof-0.7.26 → methodproof-0.7.28}/methodproof/agents/terminal.py

@@ -22,8 +22,8 @@ TEST_FRAMEWORKS = {
     "cargo_test": re.compile(r"\bcargo test\b"),
 }
 
-_PYTEST_RE = re.compile(r"(\d+) passed(?:.*?(\d+) failed)?")
-_JEST_RE = re.compile(r"Tests:\s+(?:(\d+) failed,\s+)?(\d+) passed")
+_PYTEST_RE = re.compile(r"(\d+) passed(?:.*?(\d+) failed)?(?:.*?(\d+) skipped)?")
+_JEST_RE = re.compile(r"Tests:\s+(?:(\d+) failed,\s+)?(\d+) passed(?:,\s+(\d+) skipped)?")
 _CARGO_RE = re.compile(r"(\d+) passed.*?(\d+) failed")
 
 
@@ -34,26 +34,25 @@ def _detect_test(command: str) -> str | None:
     return None
 
 
-def _parse_test_results(output: str, framework: str, exit_code: int) -> tuple[int, int]:
-    """Extract pass/fail counts from test output. Falls back to exit code heuristic."""
+def _parse_test_results(output: str, framework: str, exit_code: int) -> tuple[int, int, int]:
+    """Extract pass/fail/skipped counts from test output. Falls back to exit code heuristic."""
     if framework == "pytest":
         m = _PYTEST_RE.search(output)
         if m:
-            return int(m.group(1)), int(m.group(2) or 0)
+            return int(m.group(1)), int(m.group(2) or 0), int(m.group(3) or 0)
     elif framework == "jest":
         m = _JEST_RE.search(output)
         if m:
-            return int(m.group(2) or 0), int(m.group(1) or 0)
+            return int(m.group(2) or 0), int(m.group(1) or 0), int(m.group(3) or 0)
     elif framework == "go_test":
-        return output.count("--- PASS"), output.count("--- FAIL")
+        return output.count("--- PASS"), output.count("--- FAIL"), output.count("--- SKIP")
     elif framework == "cargo_test":
         m = _CARGO_RE.search(output)
         if m:
-            return int(m.group(1)), int(m.group(2))
-    # Fallback: exit code 0 = all passed, non-zero = at least 1 failure
+            return int(m.group(1)), int(m.group(2)), 0
     if exit_code == 0:
-        return 1, 0
-    return 0, 1
+        return 1, 0, 0
+    return 0, 1, 0
 
 
 def start(stop: threading.Event) -> None:
@@ -93,19 +92,22 @@ def _process(line: str) -> None:
     exit_code = entry.get("exit_code", 0)
     duration = entry.get("duration_ms", 0)
     output = entry.get("output", "")[:500]
-    # Redact output if it contains secrets
     if SENSITIVE.search(output):
         output = "[redacted — contains sensitive content]"
+    cwd = entry.get("cwd", "")
 
-    base.emit("terminal_cmd", {
+    meta: dict = {
         "command": command, "exit_code": exit_code,
         "output_snippet": output, "duration_ms": duration,
-    })
+    }
+    if cwd:
+        meta["cwd"] = cwd
+    base.emit("terminal_cmd", meta)
 
     framework = _detect_test(command)
     if framework:
-        passed, failed = _parse_test_results(output, framework, exit_code)
+        passed, failed, skipped = _parse_test_results(output, framework, exit_code)
         base.emit("test_run", {
             "framework": framework, "passed": passed, "failed": failed,
-            "duration_ms": duration,
+            "skipped": skipped, "duration_ms": duration,
         })

{methodproof-0.7.26 → methodproof-0.7.28}/methodproof/agents/watcher.py

@@ -139,7 +139,8 @@ class _Handler(FileSystemEventHandler):
             return
         path = self._relpath(event.src_path)
         self._hashes.pop(path, None)
-        base.emit("file_delete", {"path": path})
+        lang = Path(event.src_path).suffix.lstrip(".")
+        base.emit("file_delete", {"path": path, "language": lang})
 
 
 def _poll_git(watch_dir: str, stop: threading.Event) -> None:
@@ -164,17 +165,33 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
 
 def _log_commit(watch_dir: str, sha: str) -> None:
     try:
-        msg = subprocess.run(
-            ["git", "-C", watch_dir, "log", "-1", "--format=%s", sha],
+        # Single git call: subject\x00author\x00email\x00iso_date\x00parent_hash\x00full_body
+        fmt = subprocess.run(
+            ["git", "-C", watch_dir, "log", "-1",
+             "--format=%s%x00%an%x00%ae%x00%ai%x00%P%x00%B", sha],
             capture_output=True, text=True, timeout=5,
-        ).stdout.strip()
+        ).stdout
+        parts = fmt.split("\x00", 5)
+        subject = parts[0].strip() if len(parts) > 0 else ""
+        author = parts[1].strip() if len(parts) > 1 else ""
+        author_email = parts[2].strip() if len(parts) > 2 else ""
+        committed_at = parts[3].strip() if len(parts) > 3 else ""
+        parent_hash = parts[4].strip()[:7] if len(parts) > 4 else ""
+        body = parts[5].strip() if len(parts) > 5 else ""
         files = subprocess.run(
             ["git", "-C", watch_dir, "diff-tree", "--no-commit-id", "-r", "--name-only", sha],
             capture_output=True, text=True, timeout=5,
         ).stdout.strip().splitlines()
     except Exception:
-        msg, files = "", []
-    meta: dict[str, object] = {"hash": sha[:7], "message": msg, "files_changed": files}
+        subject, author, author_email, committed_at, parent_hash, body, files = "", "", "", "", "", "", []
+    meta: dict[str, object] = {
+        "hash": sha[:7], "message": subject, "files_changed": files,
+        "author": author, "author_email": author_email, "committed_at": committed_at,
+    }
+    if parent_hash:
+        meta["parent_hash"] = parent_hash
+    if body and body != subject:
+        meta["body"] = body[:2000]
     diff = _git_show_diff(watch_dir, sha)
     if diff:
         meta["diff"] = diff

{methodproof-0.7.26 → methodproof-0.7.28}/methodproof/config.py

@@ -118,6 +118,9 @@ JOURNAL_CONTENT_FIELDS: list[tuple[str, str]] = [
     ("user_prompt", "prompt_text"),
     ("tool_call", "tool_input_preview"),
     ("tool_result", "result_preview"),
+    # Agent final message and commit body reveal content
+    ("agent_complete", "last_message_preview"),
+    ("git_commit", "body"),
 ]
 
 

{methodproof-0.7.26 → methodproof-0.7.28}/methodproof/hook.py

@@ -10,10 +10,11 @@ _BASH = '''
 # methodproof-hook
 _mp_pre() { _MP_CMD="$BASH_COMMAND"; _MP_T=$SECONDS; }
 _mp_post() {
-  local ec=$? cmd="$_MP_CMD" dur=$(( (SECONDS - ${_MP_T:-$SECONDS}) * 1000 ))
+  local ec=$? cmd="$_MP_CMD" dur=$(( (SECONDS - ${_MP_T:-$SECONDS}) * 1000 )) cwd
   [ -z "$cmd" ] && return
   cmd="${cmd//\\\\/\\\\\\\\}"; cmd="${cmd//\\"/\\\\\\"}"
-  echo "{\\"command\\":\\"$cmd\\",\\"exit_code\\":$ec,\\"duration_ms\\":$dur}" >> ~/.methodproof/commands.jsonl
+  cwd="$(pwd)"; cwd="${cwd//\\\\/\\\\\\\\}"; cwd="${cwd//\\"/\\\\\\"}"
+  echo "{\\"command\\":\\"$cmd\\",\\"exit_code\\":$ec,\\"duration_ms\\":$dur,\\"cwd\\":\\"$cwd\\"}" >> ~/.methodproof/commands.jsonl
   unset _MP_CMD
 }
 trap '_mp_pre' DEBUG
@@ -24,10 +25,11 @@ _ZSH = '''
 # methodproof-hook
 _mp_pre() { _MP_CMD="$1"; _MP_T=$SECONDS; }
 _mp_post() {
-  local ec=$? cmd="$_MP_CMD" dur=$(( (SECONDS - ${_MP_T:-$SECONDS}) * 1000 ))
+  local ec=$? cmd="$_MP_CMD" dur=$(( (SECONDS - ${_MP_T:-$SECONDS}) * 1000 )) cwd
   [[ -z "$cmd" ]] && return
   cmd="${cmd//\\\\/\\\\\\\\}"; cmd="${cmd//\\"/\\\\\\"}"
-  echo "{\\"command\\":\\"$cmd\\",\\"exit_code\\":$ec,\\"duration_ms\\":$dur}" >> ~/.methodproof/commands.jsonl
+  cwd="$(pwd)"; cwd="${cwd//\\\\/\\\\\\\\}"; cwd="${cwd//\\"/\\\\\\"}"
+  echo "{\\"command\\":\\"$cmd\\",\\"exit_code\\":$ec,\\"duration_ms\\":$dur,\\"cwd\\":\\"$cwd\\"}" >> ~/.methodproof/commands.jsonl
   unset _MP_CMD
 }
 autoload -Uz add-zsh-hook
@@ -52,7 +54,8 @@ function prompt {
     if ($global:_mpCmd) {
         $dur = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds() - $global:_mpT
         $cmd = $global:_mpCmd -replace '\\\\','\\\\\\\\' -replace '"','\\"'
-        $line = "{`"command`":`"$cmd`",`"exit_code`":$ec,`"duration_ms`":$dur}"
+        $cwd = (Get-Location).Path -replace '\\\\','\\\\\\\\' -replace '"','\\"'
+        $line = "{`"command`":`"$cmd`",`"exit_code`":$ec,`"duration_ms`":$dur,`"cwd`":`"$cwd`"}"
         $logPath = Join-Path $HOME ".methodproof" "commands.jsonl"
         Add-Content -Path $logPath -Value $line
         $global:_mpCmd = $null

{methodproof-0.7.26 → methodproof-0.7.28}/methodproof/hooks/claude_code.py

@@ -16,6 +16,28 @@ except ImportError:
     analyze_prompt = lambda _: {}
     compose_summary = lambda _: ""
 
+def _extract_result_text(response) -> str:
+    """Extract plain text from tool_response regardless of shape.
+
+    Claude Code sends:
+    - str  — Bash, Write, Edit, simple tools
+    - list — Read, Grep, Glob: [{"type": "text", "text": "..."}]
+    - dict — rare structured responses
+    """
+    if isinstance(response, str):
+        return response[:500]
+    if isinstance(response, list):
+        parts = [
+            block.get("text", "") if isinstance(block, dict) else str(block)
+            for block in response
+            if not isinstance(block, dict) or block.get("type") == "text"
+        ]
+        return "\n".join(parts)[:500]
+    if isinstance(response, dict):
+        return response.get("text") or response.get("content") or json.dumps(response)[:500]
+    return str(response)[:500]
+
+
 def _build_prompt_meta(text: str) -> dict:
     sa = analyze_prompt(text)
     sa["prompt_length"] = len(text)
@@ -81,7 +103,7 @@ _META_EXTRACTORS = {
     },
     "PostToolUse": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True,
-        "result_preview": str(d.get("tool_response") or "")[:500],
+        "result_preview": _extract_result_text(d.get("tool_response")),
     },
     "PostToolUseFailure": lambda d: {
         "tool": _TOOL, "tool_name": d.get("tool_name", "unknown"),

{methodproof-0.7.26 → methodproof-0.7.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.7.26"
+version = "0.7.28"
 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"]