methodproof 0.7.35__tar.gz → 0.7.36__tar.gz

{methodproof-0.7.35 → methodproof-0.7.36}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.7.36] — 2026-04-12
+
+### Added
+- **`mp connect [session_id]`** — attach TUI to an active recording session. Defaults to the current active session. `mp start` with an active session now auto-connects instead of erroring.
+- **Source tracking in TUI** — events display which AI tool session generated them (e.g. `claude`, `codex`). Session bar shows source name and conversation number (`claude #2`). Tracks across multiple AI sessions within one `mp start`.
+- **End session from TUI (`x`)** — confirmation prompt (`y`/`n`) to stop the session and finalize from within the TUI. `q` now exits the TUI without stopping the daemon — reconnect later with `mp connect`.
+
+### Fixed
+- **Tree indentation invisible** — `gold_ember` (`#3d3118`) was near-invisible on dark background; switched to `gold_aged` (`#9a7b3a`).
+- **Orphan tool_call events showed no tree** — `tool_call` after `agent_turn_end`/`agent_complete` fell through to flat rendering. Now implicitly opens a new chain.
+- **`tool_name` field empty in TUI** — hook events store the tool name in `tool` not `tool_name`; formatters now check both fields.
+
 ## [0.7.35] — 2026-04-12
 
 ### Added

{methodproof-0.7.35 → methodproof-0.7.36}/PKG-INFO

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

{methodproof-0.7.35 → methodproof-0.7.36}/methodproof/cli.py

@@ -1098,9 +1098,11 @@ def cmd_start(args: argparse.Namespace) -> None:
 
     if cfg.get("active_session"):
         if _is_daemon_alive():
-            print(f"Session active: {cfg['active_session'][:8]}")
-            print("Run `methodproof stop` first.")
-            sys.exit(1)
+            sid = cfg["active_session"]
+            print(f"  Session {sid[:8]} already active. Connecting...")
+            args.session_id = None  # connect resolves from config
+            cmd_connect(args)
+            return
         stale_sid = cfg["active_session"]
         _log_step(f"Cleaning stale session {stale_sid[:8]}")
         store.complete_session(stale_sid)
@@ -1301,7 +1303,9 @@ def cmd_start(args: argparse.Namespace) -> None:
         if _resolve_ui(args, cfg):
             session = store.get_session(sid)
             from methodproof.tui.start import run as tui_start
-            tui_start(sid, session)
+            result = tui_start(sid, session)
+            if result == "end_session":
+                cmd_stop(args)
             return
         print("Run `mp stop` to finish.")
         return
@@ -1444,6 +1448,33 @@ def cmd_stop(args: argparse.Namespace) -> None:
     _print_summary(session, stats, cfg)
 
 
+def cmd_connect(args: argparse.Namespace) -> None:
+    """Attach TUI to an active recording session."""
+    cfg = config.load()
+    sid = getattr(args, "session_id", None)
+    if sid:
+        # Resolve prefix
+        sessions = store.list_sessions()
+        match = [s for s in sessions if s["id"].startswith(sid)]
+        if not match:
+            print(f"No session matching '{sid}'")
+            sys.exit(1)
+        sid = match[0]["id"]
+    else:
+        sid = cfg.get("active_session")
+    if not sid:
+        print("No active session. Run `mp start` first.")
+        sys.exit(1)
+    session = store.get_session(sid)
+    if not session:
+        print(f"Session {sid[:8]} not found.")
+        sys.exit(1)
+    from methodproof.tui.start import run as tui_start
+    result = tui_start(sid, session)
+    if result == "end_session":
+        cmd_stop(args)
+
+
 def cmd_view(args: argparse.Namespace) -> None:
     session = _resolve_session(args.session_id)
     from methodproof.viewer import view
@@ -1782,18 +1813,51 @@ def cmd_push(args: argparse.Namespace) -> None:
     local = getattr(args, "local", False)
     cfg = config.load(local=local)
     if not cfg.get("token"):
