methodproof 0.8.7__tar.gz → 0.8.8__tar.gz

{methodproof-0.8.7 → methodproof-0.8.8}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.8.8] — 2026-05-30
+
+### Fixed
+- **Git telemetry inside worktrees** — the watcher and sub-repo enumeration both assumed `.git` is a directory, but in a `git worktree` it is a file pointing at the shared git dir. As a result, running `mp start` from a worktree captured zero `git_commit`/`git_branch_switch` events (the poller raised `NotADirectoryError` reading `.git/refs` and `.git/HEAD`, swallowed silently) and `mp push`/`mp resync` skipped the worktree's repo entirely. The poller now resolves the per-worktree git dir (HEAD) and shared common dir (refs) via `git rev-parse --absolute-git-dir --git-common-dir` (`methodproof/agents/watcher.py`), and sub-repo enumeration detects worktrees via `os.path.exists` rather than `os.path.isdir` (`methodproof/repos.py`).
+
 ## [0.8.7] — 2026-05-15
 
 ### Fixed

{methodproof-0.8.7 → methodproof-0.8.8}/PKG-INFO

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

{methodproof-0.8.7 → methodproof-0.8.8}/methodproof/agents/watcher.py

@@ -268,13 +268,39 @@ def _read_branch(head_file: Path) -> str:
         return ""
 
 
