codebase-receipts-cli 1.0.0__py3-none-any.whl

receipts/tui/hub.py

@@ -0,0 +1,367 @@
+"""Unified TUI shell — dashboard, readiness, and ledger in one app.
+
+One Textual application, one screen per zero-argument workflow, switchable
+without exiting: `d` dashboard, `r` readiness, `l` ledger, `q` quits, `?`
+shows help, `g` refreshes the current screen. Each command's ``--tui`` flag
+deep-links straight to its screen (``receipts readiness --tui`` opens the
+hub on the readiness screen).
+
+Workflows that take arguments (verify, ama, rewrite, score, dossier,
+ingest) keep their dedicated full-screen apps behind their own ``--tui``
+flags — this shell unifies the always-available status/data screens.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Header, RichLog
+
+from receipts.tui.widgets.status_bar import StatusBar
+
+_SCREEN_KEYS = [
+    ("d", "switch('dashboard')", "Dashboard"),
+    ("r", "switch('readiness')", "Readiness"),
+    ("l", "switch('ledger')", "Ledger"),
+    ("g", "refresh_screen", "Refresh"),
+    ("question_mark", "help", "Help"),
+    ("q", "quit", "Quit"),
+]
+
+_HELP_TEXT = (
+    "d dashboard · r readiness · l ledger · g refresh · q quit"
+    " — every screen shows the same footer, so you always know the keys."
+)
+
+
+class _HubScreen(Screen):
+    """Shared plumbing: status bar wiring + refresh hook."""
+
+    def on_screen_resume(self) -> None:
+        self.refresh_data()
+
+    def refresh_data(self) -> None:  # overridden per screen
+        raise NotImplementedError
+
+    def _set_provider_status(self) -> None:
+        status = self.query_one(StatusBar)
+        try:
+            from receipts.config import load_settings
+
+            settings = load_settings()
+            status.provider_name = settings.provider
+        except Exception:
+            status.provider_name = "—"
+        status.status_text = self.SUB_TITLE or "Ready"
+
+
+class DashboardScreen(_HubScreen):
+    SUB_TITLE = "dashboard"
+
+    CSS = """
+    #provider-panel, #ledger-panel, #readiness-panel {
+        height: 1fr;
+        border: solid $primary;
+        margin: 0 1;
+    }
+    .panel-row { height: 1fr; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            with Horizontal(classes="panel-row"):
+                yield RichLog(id="provider-panel", markup=True, wrap=True)
+                yield RichLog(id="ledger-panel", markup=True, wrap=True)
+            yield RichLog(id="readiness-panel", markup=True, wrap=True)
+        yield StatusBar()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.refresh_data()
+
+    def refresh_data(self) -> None:
+        for pid in ("provider-panel", "ledger-panel", "readiness-panel"):
+            self.query_one(f"#{pid}", RichLog).clear()
+        self._set_provider_status()
+        self.run_worker(self._load, thread=True)
+
+    async def _load(self) -> None:
+        self._load_provider()
+        self._load_ledger()
+        self._load_readiness()
+
+    def _load_provider(self) -> None:
+        panel = self.query_one("#provider-panel", RichLog)
+        panel.write("[bold]Provider[/bold]\n")
+
+        from receipts.config import load_settings
+        from receipts.llm.factory import get_provider
+
+        settings = load_settings()
+        panel.write(f"Configured: {settings.provider}")
+        try:
+            provider = get_provider(settings, verify=True)
+        except Exception as exc:
+            panel.write(f"[red]{exc}[/red]")
+            return
+
+        chat_model = getattr(provider, "chat_model", None)
+        embed_model = getattr(provider, "embed_model", None)
+        embed_via = getattr(provider, "embed_provider_name", None)
+        if chat_model:
+            panel.write(f"Chat model:  {chat_model}")
+        if embed_model:
+            suffix = f" (via {embed_via})" if embed_via else ""
+            panel.write(f"Embed model: {embed_model}{suffix}")
+        panel.write("[green]Connected ✓[/green]")
+
+    def _load_ledger(self) -> None:
+        panel = self.query_one("#ledger-panel", RichLog)
+        panel.write("[bold]Token ledger (lifetime)[/bold]\n")
+
+        from receipts.ledger.token_ledger import TokenLedger
+
+        tl = TokenLedger()
+        try:
+            lt = tl.lifetime_summary()
+        finally:
+            tl.close()
+
+        if lt.call_count == 0:
+            panel.write("No LLM calls recorded yet.")
+            return
+        panel.write(f"Sessions:      {lt.session_count}")
+        panel.write(f"LLM calls:     {lt.call_count}")
+        panel.write(f"Input tokens:  {lt.total_input:,}")
+        panel.write(f"Output tokens: {lt.total_output:,}")
+        panel.write(f"Est. cost:     ${lt.total_cost:.4f}")
+        panel.write("\n[dim]Press l for the full ledger screen.[/dim]")
+
+    def _load_readiness(self) -> None:
+        panel = self.query_one("#readiness-panel", RichLog)
+        panel.write("[bold]Interview readiness[/bold]\n")
+
+        from receipts.prep.readiness import ReadinessStore, readiness_delta
+
+        store = ReadinessStore()
+        try:
+            sessions = store.sessions()
+            weakest = store.weakest_section()
+        finally:
+            store.close()
+
+        if not sessions:
+            panel.write("No saved interview sessions yet — run 'receipts ama'.")
+            return
+
+        for s in sessions[-5:]:
+            when = datetime.fromtimestamp(s.timestamp).strftime("%Y-%m-%d %H:%M")
+            panel.write(
+                f"{when}  {s.resume_name[:20]:<20}"
+                f" {s.held_rounds}/{s.total_rounds} held up ({s.ratio:.0%})"
+            )
+
+        delta = readiness_delta(sessions)
+        if delta:
+            latest, previous = delta
+            change = (latest - previous) * 100
+            color = "green" if change >= 0 else "red"
+            panel.write(
+                f"\n[{color}]Trend: {previous:.0%} → {latest:.0%}"
+                f" ({change:+.0f} pts)[/{color}]"
+            )
+
+        if weakest and weakest.ratio < 1.0:
+            panel.write(
+                f"\n[yellow]Drill next: {weakest.section}"
+                f" ({weakest.held}/{weakest.total} held up)[/yellow]"
+            )
+        panel.write("\n[dim]Press r for the full readiness screen.[/dim]")
+
+
+class ReadinessScreen(_HubScreen):
+    SUB_TITLE = "readiness"
+
+    CSS = """
+    #sessions-table { height: 1fr; margin: 0 1; }
+    #detail-panel { height: 1fr; border: solid $primary; margin: 0 1; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield DataTable(id="sessions-table", cursor_type="row")
+            yield RichLog(id="detail-panel", markup=True, wrap=True)
+        yield StatusBar()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#sessions-table", DataTable)
+        table.add_columns("When", "Resume", "Held up", "Rate", "Sections")
+        self.refresh_data()
+
+    def refresh_data(self) -> None:
+        self._set_provider_status()
+        table = self.query_one("#sessions-table", DataTable)
+        detail = self.query_one("#detail-panel", RichLog)
+        table.clear()
+        detail.clear()
+
+        from receipts.prep.readiness import ReadinessStore, readiness_delta
+
+        store = ReadinessStore()
+        try:
+            sessions = store.sessions()
+            weakest = store.weakest_section()
+            stumbles = store.weak_spots(limit=5)
+        finally:
+            store.close()
+
+        if not sessions:
+            detail.write("No saved interview sessions yet — run 'receipts ama'.")
+            return
+
+        for s in reversed(sessions):  # newest first in the table
+            when = datetime.fromtimestamp(s.timestamp).strftime("%Y-%m-%d %H:%M")
+            secs = ", ".join(f"{st.section} {st.held}/{st.total}" for st in s.sections)
+            table.add_row(
+                when,
+                s.resume_name[:24],
+                f"{s.held_rounds}/{s.total_rounds}",
+                f"{s.ratio:.0%}",
+                secs[:60],
+            )
+
+        latest = sessions[-1]
+        detail.write("[bold]Latest session by section[/bold]\n")
+        for stat in sorted(latest.sections, key=lambda s: s.ratio):
+            bar_len = int(stat.ratio * 20)
+            bar = "█" * bar_len + "░" * (20 - bar_len)
+            detail.write(f"  {stat.section:<24} {stat.held}/{stat.total}  {bar}")
+
+        delta = readiness_delta(sessions)
+        if delta:
+            new, old = delta
+            change = (new - old) * 100
+            color = "green" if change >= 0 else "red"
+            detail.write(
+                f"\n[{color}]Trend: {old:.0%} → {new:.0%} ({change:+.0f} pts)[/{color}]"
+            )
+
+        if weakest and weakest.ratio < 1.0:
+            detail.write(
+                f"\n[yellow]Drill next: {weakest.section} —"
+                f' receipts ama <resume> <source> --section "{weakest.section}"'
+                "[/yellow]"
+            )
+
+        if stumbles:
+            detail.write("\n[bold]Recent stumbles[/bold]")
+            for spot in stumbles:
+                detail.write(f"  • {spot.bullet_text[:70]}")
+                detail.write(f"    [dim]{spot.assessment[:90]}[/dim]")
+                if spot.model_answer:
+                    detail.write(
+                        f"    [blue]→ Better answer: {spot.model_answer[:110]}[/blue]"
+                    )
+
+
+class LedgerScreen(_HubScreen):
+    SUB_TITLE = "ledger"
+
+    CSS = """
+    #totals-panel { height: auto; max-height: 10; border: solid $primary; margin: 0 1; }
+    #models-table { height: 1fr; margin: 0 1; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield RichLog(id="totals-panel", markup=True, wrap=True)
+            yield DataTable(id="models-table", cursor_type="row")
+        yield StatusBar()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#models-table", DataTable)
+        table.add_columns("Provider", "Model", "Calls", "Input", "Output", "Cost")
+        self.refresh_data()
+
+    def refresh_data(self) -> None:
+        self._set_provider_status()
+        totals = self.query_one("#totals-panel", RichLog)
+        table = self.query_one("#models-table", DataTable)
+        totals.clear()
+        table.clear()
+
+        from receipts.ledger.token_ledger import TokenLedger
+
+        tl = TokenLedger()
+        try:
+            lt = tl.lifetime_summary()
+            last = tl.last_session_summary()
+            models = tl.model_breakdown()
+        finally:
+            tl.close()
+
+        if lt.call_count == 0:
+            totals.write("No LLM calls recorded yet. Run a command first.")
+            return
+
+        totals.write(
+            f"[bold]Lifetime[/bold]  {lt.session_count} sessions ·"
+            f" {lt.call_count} calls · {lt.total_input:,} in /"
+            f" {lt.total_output:,} out · ${lt.total_cost:.4f}"
+        )
+        if last is not None:
+            totals.write(
+                f"[bold]Last session[/bold]  {last.call_count} calls ·"
+                f" {last.total_input:,} in / {last.total_output:,} out ·"
+                f" ${last.total_cost:.4f}"
+            )
+
+        for m in models:
+            table.add_row(
+                m.provider,
+                m.model,
+                str(m.call_count),
+                f"{m.total_input:,}",
+                f"{m.total_output:,}",
+                f"${m.total_cost:.4f}",
+            )
+
+
+class HubApp(App):
+    """The unified shell. ``start`` picks the screen a --tui flag deep-links to."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "hub"
+    BINDINGS = _SCREEN_KEYS
+    SCREENS = {
+        "dashboard": DashboardScreen,
+        "readiness": ReadinessScreen,
+        "ledger": LedgerScreen,
+    }
+
+    def __init__(self, *, start: str = "dashboard", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._start = start if start in self.SCREENS else "dashboard"
+
+    def on_mount(self) -> None:
+        self.push_screen(self._start)
+
+    def action_switch(self, name: str) -> None:
+        if name in self.SCREENS and self.screen.SUB_TITLE != name:
+            self.switch_screen(name)
+
+    def action_refresh_screen(self) -> None:
+        screen = self.screen
+        if isinstance(screen, _HubScreen):
+            screen.refresh_data()
+
+    def action_help(self) -> None:
+        self.notify(_HELP_TEXT, title="Keys", timeout=6)

receipts/tui/ingest_app.py

@@ -0,0 +1,183 @@
+"""Textual TUI for the ingest flow — scan, secrets, extract, embed."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, ProgressBar, RichLog
+
+from receipts.tui.widgets.status_bar import StatusBar
+
+
+class IngestApp(App):
+    """Full-screen ingest: live log + embedding progress bar."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "codebase ingest"
+
+    CSS = """
+    #ingest-log {
+        height: 1fr;
+    }
+    #embed-progress {
+        dock: bottom;
+        height: 1;
+        margin: 0 2;
+    }
+    """
+
+    BINDINGS = [("q", "quit", "Quit")]
+
+    def __init__(
+        self,
+        source_path: Path,
+        *,
+        token_budget: int | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.source_path = source_path
+        self.token_budget = token_budget
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield RichLog(id="ingest-log", markup=True, wrap=True)
+        yield ProgressBar(id="embed-progress", show_eta=False)
+        yield StatusBar(id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._run_ingest, thread=True)
+
+    async def _run_ingest(self) -> None:
+        log = self.query_one("#ingest-log", RichLog)
+        status = self.query_one("#status-bar", StatusBar)
+        progress = self.query_one("#embed-progress", ProgressBar)
+
+        from receipts.config import load_settings
+        from receipts.ingest import artifact_extractor, scanner, secrets_scanner
+        from receipts.llm.factory import get_provider
+        from receipts.verify.kb import KnowledgeBase, default_kb_dir
+
+        log.write(f"[bold]Ingesting {self.source_path}[/bold]")
+
+        # --- Scan ---
+        status.status_text = "Scanning..."
+        result = scanner.scan(self.source_path)
+        log.write(
+            f"Scanned {len(result.files)} file(s)" f" ({len(result.text_files)} text)."
+        )
+        if result.skipped_dirs:
+            log.write(f"Skipped dependency dirs: {', '.join(result.skipped_dirs)}")
+        if result.ignored_count:
+            log.write(f"{result.ignored_count} entries excluded by .gitignore.")
+
+        # --- Secrets scan (always before anything leaves the machine) ---
+        status.status_text = "Scanning for secrets..."
+        report = secrets_scanner.SecretsReport(
+            findings=secrets_scanner.flag_special_paths(
+                [f.rel_path for f in result.files], result.venv_dirs
+            )
+        )
+        for file in result.text_files:
+            report.findings.extend(
+                secrets_scanner.scan_text(
+                    file.rel_path,
+                    scanner.read_text(self.source_path, file.rel_path),
+                )
+            )
+        if report.findings:
+            color = "red" if report.has_high_severity else "yellow"
+            log.write(
+                f"[{color}]Secrets scan: {len(report.findings)} finding(s)[/{color}]"
+            )
+            for finding in report.findings[:10]:
+                log.write(f"  [dim]{finding.rule}: {finding.rel_path}[/dim]")
+        else:
+            log.write("[green]Secrets scan: clean.[/green]")
+
+        # --- Extract ---
+        status.status_text = "Extracting artifacts..."
+        extraction = artifact_extractor.extract_artifacts(
+            self.source_path, result.files, token_budget=self.token_budget
+        )
+        budget_label = (
+            f"auto {extraction.budget:,}"
+            if extraction.auto_budget
+            else f"{extraction.budget:,}"
+        )
+        log.write(
+            f"Extracted {len(extraction.artifacts)} artifact(s),"
+            f" ~{extraction.used_tokens:,} tokens (budget {budget_label})."
+        )
+        if extraction.dropped_over_budget:
+            log.write(
+                f"[yellow]{extraction.dropped_over_budget} artifact(s)"
+                f" (~{extraction.dropped_tokens:,} tokens) dropped over budget"
+                " — raise --budget to include them.[/yellow]"
+            )
+        if extraction.redaction_count:
+            log.write(
+                f"{extraction.redaction_count} likely secret(s) redacted"
+                " from artifact content."
+            )
+
+        if not extraction.artifacts:
+            log.write("[yellow]No artifacts to store.[/yellow]")
+            status.status_text = "Done (nothing to store)"
+            return
+
+        # --- Provider + embed ---
+        settings = load_settings()
+        try:
+            provider = get_provider(settings, verify=True)
+        except Exception as exc:
+            log.write(f"[red]Provider error: {exc}[/red]")
+            status.status_text = "Error — provider"
+            return
+
+        status.provider_name = provider.name
+        if hasattr(provider, "wait_callback"):
+
+            def _on_wait(reason: str, wait: int) -> None:
+                status.status_text = f"Rate-limited — waiting {wait}s..."
+                log.write(f"[yellow]{reason} — waiting {wait}s...[/yellow]")
+
+            provider.wait_callback = _on_wait
+
+        kb = KnowledgeBase(default_kb_dir(self.source_path))
+        total = len(extraction.artifacts)
+        log.write("")
+        log.write(f"[bold]Syncing {total} artifact(s) via '{provider.name}'...[/bold]")
+        self.call_from_thread(progress.update, total=total, progress=0)
+
+        def _on_progress(done: int, _total: int) -> None:
+            # _total is the number being embedded (changed artifacts only),
+            # which can be smaller than the corpus on a re-ingest.
+            self.call_from_thread(progress.update, total=_total, progress=done)
+            status.status_text = f"Embedding {done}/{_total}..."
+
+        try:
+            stats = kb.sync_artifacts(
+                extraction.artifacts,
+                provider,
+                source=self.source_path.resolve().name,
+                on_progress=_on_progress,
+            )
+        except Exception as exc:
+            log.write(f"[red]Embedding failed: {exc}[/red]")
+            status.status_text = "Error — embedding"
+            return
+
+        if stats.embedded == 0:
+            self.call_from_thread(progress.update, total=total, progress=total)
+
+        log.write("")
+        log.write(
+            f"[bold green]Knowledge base: {stats.added} new,"
+            f" {stats.changed} changed, {stats.unchanged} unchanged,"
+            f" {stats.removed} stale removed — {kb.count()} total.[/bold green]"
+        )
+        log.write("[dim]Next: receipts tui <resume.tex> <this folder>[/dim]")
+        status.status_text = "Done"