methodproof 0.1.1__py3-none-any.whl

methodproof/__init__.py

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

methodproof/__main__.py

@@ -0,0 +1,4 @@
+"""Allow `python -m methodproof`."""
+from methodproof.cli import main
+
+main()

methodproof/agents/base.py

@@ -0,0 +1,136 @@
+"""Shared telemetry primitives — one log, one emit, one flush."""
+
+import json
+import sys
+import threading
+import time
+import uuid
+from typing import Any
+
+from methodproof import store
+
+_session_id = ""
+_initialized = False
+_e2e_key: bytes | None = None
+_capture: dict[str, bool] = {}
+_live_mode = False
+_lock = threading.Lock()
+_buffer: list[dict[str, Any]] = []
+_FLUSH_SIZE = 50
+_MAX_RETRIES = 3
+_prev_hash = "genesis"
+
+# Maps event types to the capture category that gates them
+_EVENT_GATES: dict[str, str] = {
+    "terminal_cmd": "terminal_commands",
+    "test_run": "test_results",
+    "file_create": "file_changes",
+    "file_edit": "file_changes",
+    "file_delete": "file_changes",
+    "git_commit": "git_commits",
+    "llm_prompt": "ai_prompts",
+    "agent_prompt": "ai_prompts",
+    "llm_completion": "ai_responses",
+    "agent_completion": "ai_responses",
+    "agent_tool_dispatch": "ai_responses",
+    "agent_tool_result": "ai_responses",
+    "agent_skill_invoke": "ai_responses",
+    "agent_session_event": "ai_responses",
+    "inline_completion_shown": "ai_responses",
+    "inline_completion_accepted": "ai_responses",
+    "inline_completion_rejected": "ai_responses",
+    "browser_visit": "browser",
+    "browser_search": "browser",
+    "browser_tab_switch": "browser",
+    "browser_copy": "browser",
+    "browser_ai_chat": "browser",
+    "music_playing": "music",
+}
+
+# Maps capture categories to (event_type, field) pairs for field-level gating.
+# When the category is disabled, these fields are stripped from emitted events.
+# When enabled (code_capture), these fields are populated by the agent.
+_FIELD_GATES: dict[str, list[tuple[str, str]]] = {
+    "command_output": [("terminal_cmd", "output_snippet")],
+    "code_capture": [("file_edit", "diff"), ("git_commit", "diff")],
+}
+
+
+def init(session_id: str, live: bool = False) -> None:
+    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash
+    _session_id = session_id
+    _initialized = True
+    _live_mode = live
+    _prev_hash = "genesis"
+    from methodproof import config
+    cfg = config.load()
+    raw = cfg.get("e2e_key", "")
+    _e2e_key = bytes.fromhex(raw) if raw else None
+    _capture = cfg.get("capture", {})
+
+
+def log(level: str, event: str, **kw: object) -> None:
+    entry = {"ts": time.time(), "level": level, "event": event, "sid": _session_id, **kw}
+    sys.stderr.write(json.dumps(entry, default=str) + "\n")
+
+
+def emit(event_type: str, metadata: dict[str, Any]) -> None:
+    if not _initialized:
+        log("warning", "emit.before_init", type=event_type)
+        return
+    # Event-level consent gate
+    gate = _EVENT_GATES.get(event_type)
+    if gate and not _capture.get(gate, True):
+        return
+    # Field-level consent gate — strip opted-out fields
+    for category, pairs in _FIELD_GATES.items():
+        for etype, field in pairs:
+            if event_type == etype and not _capture.get(category, True):
+                metadata.pop(field, None)
+
+    entry = {
+        "id": uuid.uuid4().hex,
+        "session_id": _session_id,
+        "type": event_type,
+        "timestamp": time.time(),
+        "duration_ms": metadata.pop("duration_ms", 0),
+        "metadata": metadata,
+    }
+    if _e2e_key:
+        from methodproof.crypto import encrypt_metadata
+        entry["metadata"] = encrypt_metadata(dict(entry["metadata"]), _e2e_key)
+    global _prev_hash
+    from methodproof.integrity import compute_event_hash
+    entry["_chain_hash"] = compute_event_hash(entry, _prev_hash)
+    _prev_hash = entry["_chain_hash"]
+    if _live_mode:
+        from methodproof import live as live_mod
+        live_mod.send(entry)
+    with _lock:
+        _buffer.append(entry)
+        if len(_buffer) >= _FLUSH_SIZE:
+            _flush_locked()
+
+
+def flush() -> None:
+    with _lock:
+        _flush_locked()
+
+
+def _flush_locked() -> None:
+    if not _buffer:
+        return
+    batch = list(_buffer)
+    hashes = [(e["id"], e.pop("_chain_hash")) for e in batch if "_chain_hash" in e]
+    for attempt in range(_MAX_RETRIES):
+        try:
+            store.insert_events(_session_id, batch)
+            if hashes:
+                store.insert_event_hashes(hashes)
+            _buffer.clear()
+            return
+        except Exception as exc:
+            log("warning", "flush.retry", attempt=attempt + 1, error=str(exc))
+            time.sleep(0.1 * (attempt + 1))
+    # Final attempt failed — keep events in buffer for next flush cycle
+    log("error", "flush.failed", count=len(batch), retries=_MAX_RETRIES)

