methodproof 0.7.12__tar.gz → 0.7.14__tar.gz

methodproof-0.7.14/.code-review-graph/.gitignore

@@ -0,0 +1,3 @@
+# Auto-generated by code-review-graph — do not commit database files.
+# The graph.db contains absolute paths and code structure metadata.
+*

{methodproof-0.7.12 → methodproof-0.7.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.7.12
+Version: 0.7.14
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -11,6 +11,9 @@ Requires-Dist: watchdog>=4.0
 Requires-Dist: websocket-client>=1.7
 Provides-Extra: proxy
 Requires-Dist: mitmproxy>=10.0; extra == 'proxy'
+Provides-Extra: ui
+Requires-Dist: rich>=13.7; extra == 'ui'
+Requires-Dist: textual>=0.59; extra == 'ui'
 Description-Content-Type: text/markdown
 
 <p align="center">

{methodproof-0.7.12 → methodproof-0.7.14}/methodproof/__init__.py

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

{methodproof-0.7.12 → methodproof-0.7.14}/methodproof/cli.py

@@ -335,7 +335,7 @@ def cmd_init(args: argparse.Namespace) -> None:
     config.ensure_dirs()
     cfg = config.load()
     if getattr(args, "force", False):
-        for key in ("consent_acknowledged", "auto_update_offered", "alias_offered", "local_ai_ports_offered"):
+        for key in ("consent_acknowledged", "auto_update_offered", "alias_offered", "local_ai_ports_offered", "ui_mode_offered"):
             cfg.pop(key, None)
         config.save(cfg)
 
@@ -372,6 +372,18 @@ def cmd_init(args: argparse.Namespace) -> None:
             print("Alias: skipped")
         config.save(cfg)
 
+    # Offer classic CLI mode (TUI is default)
+    if not cfg.get("ui_mode_offered"):
+        cfg["ui_mode_offered"] = True
+        answer = input("Prefer classic terminal output instead of the rich TUI? [y/N]: ").strip().lower()
+        if answer == "y":
+            cfg["ui_mode"] = False
+            print("Output mode: classic  (toggle anytime with: mp ui on/off)")
+        else:
+            cfg["ui_mode"] = True
+            print("Output mode: rich TUI  (toggle anytime with: mp ui off)")
+        config.save(cfg)
+
     # Shell hook — needed for terminal commands
     if capture.get("terminal_commands", True):
         rc = hook.install()
@@ -458,6 +470,58 @@ def cmd_shell_hook(_args: argparse.Namespace) -> None:
     print(hook_text.strip())
 
 
+# ── TUI mode helpers ──────────────────────────────────────────────────────────
+
+def _add_ui_flags(parser: argparse.ArgumentParser) -> None:
+    """Add --ui / --no-ui flags to a subparser."""
+    g = parser.add_mutually_exclusive_group()
+    g.add_argument("--ui", dest="ui", action="store_true", default=None, help="Force TUI output")
+    g.add_argument("--no-ui", dest="ui", action="store_false", help="Force classic output")
+
+
+def _tui_guard() -> None:
+    """Raise SystemExit with install hint if textual is not installed."""
+    import importlib.util
+    if importlib.util.find_spec("textual") is None:
+        raise SystemExit(
+            "TUI mode requires the ui extras.\n"
+            "Install with:  pip install methodproof[ui]\n"
+            "Or switch back: mp ui off"
+        )
+
+
+def _resolve_ui(args: argparse.Namespace, cfg: dict) -> bool:
+    """Return True if TUI mode should be used for this invocation."""
+    flag = getattr(args, "ui", None)  # True / False / None (not specified)
+    if flag is True:
+        return True
+    if flag is False:
+        return False
+    return cfg.get("ui_mode", True)
+
+
+def cmd_ui(args: argparse.Namespace) -> None:
+    """Toggle or report TUI mode."""
+    import importlib.util
+    cfg = config.load()
+    sub = getattr(args, "ui_cmd", None)
+    if sub == "on":
+        cfg["ui_mode"] = True
+        config.save(cfg)
+        print("TUI mode: on  (mp consent, mp log, mp start, mp status, mp review)")
+        if importlib.util.find_spec("textual") is None:
+            print("Install libraries:  pip install methodproof[ui]")
+    elif sub == "off":
+        cfg["ui_mode"] = False
+        config.save(cfg)
+        print("TUI mode: off  (classic terminal output)")
+    else:
+        mode = cfg.get("ui_mode", True)
+        installed = importlib.util.find_spec("textual") is not None
+        print(f"TUI mode:  {'on' if mode else 'off'}")
+        print(f"Libraries: {'installed ✓' if installed else 'not installed  (pip install methodproof[ui])'}")
+
+
 def _print_commands() -> None:
     """Print color coded command reference."""
     if not sys.stdout.isatty():
@@ -738,6 +802,18 @@ def cmd_reset(args: argparse.Namespace) -> None:
 def cmd_consent(args: argparse.Namespace) -> None:
     """Review or change capture, research, and redaction settings."""
     cfg = config.load()
+    if _resolve_ui(args, cfg):
+        _tui_guard()
+        from methodproof.tui.consent import run as tui_consent
+        cfg = tui_consent(cfg)
+        config.save(cfg)
+        if cfg.get("token"):
+            cfg["_pending_research_sync"] = True
+            config.save(cfg)
+            from methodproof.sync import sync_research_consent
+            sync_research_consent(cfg["token"], cfg["api_url"])
+        return
+    # Classic flow
     print(f"\n{_banner()}\n")
     cfg = _run_consent_detailed(cfg)
     config.save(cfg)
@@ -1154,6 +1230,15 @@ def cmd_start(args: argparse.Namespace) -> None:
                     print("Extension: not detected — run `mp extension pair` or install from store")
             except Exception as exc:
                 print(f"Extension: not detected ({exc})")
+        if _resolve_ui(args, cfg):
+            try:
+                _tui_guard()
+                session = store.get_session(sid)
+                from methodproof.tui.start import run as tui_start
+                tui_start(sid, session)
+                return
+            except SystemExit:
+                pass  # textual not installed — fall through to plain message
         print("Run `mp stop` to finish.")
         return
 
@@ -1251,8 +1336,16 @@ def cmd_stop(args: argparse.Namespace) -> None:
     cfg = config.load()
     sid = cfg.get("active_session")
     if not sid:
-        print("No active session.")
-        sys.exit(1)
+        # Config lost track — check store for dangling sessions on this directory
+        watch_dir = os.path.abspath(".")
+        dangling = store.find_active_for_dir(watch_dir)
+        if dangling:
+            sid = dangling["id"]
+            cfg["active_session"] = sid
+            config.save(cfg)
+        else:
+            print("No active session.")
+            sys.exit(1)
 
     # Signal the start process if it's running
     if PIDFILE.exists():
@@ -1294,6 +1387,20 @@ def cmd_view(args: argparse.Namespace) -> None:
 
 
 def cmd_log(args: argparse.Namespace) -> None:
+    cfg = config.load()
+    if _resolve_ui(args, cfg):
+        _tui_guard()
+        from methodproof.tui.log import run as tui_log
+        result = tui_log()
+        if result:
+            action, sid = result
+            import argparse as _ap
+            fake = _ap.Namespace(session_id=sid, local=False)
+            if action == "push":
+                cmd_push(fake)
+            elif action == "view":
+                cmd_view(fake)
+        return
     sessions = store.list_sessions()
     if not sessions:
         print("No sessions yet.")
@@ -1318,8 +1425,13 @@ def cmd_log(args: argparse.Namespace) -> None:
 
 def cmd_status(args: argparse.Namespace) -> None:
     """Show auth, session, and config status at a glance."""
-    from methodproof import __version__
     cfg = config.load()
+    if _resolve_ui(args, cfg):
+        _tui_guard()
+        from methodproof.tui.status import run as tui_status
+        tui_status(cfg)
+        return
+    from methodproof import __version__
     token = cfg.get("token", "")
     claims = _decode_jwt_claims(token) if token else {}
     sessions = store.list_sessions()
@@ -1663,7 +1775,13 @@ def cmd_delete(args: argparse.Namespace) -> None:
 
 def cmd_review(args: argparse.Namespace) -> None:
     """Show exactly what a session contains before pushing."""
+    cfg = config.load()
     session = _resolve_session(args.session_id)
+    if _resolve_ui(args, cfg):
+        _tui_guard()
+        from methodproof.tui.review import run as tui_review
+        tui_review(session)
+        return
     events = store.get_events(session["id"])
     if not events:
         print("No events in this session.")
@@ -1979,11 +2097,14 @@ def main() -> None:
     s.add_argument("--no-e2e", action="store_true", help="Disable E2E for this session (overrides config)")
     s.add_argument("--verbose", "-v", action="store_true", help="Debug logging at each step (still daemonizes)")
     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")
     v = sub.add_parser("view", help="Inspect captured session data")
     v.add_argument("session_id", nargs="?")
-    sub.add_parser("log", help="List sessions")
-    sub.add_parser("status", help="Auth, session, and config status")
+    l_log = sub.add_parser("log", help="List sessions")
+    _add_ui_flags(l_log)
+    s_status = sub.add_parser("status", help="Auth, session, and config status")
+    _add_ui_flags(s_status)
     l = sub.add_parser("login", help="Connect to platform")
     l.add_argument("--api-url")
     l.add_argument("--force", "-f", action="store_true", help="Skip switch-account prompt")
@@ -2005,7 +2126,14 @@ def main() -> None:
     dl.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
     rv = sub.add_parser("review", help="Review session data before pushing")
     rv.add_argument("session_id", nargs="?")
-    sub.add_parser("consent", help="Change capture, research, and redaction settings")
+    _add_ui_flags(rv)
+    c_consent = sub.add_parser("consent", help="Change capture, research, and redaction settings")
+    _add_ui_flags(c_consent)
+    ui_p = sub.add_parser("ui", help="Toggle TUI mode on/off")
+    ui_sub = ui_p.add_subparsers(dest="ui_cmd")
+    ui_sub.add_parser("on", help="Enable TUI mode")
+    ui_sub.add_parser("off", help="Disable TUI mode (classic output)")
+    ui_sub.add_parser("status", help="Show TUI mode and library status")
     up = sub.add_parser("update", help="Update to the latest version from PyPI")
     up_auto = up.add_mutually_exclusive_group()
     up_auto.add_argument("--auto", dest="auto", action="store_true", default=None,
@@ -2062,6 +2190,7 @@ def main() -> None:
         "intro": lambda _: _print_intro(),
         "help": lambda _: _print_commands(),
         "shell-hook": cmd_shell_hook,
+        "ui": cmd_ui,
         "mcp-serve": cmd_mcp_serve,
         "proxy": lambda a: __import__("methodproof.proxy", fromlist=["cmd_proxy"]).cmd_proxy(a),
     }

{methodproof-0.7.12 → methodproof-0.7.14}/methodproof/config.py

@@ -51,6 +51,7 @@ _DEFAULTS: dict[str, Any] = {
         "code_capture": True,
     },
     "profiles": {},
+    "ui_mode": True,
 }
 
 FREE_JOURNAL_MAX_HOURS = 4