-        target = "local API" if local else "platform"
         print(f"Run `methodproof login{' --api-url http://localhost:8000' if local else ''}` first.")
         sys.exit(1)
     from methodproof.sync import sync_research_consent
     sync_research_consent(cfg["token"], cfg["api_url"])
     cfg = config.load(local=local)
-    sid = args.session_id or _latest()
-    if not sid:
-        print("No sessions to push.")
-        sys.exit(1)
-    from methodproof.sync import push
     force = getattr(args, "force", False)
+
+    if args.session_id:
+        _push_one(args.session_id, cfg, force=force)
+        return
+
+    # No session_id — check for unsynced completed sessions
+    unsynced = [s for s in store.list_sessions()
+                if not s["synced"] and s.get("completed_at")]
+    if not unsynced:
+        # Fall back to latest session
+        sid = _latest()
+        if not sid:
+            print("No sessions to push.")
+            sys.exit(1)
+        _push_one(sid, cfg, force=force)
+        return
+
+    if len(unsynced) == 1:
+        _push_one(unsynced[0]["id"], cfg, force=force)
+        return
+
+    # Multiple unsynced — offer to push all
+    print(f"Found {len(unsynced)} unsynced sessions:\n")
+    for s in unsynced:
+        events = len(store.get_events(s["id"]))
+        date = s["created_at"][:10] if s.get("created_at") else "?"
+        print(f"  {s['id'][:8]}  {date}  {events} events")
+    print()
+    answer = input(f"Push all {len(unsynced)}? [Y/n] ").strip().lower()
+    if answer in ("", "y", "yes"):
+        for s in unsynced:
+            _push_one(s["id"], cfg, force=force)
+            print()
+    else:
+        print("Cancelled. Push individually with `mp push <session_id>`.")
+
+
+def _push_one(sid: str, cfg: dict, force: bool = False) -> None:
+    from methodproof.sync import push
     remote_id = push(sid, cfg["token"], cfg["api_url"], force=force)
     app = _app_url(cfg["api_url"])
     print(f"Pushed {sid[:8]} → {cfg['api_url']} (private).")
@@ -2205,6 +2269,9 @@ def main() -> None:
     s.add_argument("--streaming", action="store_true", help="Blocking foreground — stream every captured event to stdout")
     _add_ui_flags(s)
     sub.add_parser("stop", help="Stop recording")
+    cn = sub.add_parser("connect", help="Attach TUI to active session")
+    cn.add_argument("session_id", nargs="?", help="Session ID prefix (defaults to active)")
+    _add_ui_flags(cn)
     v = sub.add_parser("view", help="Inspect captured session data")
     v.add_argument("session_id", nargs="?")
     l_log = sub.add_parser("log", help="List sessions")