methodproof/agents/music.py

@@ -0,0 +1,105 @@
+"""OS-level Now Playing detection — polls Spotify / Music.app / MPRIS."""
+
+import platform
+import subprocess
+import threading
+import time
+
+from methodproof.agents import base
+
+_POLL_INTERVAL = 10
+_HEARTBEAT_INTERVAL = 60
+
+
+def _get_now_playing_macos() -> dict[str, str] | None:
+    script = (
+        'set output to ""\n'
+        'if application "Spotify" is running then\n'
+        '  tell application "Spotify"\n'
+        '    if player state is playing then\n'
+        '      set output to name of current track & "|||" & artist of current track & "|||spotify_desktop"\n'
+        '    end if\n'
+        '  end tell\n'
+        'end if\n'
+        'if output is "" and application "Music" is running then\n'
+        '  tell application "Music"\n'
+        '    if player state is playing then\n'
+        '      set output to name of current track & "|||" & artist of current track & "|||apple_music_desktop"\n'
+        '    end if\n'
+        '  end tell\n'
+        'end if\n'
+        'return output'
+    )
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True, text=True, timeout=5,
+        )
+        parts = result.stdout.strip().split("|||")
+        if len(parts) != 3 or not parts[0]:
+            return None
+        return {"track": parts[0], "artist": parts[1], "player": parts[2]}
+    except Exception:
+        return None
+
+
+def _get_now_playing_linux() -> dict[str, str] | None:
+    try:
+        result = subprocess.run(
+            ["playerctl", "metadata", "--format", "{{artist}}|||{{title}}|||{{playerName}}"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode != 0:
+            return None
+        parts = result.stdout.strip().split("|||")
+        if len(parts) != 3 or not parts[1]:
+            return None
+        player_map = {"spotify": "spotify_desktop", "chromium": "unknown", "firefox": "unknown"}
+        return {"track": parts[1], "artist": parts[0], "player": player_map.get(parts[2].lower(), "unknown")}
+    except FileNotFoundError:
+        return None
+    except Exception:
+        return None
+
+
+def start(stop: threading.Event) -> None:
+    getter = (
+        _get_now_playing_macos if platform.system() == "Darwin"
+        else _get_now_playing_linux if platform.system() == "Linux"
+        else None
+    )
+    if getter is None:
+        base.log("info", "music.unsupported_platform", platform=platform.system())
+        return
+
+    base.log("info", "music.started")
+    last_track_key = ""
+    last_emit_time = 0.0
+
+    while not stop.is_set():
+        info = getter()
+        now = time.time()
+
+        if info:
+            track_key = f"{info['artist']}::{info['track']}"
+            if track_key != last_track_key:
+                base.emit("music_playing", {
+                    "track": info["track"], "artist": info["artist"],
+                    "source": "os_media", "player": info["player"],
+                    "event_kind": "track_change",
+                })
+                last_track_key = track_key
+                last_emit_time = now
+            elif now - last_emit_time >= _HEARTBEAT_INTERVAL:
+                base.emit("music_playing", {
+                    "track": info["track"], "artist": info["artist"],
+                    "source": "os_media", "player": info["player"],
+                    "event_kind": "heartbeat",
+                })
+                last_emit_time = now
+        elif last_track_key:
+            last_track_key = ""
+
+        stop.wait(_POLL_INTERVAL)
+
+    base.log("info", "music.stopped")

methodproof/agents/terminal.py

@@ -0,0 +1,111 @@
+"""Terminal monitor — captures commands from shell hook JSONL log."""
+
+import json
+import re
+import threading
+
+from methodproof.agents import base
+from methodproof.config import CMD_LOG
+
+SENSITIVE = re.compile(
+    r"(^export\s|^set\s|password|token|secret|api[_-]?key|access[_-]?key"
+    r"|credential|private[_-]?key|Authorization:\s*Bearer|ssh\s+-i\s"
+    r"|postgres://\S+:\S+@|mysql://\S+:\S+@|--password|--secret|--token"
+    r"|AKIA[0-9A-Z]{16}|sk-[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{36})",
+    re.IGNORECASE,
+)
+
+TEST_FRAMEWORKS = {
+    "pytest": re.compile(r"\bpytest\b"),
+    "jest": re.compile(r"\bjest\b|npx jest|npm test"),
+    "go_test": re.compile(r"\bgo test\b"),
+    "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")
+_CARGO_RE = re.compile(r"(\d+) passed.*?(\d+) failed")
+
+
+def _detect_test(command: str) -> str | None:
+    for name, pattern in TEST_FRAMEWORKS.items():
+        if pattern.search(command):
+            return name
+    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."""
+    if framework == "pytest":
+        m = _PYTEST_RE.search(output)
+        if m:
+            return int(m.group(1)), int(m.group(2) 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)
+    elif framework == "go_test":
+        return output.count("--- PASS"), output.count("--- FAIL")
+    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
+    if exit_code == 0:
+        return 1, 0
+    return 0, 1
+
+
+def start(stop: threading.Event) -> None:
+    """Tail the command log and emit events until stop is set."""
+    base.log("info", "terminal.started", log=str(CMD_LOG))
+    pos = 0
+    if CMD_LOG.exists():
+        pos = CMD_LOG.stat().st_size
+
+    while not stop.is_set():
+        if not CMD_LOG.exists():
+            stop.wait(1)
+            continue
+        size = CMD_LOG.stat().st_size
+        if size <= pos:
+            stop.wait(0.5)
+            continue
+        with open(CMD_LOG) as f:
+            f.seek(pos)
+            for line in f:
+                _process(line.strip())
+            pos = f.tell()
+
+    base.log("info", "terminal.stopped")
+
+
+def _process(line: str) -> None:
+    if not line:
+        return
+    try:
+        entry = json.loads(line)
+    except json.JSONDecodeError:
+        return
+    command = entry.get("command", "")
+    if not command or SENSITIVE.search(command):
+        return
+    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]"
+
+    base.emit("terminal_cmd", {
+        "command": command, "exit_code": exit_code,
+        "output_snippet": output, "duration_ms": duration,
+    })
+
+    framework = _detect_test(command)
+    if framework:
+        passed, failed = _parse_test_results(output, framework, exit_code)
+        base.emit("test_run", {
+            "framework": framework, "passed": passed, "failed": failed,
+            "duration_ms": duration,
+        })

methodproof/agents/watcher.py

@@ -0,0 +1,170 @@
+"""File watcher agent — captures file changes and git commits."""
+
+import hashlib
+import os
+import re
+import subprocess
+import threading
+from pathlib import Path
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+from methodproof.agents import base
+
+IGNORE_PATTERNS = re.compile(
+    r"(__pycache__|\.pyc|\.git/|node_modules|\.DS_Store|\.swp|~$)"
+)
+
+
+_MAX_DIFF_BYTES = 50_000
+
+
+def _git_diff_stats(repo: str, path: str) -> tuple[int, int]:
+    """Run git diff --stat for a file, return (lines_added, lines_removed)."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "diff", "--numstat", "--", path],
+            capture_output=True, text=True, timeout=5,
+        )
+        line = result.stdout.strip()
+        if not line:
+            return 0, 0
+        parts = line.split("\t")
+        added = int(parts[0]) if parts[0] != "-" else 0
+        removed = int(parts[1]) if parts[1] != "-" else 0
+        return added, removed
+    except Exception:
+        return 0, 0
+
+
+def _git_diff_content(repo: str, path: str) -> str:
+    """Get full diff content for a file, capped at 50KB."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "diff", "--", path],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout[:_MAX_DIFF_BYTES]
+    except Exception:
+        return ""
+
+
+def _git_show_diff(repo: str, sha: str) -> str:
+    """Get full diff for a commit, capped at 50KB."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", repo, "show", "--format=", sha],
+            capture_output=True, text=True, timeout=10,
+        )
+        return result.stdout[:_MAX_DIFF_BYTES]
+    except Exception:
+        return ""
+
+
+class _Handler(FileSystemEventHandler):
+    def __init__(self, watch_dir: str) -> None:
+        self._root = watch_dir
+        self._hashes: dict[str, str] = {}
+
+    def _relpath(self, path: str) -> str:
+        return os.path.relpath(path, self._root)
+
+    def on_created(self, event: FileSystemEvent) -> None:
+        if event.is_directory or IGNORE_PATTERNS.search(event.src_path):
+            return
+        path = self._relpath(event.src_path)
+        lang = Path(event.src_path).suffix.lstrip(".")
+        try:
+            size = os.path.getsize(event.src_path)
+        except OSError:
+            size = 0
+        base.emit("file_create", {"path": path, "size": size, "language": lang})
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        if event.is_directory or IGNORE_PATTERNS.search(event.src_path):
+            return
+        # Skip if content unchanged (watchdog fires on metadata changes)
+        try:
+            content = Path(event.src_path).read_bytes()
+        except OSError:
+            return
+        path = self._relpath(event.src_path)
+        h = hashlib.md5(content).hexdigest()
+        if self._hashes.get(path) == h:
+            return
+        self._hashes[path] = h
+
+        added, removed = _git_diff_stats(self._root, path)
+        lang = Path(event.src_path).suffix.lstrip(".")
+        meta: dict[str, object] = {
+            "path": path, "language": lang,
+            "lines_added": added, "lines_removed": removed,
+        }
+        diff = _git_diff_content(self._root, path)
+        if diff:
+            meta["diff"] = diff
+        base.emit("file_edit", meta)
+
+    def on_deleted(self, event: FileSystemEvent) -> None:
+        if event.is_directory or IGNORE_PATTERNS.search(event.src_path):
+            return
+        path = self._relpath(event.src_path)
+        self._hashes.pop(path, None)
+        base.emit("file_delete", {"path": path})
+
+
+def _poll_git(watch_dir: str, stop: threading.Event) -> None:
+    """Poll .git/refs for new commits every 2 seconds."""
+    git_dir = Path(watch_dir) / ".git"
+    if not git_dir.exists():
+        return
+    seen: set[str] = set()
+    refs = git_dir / "refs" / "heads"
+    while not stop.is_set():
+        try:
+            for ref in refs.iterdir():
+                sha = ref.read_text().strip()
+                if sha not in seen:
+                    seen.add(sha)
+                    if len(seen) > 1:
+                        _log_commit(watch_dir, sha)
+        except OSError:
+            pass
+        stop.wait(2)
+
+
+def _log_commit(watch_dir: str, sha: str) -> None:
+    try:
+        msg = subprocess.run(
+            ["git", "-C", watch_dir, "log", "-1", "--format=%s", sha],
+            capture_output=True, text=True, timeout=5,
+        ).stdout.strip()
+        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}
+    diff = _git_show_diff(watch_dir, sha)
+    if diff:
+        meta["diff"] = diff
+    base.emit("git_commit", meta)
+
+
+def start(watch_dir: str, stop: threading.Event) -> None:
+    """Run file watcher + git poller until stop is set."""
+    handler = _Handler(watch_dir)
+    observer = Observer()
+    observer.schedule(handler, watch_dir, recursive=True)
+    observer.start()
+
+    git_thread = threading.Thread(target=_poll_git, args=(watch_dir, stop), daemon=True)
+    git_thread.start()
+
+    base.log("info", "watcher.started", dir=watch_dir)
+    stop.wait()
+    observer.stop()
+    observer.join(timeout=3)
+    base.log("info", "watcher.stopped")