{methodproof-0.7.12 → methodproof-0.7.14}/methodproof/sync.py

@@ -30,6 +30,7 @@ def sync_metadata(session: dict[str, Any], token: str, api_url: str) -> None:
 def _raw_request(
     method: str, url: str, token: str,
     body: dict[str, Any] | None = None,
+    timeout: int = 15,
 ) -> dict[str, Any]:
     if body is not None:
         data = gzip.compress(json.dumps(body).encode())
@@ -39,7 +40,7 @@ def _raw_request(
     if data is not None:
         headers["Content-Encoding"] = "gzip"
     req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    with urllib.request.urlopen(req, timeout=15) as resp:
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
         return json.loads(resp.read())
 
 
@@ -57,10 +58,11 @@ def _refresh_token(api_url: str, refresh: str) -> tuple[str, str] | None:
 def _request(
     method: str, path: str, api_url: str, token: str,
     body: dict[str, Any] | None = None,
+    timeout: int = 15,
 ) -> dict[str, Any]:
     url = f"{api_url}{path}"
     try:
-        return _raw_request(method, url, token, body)
+        return _raw_request(method, url, token, body, timeout=timeout)
     except urllib.error.HTTPError as exc:
         if exc.code == 401:
             from methodproof import config
@@ -71,7 +73,7 @@ def _request(
                 if pair:
                     cfg["token"], cfg["refresh_token"] = pair
                     config.save(cfg)
-                    return _raw_request(method, url, cfg["token"], body)
+                    return _raw_request(method, url, cfg["token"], body, timeout=timeout)
             raise SystemExit("Session expired. Run `methodproof login` to re-authenticate.") from None
         detail = ""
         if exc.fp:
@@ -170,8 +172,8 @@ def push(session_id: str, token: str, api_url: str) -> str:
         except ImportError:
             pass  # cryptography not installed
 
-    # Complete
-    _request("PUT", f"/personal/sessions/{remote_id}/complete", api_url, token)
+    # Complete (server drains ingest queue + materializes stats — needs longer timeout)
+    _request("PUT", f"/personal/sessions/{remote_id}/complete", api_url, token, timeout=90)
     store.mark_synced(session_id, remote_id)
 
     # Sync metadata (repo, tags, visibility)

methodproof-0.7.14/methodproof/tui/__init__.py

@@ -0,0 +1 @@
+# methodproof TUI — requires `pip install methodproof[ui]`

methodproof-0.7.14/methodproof/tui/consent.py

@@ -0,0 +1,256 @@
+"""Textual TUI for mp consent — capture categories + publish redaction."""
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, ScrollableContainer, Vertical
+from textual.widgets import Footer, Header, Label, Rule, Static, Switch
+
+from methodproof import config as cfg_mod
+from methodproof.tui.theme import BASE_CSS, BORDER, DIM, GOLD, GREEN, PURPLE, RED, TEXT
+
+# Redaction settings shown in Section B
+_REDACTABLE = [
+    ("command_output", "Terminal output (first 500 chars)"),
+    ("ai_prompts",     "AI prompt text"),
+    ("ai_responses",   "AI response text"),
+    ("code_capture",   "File diffs and git patches"),
+]
+
+# Which sample field each publish_redact key covers (for live preview)
+_REDACT_FIELD: dict[str, str] = {
+    "command_output": "output_snippet",
+    "ai_prompts":     "prompt_text",
+    "ai_responses":   "response_text",
+    "code_capture":   "diff",
+}
+
+_SAMPLE_EVENT = {
+    "type":           "terminal_cmd",
+    "command":        "pytest tests/ -v",
+    "exit_code":      0,
+    "duration_ms":    4201,
+    "output_snippet": "12 passed in 4.2s",
+}
+
+_CSS = BASE_CSS + f"""
+#main {{
+    padding: 1 3;
+}}
+#heading {{
+    color: {TEXT};
+    text-style: bold;
+    margin: 0 0 0 0;
+}}
+#subhead {{
+    color: {DIM};
+    margin: 0 0 1 0;
+}}
+.toggle-row {{
+    height: 2;
+    align: left middle;
+    margin: 0;
+}}
+.toggle-row Switch {{
+    margin: 0 1 0 0;
+    width: 4;
+}}
+.pro-row .row-label {{
+    color: {PURPLE};
+}}
+.pro-badge {{
+    background: #200a26;
+    color: {PURPLE};
+    padding: 0 1;
+    margin: 0 0 0 2;
+    width: 5;
+}}
+#fs-status {{
+    color: {DIM};
+    margin: 1 0 0 0;
+    height: 1;
+}}
+#fs-status.full {{
+    color: {GOLD};
+}}
+#preview-box {{
+    background: #050403;
+    border: solid {BORDER};
+    margin: 1 0 0 0;
+    padding: 1 2;
+    height: auto;
+}}
+.preview-header {{
+    color: {DIM};
+    margin: 0 0 1 0;
+}}
+"""
+
+
+def _build_preview(redact: dict) -> str:
+    """Rich markup string showing the sample event with redacted fields highlighted."""
+    lines = [f"[{DIM}]{{[/{DIM}]"]
+    sample = {**_SAMPLE_EVENT}
+
+    # Mark fields that would be stripped on publish
+    redacted_fields = {
+        field for key, field in _REDACT_FIELD.items() if redact.get(key, True)
+    }
+
+    for k, v in sample.items():
+        if k in redacted_fields:
+            lines.append(f'  [{RED}]"{k}"[/{RED}]: [{RED} dim]\\[redacted][/{RED} dim],')
+        elif isinstance(v, str):
+            lines.append(f'  [{GOLD}]"{k}"[/{GOLD}]: [{GREEN}]"{v}"[/{GREEN}],')
+        else:
+            lines.append(f'  [{GOLD}]"{k}"[/{GOLD}]: [{TEXT}]{v}[/{TEXT}],')
+
+    lines.append(f"[{DIM}]}}[/{DIM}]")
+    return "\n".join(lines)
+
+
+class ConsentApp(App[dict | None]):
+    """Consent + Redaction TUI. Exits with updated cfg dict on save, None on cancel."""
+
+    TITLE = "methodproof — mp consent"
+    CSS = _CSS
+    BINDINGS = [
+        Binding("s", "save", "save"),
+        Binding("escape", "cancel", "cancel"),
+        Binding("r", "reset_defaults", "reset"),
+    ]
+
+    def __init__(self, cfg: dict) -> None:
+        super().__init__()
+        self._cfg = cfg
+        self._capture = dict(cfg.get("capture", cfg_mod._DEFAULTS["capture"]))
+        self._redact = dict(cfg.get("publish_redact", cfg_mod._DEFAULTS["publish_redact"]))
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        with ScrollableContainer(id="main"):
+            yield Static("Configure Data Capture", id="heading")
+            yield Static(
+                "Control exactly what leaves your machine.  Nothing uploads until  mp push.",
+                id="subhead",
+            )
+
+            # ── Section A: Capture categories ────────────────────
+            with Vertical(classes="panel", id="capture-panel"):
+                yield Static("  Structural Capture  ", classes="section-title")
+
+                for cat in cfg_mod.STANDARD_CATEGORIES:
+                    label = cat.replace("_", " ")
+                    desc = cfg_mod.CAPTURE_DESCRIPTIONS[cat]
+                    with Horizontal(classes="toggle-row"):
+                        yield Switch(
+                            value=self._capture.get(cat, True),
+                            id=f"cap-{cat}",
+                            animate=False,
+                        )
+                        yield Label(label, classes="row-label")
+                        yield Label(desc, classes="row-desc")
+
+                yield Static("", id="fs-status")
+                yield Rule()
+
+                # Code capture — Pro, off by default
+                with Horizontal(classes="toggle-row pro-row"):
+                    yield Switch(
+                        value=self._capture.get("code_capture", False),
+                        id="cap-code_capture",
+                        animate=False,
+                    )
+                    yield Label("code capture", classes="row-label")
+                    yield Label(cfg_mod.CAPTURE_DESCRIPTIONS["code_capture"], classes="row-desc")
+                    yield Static("Pro", classes="pro-badge")
+
+            # ── Section B: Publish redaction ─────────────────────
+            with Vertical(classes="panel", id="redact-panel"):
+                yield Static("  Publish Redaction  ", classes="section-title")
+                yield Static(
+                    "Stripped when you publish a session publicly (mp publish).",
+                    classes="row-desc",
+                )
+                yield Static("", classes="row-desc")  # spacer
+
+                for key, desc in _REDACTABLE:
+                    with Horizontal(classes="toggle-row"):
+                        yield Switch(
+                            value=self._redact.get(key, True),
+                            id=f"red-{key}",
+                            animate=False,
+                        )
+                        yield Label(desc, classes="row-label")
+
+                # Live redaction preview
+                with Vertical(id="preview-box"):
+                    yield Static(
+                        "What leaves your machine on  mp push  with current settings:",
+                        classes="preview-header",
+                    )
+                    yield Static(
+                        _build_preview(self._redact),
+                        id="preview-content",
+                        markup=True,
+                    )
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._refresh_fs_status()
+
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        sw_id = event.switch.id or ""
+        if sw_id.startswith("cap-"):
+            self._capture[sw_id[4:]] = event.value
+            self._refresh_fs_status()
+        elif sw_id.startswith("red-"):
+            self._redact[sw_id[4:]] = event.value
+            self._refresh_preview()
+
+    def _refresh_fs_status(self) -> None:
+        enabled = sum(1 for k in cfg_mod.STANDARD_CATEGORIES if self._capture.get(k, True))
+        is_full = enabled == len(cfg_mod.STANDARD_CATEGORIES)
+        widget = self.query_one("#fs-status", Static)
+        if is_full:
+            widget.update("★  Full Spectrum — free live streaming unlocked")
+            widget.remove_class("full")
+            widget.add_class("full")
+        else:
+            widget.update(
+                f"  {enabled} / {len(cfg_mod.STANDARD_CATEGORIES)} enabled"
+                "  —  enable all 10 for free live streaming"
+            )
+            widget.remove_class("full")
+        self._refresh_preview()
+
+    def _refresh_preview(self) -> None:
+        self.query_one("#preview-content", Static).update(
+            _build_preview(self._redact)
+        )
+
+    def action_save(self) -> None:
+        self._cfg["capture"] = self._capture
+        self._cfg["publish_redact"] = self._redact
+        self._cfg["consent_acknowledged"] = True
+        self.exit(self._cfg)
+
+    def action_cancel(self) -> None:
+        self.exit(None)
+
+    def action_reset_defaults(self) -> None:
+        self._capture = dict(cfg_mod._DEFAULTS["capture"])
+        self._redact = dict(cfg_mod._DEFAULTS["publish_redact"])
+        for cat in cfg_mod.STANDARD_CATEGORIES:
+            self.query_one(f"#cap-{cat}", Switch).value = self._capture[cat]
+        self.query_one("#cap-code_capture", Switch).value = self._capture["code_capture"]
+        for key, _ in _REDACTABLE:
+            self.query_one(f"#red-{key}", Switch).value = self._redact[key]
+        self._refresh_fs_status()
+
+
+def run(cfg: dict) -> dict:
+    """Launch the consent TUI. Returns updated cfg, or unchanged cfg if cancelled."""
+    result = ConsentApp(cfg).run()
+    return result if result is not None else cfg