@@ -2287,7 +2354,7 @@ def main() -> None:
 
     args = p.parse_args()
     cmds = {
-        "init": cmd_init, "start": cmd_start, "stop": cmd_stop,
+        "init": cmd_init, "start": cmd_start, "stop": cmd_stop, "connect": cmd_connect,
         "view": cmd_view, "log": cmd_log, "status": cmd_status,
         "login": cmd_login, "logout": cmd_logout, "accounts": cmd_accounts, "switch": cmd_switch,
         "push": cmd_push, "tag": cmd_tag, "publish": cmd_publish,

{methodproof-0.7.35 → methodproof-0.7.36}/methodproof/tui/start.py

@@ -197,6 +197,11 @@ class _TreeTracker:
                 return "├ ", True
             self._in_chain = False
             return "  ", True
+        # Not in chain — tool_call starts one implicitly (orphan after closer)
+        if etype in self._INNERS:
+            self._in_chain = True
+            self._collapse_count = 0
+            return "├ ", True
         return "  ", True
 
 
@@ -255,15 +260,15 @@ def _fmt_meta(ev: dict) -> str:
 
     # Hook lifecycle — tool call / result
     if etype == "tool_call":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         preview = (meta.get("tool_input_preview") or "")[:60]
         return f"{name}  {preview}".strip()
     if etype == "tool_result":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         ok = "✓" if meta.get("success", True) else "✗"
         return f"{name}  {ok}"
     if etype == "tool_failure":
-        name = meta.get("tool_name", "")
+        name = meta.get("tool_name") or meta.get("tool", "")
         err = (meta.get("error") or "")[:40]
         return f"{name}  ✗  {err}".strip()
 
@@ -392,14 +397,40 @@ class _DetailScreen(Screen[None]):
         self.app.pop_screen()
 
 
+class _ConfirmEndScreen(Screen[bool]):
+    """Confirm session end."""
+
+    BINDINGS = [
+        Binding("y", "confirm", "yes"),
+        Binding("n", "cancel", "no"),
+        Binding("escape", "cancel", "cancel"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        P = ACTIVE
+        yield Static(
+            f"\n  [{P.red}]End this session?[/{P.red}]\n\n"
+            f"  [{P.dim}]This will stop all capture agents and finalize the session.[/{P.dim}]\n\n"
+            f"  [{P.gold}]y[/{P.gold}] [{P.dim}]confirm[/{P.dim}]    "
+            f"[{P.gold}]n[/{P.gold}] [{P.dim}]cancel[/{P.dim}]",
+        )
+
+    def action_confirm(self) -> None:
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+
 # ── App ──────────────────────────────────────────────────────────────
-class StartApp(App[None]):
+class StartApp(App[str | None]):
     """Live session view — tails the active session's events."""
 
     TITLE = "methodproof — mp start"
     CSS = _CSS
     BINDINGS = [
-        Binding("q", "stop_session", "stop"),
+        Binding("q", "exit_tui", "exit"),
+        Binding("x", "end_session", "end session"),
         Binding("p", "pause", "pause"),
         Binding("j", "toggle_journal", "journal"),
         Binding("f", "cycle_filter", "filter"),
@@ -438,6 +469,10 @@ class StartApp(App[None]):
         self._last_event_ts: float = 0.0
         self._recent_files: list[str] = []
         self._recent_tools: list[str] = []
+        # Source tracking: which AI tool session is active
+        self._active_source: str = ""  # e.g. "claude", "codex", "gemini"
+        self._source_session_id: str = ""  # short id of the AI session
+        self._source_count: int = 0  # how many AI sessions so far
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=False)
@@ -518,10 +553,13 @@ class StartApp(App[None]):
             badge_str = f"  {badge_str}"
 
         ev = f"  {self._event_count} ev" if self._event_count else ""
+        src = ""
+        if self._active_source:
+            src = f"  ·  [{P.purple_muted}]{self._active_source} #{self._source_count}[/{P.purple_muted}]"
         self.query_one("#session-bar", Static).update(
             f"  session: [{P.gold}]{sid}[/{P.gold}]  ·  {watch_dir}"
             f"  ·  [{P.green}]●[/{P.green}]  {h:02d}:{m:02d}:{s:02d}"
-            f"{ev}{badge_str}  ·  [{P.purple}]{self._account_type}[/{P.purple}]"
+            f"{ev}{src}{badge_str}  ·  [{P.purple}]{self._account_type}[/{P.purple}]"
         )
 
     # ── Event poll: Layers B + E + A ─────────────────────────────
@@ -544,6 +582,17 @@ class StartApp(App[None]):
             self._last_event = ev
             ev_ts = ev.get("ts", time.time())
 
+            # Source tracking: detect AI session boundaries
+            if etype.endswith("_session_start"):
+                self._active_source = etype.replace("_session_start", "")
+                ev_meta_src = ev.get("metadata") or {}
+                sid_field = ev_meta_src.get("session_id") or ev_meta_src.get("claude_session_id", "")
+                self._source_session_id = str(sid_field)[:8]
+                self._source_count += 1
+            elif etype.endswith("_session_end"):
+                self._active_source = ""
+                self._source_session_id = ""
+
             # Quiet mode: skip dim events
             if self._quiet_mode and etype in _DIM_TYPES:
                 self._stats[etype] = self._stats.get(etype, 0) + 1
@@ -572,7 +621,7 @@ class StartApp(App[None]):
                         self._recent_files.append(path)
                     if len(self._recent_files) > 10:
                         self._recent_files.pop(0)
-                tool = ev_meta.get("tool_name")
+                tool = ev_meta.get("tool_name") or ev_meta.get("tool")
                 if tool and etype in ("tool_call", "tool_result"):
                     if tool not in self._recent_tools:
                         self._recent_tools.append(tool)
@@ -585,16 +634,20 @@ class StartApp(App[None]):
                 self._event_count += 1
                 continue
 
+            # Source tag
+            src_tag = ""
+            if self._active_source:
+                src_tag = f"[{P.purple_muted}]{self._active_source}[/{P.purple_muted}] "
+
             # Search highlight
             line_plain = f"{etype} {meta}"
             if self._search_query and self._search_query.lower() not in line_plain.lower():
-                # Still render but dimmed
                 feed.write(f"[{P.dim}]{ts}  {prefix}{etype:<18} {meta}[/{P.dim}]")
             else:
-                # Layer B + E: structural line with tree prefix
                 feed.write(
                     f"[{P.dim}]{ts}[/{P.dim}] "
-                    f"[{P.gold_ember}]{prefix}[/{P.gold_ember}]"
+                    f"{src_tag}"
+                    f"[{P.gold_aged}]{prefix}[/{P.gold_aged}]"
                     f"[{color}]{etype:<18}[/{color}] "
                     f"[{P.dim}]{meta}[/{P.dim}]"
                 )
@@ -602,7 +655,7 @@ class StartApp(App[None]):
             # Layer A: journal content enrichment
             for jline in _journal_lines(ev, self._journal_mode):
                 feed.write(
-                    f"           [{P.gold_ember}]│[/{P.gold_ember}] "
+                    f"           [{P.gold_aged}]│[/{P.gold_aged}] "
                     f"[{P.dim}]{jline}[/{P.dim}]"
                 )
 
@@ -655,9 +708,19 @@ class StartApp(App[None]):
         self.set_timer(4.0, lambda: alert.remove_class("visible"))
 
     # ── Actions ──────────────────────────────────────────────────
-    def action_stop_session(self) -> None:
+    def action_exit_tui(self) -> None:
+        """Detach TUI — daemon keeps recording."""
         self.exit(None)
 
+    def action_end_session(self) -> None:
+        """End the session (with confirmation)."""
+        self.push_screen(_ConfirmEndScreen(), self._on_confirm_end)
+
+    def _on_confirm_end(self, confirmed: bool) -> None:
+        if not confirmed:
+            return
+        self.exit("end_session")
+
     def action_pause(self) -> None:
         self._paused = not self._paused
 
@@ -743,6 +806,7 @@ class StartApp(App[None]):
         self._tick_timer()
 
 
-def run(session_id: str, session: dict) -> None:
-    """Launch the live session view for the given session."""
-    StartApp(session_id, session).run()
+def run(session_id: str, session: dict) -> str | None:
+    """Launch the live session view. Returns 'end_session' if user chose to end."""
+    app = StartApp(session_id, session)
+    return app.run()

{methodproof-0.7.35 → methodproof-0.7.36}/pyproject.toml

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

{methodproof-0.7.35 → methodproof-0.7.36}/tests/test_cli_start.py

@@ -38,14 +38,17 @@ def test_start_auth_fails(mock_auth, mock_hook, cli_args):
 
 @patch("methodproof.cli._is_daemon_alive", return_value=True)
 @patch("methodproof.hook.is_installed", return_value=True)
-def test_start_session_already_active(mock_hook, mock_alive, logged_in_cfg, cli_args, make_session):
+def test_start_session_already_active(mock_hook, mock_alive, logged_in_cfg, cli_args, make_session, capsys):
     logged_in_cfg()
     sid, _ = make_session()
     cfg = config.load()
     cfg["active_session"] = sid
     config.save(cfg)
-    with pytest.raises(SystemExit):
+    with patch("methodproof.cli.cmd_connect") as mock_connect:
         cli.cmd_start(cli_args())
+        mock_connect.assert_called_once()
+    out = capsys.readouterr().out
+    assert "already active" in out
 
 
 @patch("methodproof.cli._is_daemon_alive", return_value=False)