methodproof/bridge.py

@@ -0,0 +1,86 @@
+"""Local HTTP bridge — accepts browser extension events into SQLite."""
+
+import json
+import threading
+import time
+import uuid
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Any
+
+from methodproof import store
+from methodproof.agents import base
+
+_session_id = ""
+MAX_BODY = 10 * 1024 * 1024  # 10 MB
+
+
+class _Handler(BaseHTTPRequestHandler):
+    def log_message(self, fmt: str, *args: Any) -> None:
+        pass
+
+    def do_GET(self) -> None:
+        if self.path == "/session":
+            self._json({"session_id": _session_id, "active": bool(_session_id)})
+        else:
+            self.send_error(404)
+
+    def do_POST(self) -> None:
+        if self.path == "/events":
+            length = int(self.headers.get("Content-Length", 0))
+            if length > MAX_BODY:
+                self.send_error(413, "Request too large")
+                return
+            try:
+                body = json.loads(self.rfile.read(length)) if length else {}
+            except (json.JSONDecodeError, ValueError):
+                self.send_error(400, "Invalid JSON")
+                return
+            events = body.get("events", [])
+            for e in events:
+                e.setdefault("id", uuid.uuid4().hex)
+                e.setdefault("timestamp", time.time())
+                e.setdefault("duration_ms", 0)
+                e.setdefault("metadata", e.get("metadata", {}))
+            accepted = 0
+            if events:
+                try:
+                    store.insert_events(_session_id, events)
+                    accepted = len(events)
+                except Exception:
+                    self.send_error(500, "Storage error")
+                    return
+            self._json({"accepted": accepted})
+        else:
+            self.send_error(404)
+
+    def do_OPTIONS(self) -> None:
+        self.send_response(204)
+        self._cors()
+        self.end_headers()
+
+    def _json(self, data: Any) -> None:
+        body = json.dumps(data).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self._cors()
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _cors(self) -> None:
+        origin = self.headers.get("Origin", "")
+        allowed = origin.startswith("chrome-extension://") or origin.startswith("http://localhost")
+        self.send_header("Access-Control-Allow-Origin", origin if allowed else "http://localhost:9877")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+
+
+def start(session_id: str, stop: threading.Event, port: int = 9877) -> None:
+    global _session_id
+    _session_id = session_id
+    server = HTTPServer(("127.0.0.1", port), _Handler)
+    server.timeout = 1
+    base.log("info", "bridge.started", port=port)
+    while not stop.is_set():
+        server.handle_request()
+    server.server_close()
+    base.log("info", "bridge.stopped")