+def _resolve_git_dirs(watch_dir: str) -> tuple[Path, Path] | None:
+    """Resolve (git_dir, common_dir) for `watch_dir`, or None if not a git repo.
+
+    HEAD lives in git_dir; shared refs live in common_dir. The two diverge
+    inside a git worktree, where `.git` is a file rather than a directory.
+    """
+    try:
+        out = subprocess.run(
+            ["git", "-C", watch_dir, "rev-parse", "--absolute-git-dir", "--git-common-dir"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+    if out.returncode != 0:
+        return None
+    lines = out.stdout.splitlines()
+    if len(lines) < 2:
+        return None
+    git_dir = Path(lines[0].strip())
+    common_dir = Path(lines[1].strip())
+    if not common_dir.is_absolute():
+        common_dir = (Path(watch_dir) / common_dir).resolve()
+    return git_dir, common_dir
+
+
 def _poll_git(watch_dir: str, stop: threading.Event) -> None:
-    """Poll .git/refs for new commits and HEAD for branch switches."""
-    git_dir = Path(watch_dir) / ".git"
-    if not git_dir.exists():
+    """Poll shared refs for new commits and HEAD for branch switches."""
+    dirs = _resolve_git_dirs(watch_dir)
+    if dirs is None:
         return
+    git_dir, common_dir = dirs
     seen: set[str] = set()
-    refs = git_dir / "refs" / "heads"
+    refs = common_dir / "refs" / "heads"
     head_file = git_dir / "HEAD"
     last_branch = _read_branch(head_file)
     while not stop.is_set():
@@ -284,7 +310,7 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
                 if sha not in seen:
                     seen.add(sha)
                     if len(seen) > 1:
-                        _log_commit(watch_dir, sha)
+                        _log_commit(watch_dir, sha, head_file)
         except OSError:
             pass
         current_branch = _read_branch(head_file)
@@ -296,7 +322,7 @@ def _poll_git(watch_dir: str, stop: threading.Event) -> None:
         stop.wait(2)
 
 
-def _log_commit(watch_dir: str, sha: str) -> None:
+def _log_commit(watch_dir: str, sha: str, head_file: Path) -> None:
     try:
         fmt = subprocess.run(
             ["git", "-C", watch_dir, "log", "-1",
@@ -336,7 +362,7 @@ def _log_commit(watch_dir: str, sha: str) -> None:
         meta["body"] = body
     if file_statuses:
         meta["file_statuses"] = file_statuses
-    branch = _read_branch(Path(watch_dir) / ".git" / "HEAD")
+    branch = _read_branch(head_file)
     if branch:
         meta["branch"] = branch
     include_lines = base.is_content_captured()

{methodproof-0.8.7 → methodproof-0.8.8}/methodproof/repos.py

@@ -26,7 +26,8 @@ def enumerate_sub_repos(watch_dir: str, max_depth: int = 2) -> list[dict[str, st
     def visit(path: str, depth: int) -> None:
         if not os.path.isdir(path):
             return
-        if os.path.isdir(os.path.join(path, ".git")):
+        # `.git` is a directory in a normal clone, a file in a worktree.
+        if os.path.exists(os.path.join(path, ".git")):
             url = _remote_url(path)
             if url and url not in seen_urls:
                 rel = os.path.relpath(path, watch_dir)

{methodproof-0.8.7 → methodproof-0.8.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.8.7"
+version = "0.8.8"
 description = "See how you code. Capture and visualize your engineering process."
 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"]

{methodproof-0.8.7 → methodproof-0.8.8}/tests/test_repos.py

@@ -12,6 +12,9 @@ from methodproof import repos
 def _git_init(path: Path, remote: str) -> None:
     path.mkdir(parents=True, exist_ok=True)
     subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    # CI runners have no global git identity; commits need a local one.
+    subprocess.run(["git", "config", "user.email", "test@methodproof.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=path, check=True)
     subprocess.run(["git", "remote", "add", "origin", remote], cwd=path, check=True)
 
 
@@ -71,3 +74,18 @@ def test_enumerate_sub_repos_skips_non_repo_dirs(tmp_path: Path) -> None:
     assert "node_modules" not in rels
     assert "not-a-repo" not in rels
     assert "real" in rels
+
+
+def test_enumerate_sub_repos_detects_worktree(tmp_path: Path) -> None:
+    main = tmp_path / "main"
+    _git_init(main, "https://github.com/me/wt")
+    subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "init"],
+                   cwd=main, check=True)
+    wt = tmp_path / "wt-feature"
+    subprocess.run(["git", "worktree", "add", "-q", str(wt), "-b", "feature"],
+                   cwd=main, check=True)
+
+    # `.git` is a file in the worktree, not a directory.
+    assert (wt / ".git").is_file()
+    found = repos.enumerate_sub_repos(str(wt), max_depth=1)
+    assert found == [{"remote_url": "https://github.com/me/wt", "rel_path": ""}]

methodproof-0.8.8/tests/test_watcher_git.py

@@ -0,0 +1,41 @@
+"""Tests for git dir resolution — normal clones vs worktrees."""
+
+import subprocess
+from pathlib import Path
+
+from methodproof.agents import watcher
+
+
+def _git_init(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    # CI runners have no global git identity; commits need a local one.
+    subprocess.run(["git", "config", "user.email", "test@methodproof.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=path, check=True)
+    subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "init"],
+                   cwd=path, check=True)
+
+
+def test_resolve_git_dirs_normal_repo(tmp_path: Path) -> None:
+    _git_init(tmp_path)
+    git_dir, common_dir = watcher._resolve_git_dirs(str(tmp_path))
+    assert git_dir == common_dir
+    assert (git_dir / "HEAD").is_file()
+
+
+def test_resolve_git_dirs_worktree(tmp_path: Path) -> None:
+    main = tmp_path / "main"
+    _git_init(main)
+    wt = tmp_path / "wt-feature"
+    subprocess.run(["git", "worktree", "add", "-q", str(wt), "-b", "feature"],
+                   cwd=main, check=True)
+
+    git_dir, common_dir = watcher._resolve_git_dirs(str(wt))
+    # Worktree HEAD is per-worktree; shared refs live in the common dir.
+    assert git_dir != common_dir
+    assert watcher._read_branch(git_dir / "HEAD") == "feature"
+    assert (common_dir / "refs" / "heads" / "feature").is_file()
+
+
+def test_resolve_git_dirs_non_repo(tmp_path: Path) -> None:
+    assert watcher._resolve_git_dirs(str(tmp_path)) is None