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

receipts/tui/app.py

@@ -0,0 +1,316 @@
+"""Textual TUI for the receipts verify flow.
+
+Layout: left tree pane (ingested files), right tabbed content
+(claims table, rewrites diff, activity log), persistent status bar.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import (
+    Footer,
+    Header,
+    RichLog,
+    TabbedContent,
+    TabPane,
+    Tree,
+)
+
+from receipts.tui.widgets.claims_table import ClaimsTable
+from receipts.tui.widgets.diff_view import DiffView
+from receipts.tui.widgets.status_bar import StatusBar
+
+
+class ReceiptsApp(App):
+    """Panelled TUI for resume claim verification."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "resume claim verifier"
+
+    CSS = """
+    #tree-pane {
+        width: 30;
+        dock: left;
+        border-right: solid $primary;
+        overflow-y: auto;
+    }
+    #main-area {
+        width: 1fr;
+    }
+    #activity-log {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("c", "show_tab('claims-pane')", "Claims"),
+        ("r", "show_tab('rewrites-pane')", "Rewrites"),
+        ("l", "show_tab('log-pane')", "Log"),
+    ]
+
+    def __init__(
+        self,
+        resume_path: Path,
+        source_path: Path,
+        *,
+        threshold: float = 0.5,
+        sections: list[str] | None = None,
+        entries: list[str] | None = None,
+        kb_dir: Path | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.resume_path = resume_path
+        self.source_path = source_path
+        self.threshold = threshold
+        self.sections = sections
+        self.entries = entries
+        # Pre-resolved KB dir (git URLs / manifest aliases); None → derive
+        # from source_path like always.
+        self.kb_dir = kb_dir
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal():
+            yield Tree("Files", id="tree-pane")
+            with TabbedContent(id="main-area"):
+                with TabPane("Claims", id="claims-pane"):
+                    yield ClaimsTable(id="claims-table")
+                with TabPane("Rewrites", id="rewrites-pane"):
+                    yield DiffView(id="diff-view")
+                with TabPane("Log", id="log-pane"):
+                    yield RichLog(id="activity-log", markup=True, wrap=True)
+        yield StatusBar(id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._run_verify, thread=True)
+
+    async def _run_verify(self) -> None:
+        log = self.query_one("#activity-log", RichLog)
+        status = self.query_one("#status-bar", StatusBar)
+        table = self.query_one("#claims-table", ClaimsTable)
+        diff = self.query_one("#diff-view", DiffView)
+        tree = self.query_one("#tree-pane", Tree)
+
+        log.write("[bold]Starting verification...[/bold]")
+
+        from receipts.config import load_settings
+        from receipts.llm.factory import get_provider
+        from receipts.resume.claim_extractor import extract_claims
+        from receipts.resume.loader import load_resume
+        from receipts.verify.kb import KnowledgeBase, default_kb_dir
+        from receipts.verify.rewriter import rewrite_weak_bullets
+        from receipts.verify.verifier import (
+            group_claims_by_bullet,
+            verify_bullet_claims,
+            verify_claim,
+        )
+
+        # --- Load provider ---
+        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"
+            return
+
+        status.provider_name = provider.name
+        log.write(f"Provider: [green]{provider.name}[/green]")
+
+        # Surface rate-limit waits in the status bar instead of hanging silently.
+        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 before retrying...[/yellow]"
+                )
+
+            provider.wait_callback = _on_wait
+
+        # --- Open KB ---
+        kb_dir = self.kb_dir or default_kb_dir(self.source_path)
+        kb = KnowledgeBase(kb_dir)
+        if kb.count() == 0:
+            msg = "Knowledge base is empty. Run 'receipts ingest' first."
+            log.write(f"[red]{msg}[/red]")
+            status.status_text = "Error — empty KB"
+            return
+
+        log.write(f"Knowledge base: {kb.count()} artifact(s) in {kb_dir}")
+
+        # --- Populate file tree from KB ---
+        _populate_tree(tree, kb)
+
+        # --- Parse resume ---
+        status.status_text = "Parsing resume..."
+        log.write(f"Parsing [bold]{self.resume_path.name}[/bold] ...")
+        resume = load_resume(self.resume_path)
+        log.write(f"  Name: {resume.name}")
+        log.write(f"  Sections: {len(resume.sections)}")
+
+        claims = extract_claims(resume, sections=self.sections, entries=self.entries)
+        if self.entries:
+            log.write(f"  Scoped to entries: {', '.join(self.entries)} (+ skills)")
+        log.write(f"  Claims: {len(claims)}")
+
+        # --- Verify claims, batching per bullet on API providers ---
+        status.status_text = "Verifying claims..."
+        use_batch = provider.name != "ollama"
+        groups = group_claims_by_bullet(claims) if use_batch else [[c] for c in claims]
+        log.write("")
+        log.write(f"[bold]Verifying {len(claims)} claim(s)...[/bold]")
+        if use_batch:
+            log.write("[dim]Claims from the same bullet share one LLM call.[/dim]")
+
+        results = []
+        errors = 0
+        done = 0
+        for group in groups:
+            done += len(group)
+            status.status_text = f"Verifying {done}/{len(claims)}..."
+            try:
+                if use_batch:
+                    group_results = verify_bullet_claims(
+                        group, kb, provider, distance_threshold=self.threshold
+                    )
+                else:
+                    group_results = [
+                        verify_claim(
+                            group[0],
+                            kb,
+                            provider,
+                            distance_threshold=self.threshold,
+                        )
+                    ]
+            except Exception as exc:
+                from receipts.errors import ProviderConfigError
+
+                if isinstance(exc, ProviderConfigError):
+                    log.write(f"[red]Provider configuration error: {exc}[/red]")
+                    log.write(
+                        "[red]Aborting run — fix your .env / environment"
+                        " (run 'receipts check') and retry.[/red]"
+                    )
+                    status.status_text = "Error — provider config"
+                    return
+                errors += len(group)
+                log.write(
+                    f"  [red]ERROR verifying '{group[0].bullet_text[:50]}':"
+                    f" {exc}[/red]"
+                )
+                continue
+
+            for result in group_results:
+                results.append(result)
+                self.call_from_thread(table.add_result, result)
+
+                if result.completion:
+                    status.add_tokens(
+                        result.completion.input_tokens,
+                        result.completion.output_tokens,
+                    )
+
+                if result.verdict == "unsupported":
+                    log.write(
+                        f"  [red]✗[/red] {result.claim.claim_type}:"
+                        f" {result.claim.value}"
+                    )
+                elif result.verdict == "plausible":
+                    log.write(
+                        f"  [yellow]?[/yellow] {result.claim.claim_type}:"
+                        f" {result.claim.value}"
+                    )
+
+        if errors:
+            log.write(f"[red]{errors} claim(s) failed due to API errors.[/red]")
+
+        verified = sum(1 for r in results if r.verdict == "verified")
+        plausible = sum(1 for r in results if r.verdict == "plausible")
+        unsupported = sum(1 for r in results if r.verdict == "unsupported")
+
+        log.write("")
+        log.write(
+            f"[bold]Results:[/bold] "
+            f"[green]{verified} verified[/green], "
+            f"[yellow]{plausible} plausible[/yellow], "
+            f"[red]{unsupported} unsupported[/red]"
+        )
+
+        # --- Rewrite weak bullets ---
+        status.status_text = "Rewriting weak bullets..."
+        log.write("")
+        log.write("[bold]Generating rewrites for weak bullets...[/bold]")
+
+        try:
+            rewrites = rewrite_weak_bullets(results, provider)
+        except Exception as exc:
+            log.write(f"[red]Rewrite failed: {exc}[/red]")
+            rewrites = []
+
+        if not rewrites:
+            self.call_from_thread(diff.show_no_rewrites)
+            log.write("[green]No rewrites needed.[/green]")
+        else:
+            for rw in rewrites:
+                self.call_from_thread(diff.add_rewrite, rw)
+                if rw.completion:
+                    status.add_tokens(
+                        rw.completion.input_tokens,
+                        rw.completion.output_tokens,
+                    )
+            log.write(f"Generated {len(rewrites)} rewrite(s).")
+
+        status.status_text = "Done"
+        log.write("")
+        log.write("[bold green]Verification complete.[/bold green]")
+
+    def action_show_tab(self, tab_id: str) -> None:
+        tc = self.query_one("#main-area", TabbedContent)
+        tc.active = tab_id
+
+    def on_data_table_row_selected(self, event) -> None:
+        """Selecting a claims row shows its FULL details in the Log tab."""
+        table = self.query_one("#claims-table", ClaimsTable)
+        result = table.result_at(event.cursor_row)
+        if result is None:
+            return
+        log = self.query_one("#activity-log", RichLog)
+        log.write("")
+        log.write(f"[bold]━━━ Claim details ({result.verdict}) ━━━[/bold]")
+        log.write(
+            f"[bold]Claim:[/bold] {result.claim.claim_type} — {result.claim.value}"
+        )
+        log.write(f"[bold]Bullet:[/bold] {result.claim.bullet_text}")
+        log.write(f"[bold]Why:[/bold] {result.explanation}")
+        for e in result.evidence[:3]:
+            log.write(f"  evidence: {e.rel_path} :: {e.name}")
+        self.action_show_tab("log-pane")
+
+
+def _populate_tree(tree: Tree, kb: object) -> None:
+    """Build a tree of file paths from KB metadata."""
+    raw = kb._collection.get(include=["metadatas"])
+    paths: set[str] = set()
+    for meta in raw.get("metadatas", []) or []:
+        if meta and "rel_path" in meta:
+            paths.add(meta["rel_path"])
+
+    tree.root.expand()
+    dirs: dict[str, object] = {}
+
+    for path in sorted(paths):
+        parts = path.replace("\\", "/").split("/")
+        parent = tree.root
+        for i, part in enumerate(parts[:-1]):
+            key = "/".join(parts[: i + 1])
+            if key not in dirs:
+                dirs[key] = parent.add(part, expand=True)
+            parent = dirs[key]
+        parent.add_leaf(parts[-1])

receipts/tui/dossier_app.py

@@ -0,0 +1,170 @@
+"""Textual TUI for the dossier flow — verify, build, preview the study doc."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, Markdown, RichLog, TabbedContent, TabPane
+
+from receipts.tui.widgets.status_bar import StatusBar
+
+
+class DossierApp(App):
+    """Full-screen dossier builder with an in-app markdown preview."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "defense dossier"
+
+    CSS = """
+    #dossier-preview {
+        height: 1fr;
+        padding: 0 1;
+    }
+    #activity-log {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("p", "show_tab('preview-pane')", "Preview"),
+        ("l", "show_tab('log-pane')", "Log"),
+    ]
+
+    def __init__(
+        self,
+        resume_path: Path,
+        source_path: Path,
+        *,
+        threshold: float = 0.5,
+        sections: list[str] | None = None,
+        entries: list[str] | None = None,
+        output_path: Path | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.resume_path = resume_path
+        self.source_path = source_path
+        self.threshold = threshold
+        self.sections = sections
+        self.entries = entries
+        self.output_path = output_path or Path("dossier.md")
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with TabbedContent(id="main-area"):
+            with TabPane("Preview", id="preview-pane"):
+                yield Markdown("*Building dossier...*", id="dossier-preview")
+            with TabPane("Log", id="log-pane"):
+                yield RichLog(id="activity-log", markup=True, wrap=True)
+        yield StatusBar(id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._run_dossier, thread=True)
+
+    async def _run_dossier(self) -> None:
+        log = self.query_one("#activity-log", RichLog)
+        status = self.query_one("#status-bar", StatusBar)
+        preview = self.query_one("#dossier-preview", Markdown)
+
+        from datetime import date
+
+        from receipts.config import load_settings
+        from receipts.llm.factory import get_provider
+        from receipts.prep.dossier import build_dossier, render_markdown
+        from receipts.prep.readiness import ReadinessStore
+        from receipts.resume.claim_extractor import extract_claims
+        from receipts.resume.loader import load_resume
+        from receipts.verify.kb import KnowledgeBase, default_kb_dir
+        from receipts.verify.verifier import verify_claims
+
+        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))
+        if kb.count() == 0:
+            log.write(
+                "[red]Knowledge base is empty. Run 'receipts ingest' first.[/red]"
+            )
+            status.status_text = "Error — empty KB"
+            return
+
+        status.status_text = "Parsing resume..."
+        resume = load_resume(self.resume_path)
+        claims = extract_claims(resume, sections=self.sections, entries=self.entries)
+        log.write(f"Claims: {len(claims)}")
+
+        status.status_text = "Verifying claims..."
+        log.write(f"Verifying {len(claims)} claim(s)...")
+        try:
+            results = verify_claims(
+                claims,
+                kb,
+                provider,
+                distance_threshold=self.threshold,
+                batch=provider.name != "ollama",
+            )
+        except Exception as exc:
+            log.write(f"[red]Verification failed: {exc}[/red]")
+            status.status_text = "Error — verification"
+            return
+
+        store = ReadinessStore()
+        try:
+            weak_spots = store.weak_spots()
+        finally:
+            store.close()
+        if weak_spots:
+            log.write(f"Including {len(weak_spots)} weak spot(s) from past sessions.")
+
+        log.write("")
+        log.write("[bold]Building dossier (one LLM call per bullet)...[/bold]")
+
+        def _progress(done: int, total: int) -> None:
+            status.status_text = f"Dossier bullet {done}/{total}..."
+            log.write(f"  bullet {done}/{total}")
+
+        try:
+            entries_built = build_dossier(
+                results, provider, weak_spots=weak_spots, on_progress=_progress
+            )
+        except Exception as exc:
+            log.write(f"[red]Dossier build failed: {exc}[/red]")
+            status.status_text = "Error — dossier"
+            return
+
+        doc = render_markdown(
+            entries_built,
+            resume_name=resume.name,
+            source_name=self.source_path.name,
+            generated=date.today().isoformat(),
+        )
+        self.output_path.write_text(doc, encoding="utf-8")
+
+        self.call_from_thread(preview.update, doc)
+
+        log.write("")
+        log.write(f"[bold green]Dossier written: {self.output_path}[/bold green]")
+        log.write(f"  Bullets covered: {len(entries_built)}")
+        log.write("[dim]Press p to read it here, or open the .md file.[/dim]")
+        status.status_text = "Done"
+
+    def action_show_tab(self, tab_id: str) -> None:
+        tc = self.query_one("#main-area", TabbedContent)
+        tc.active = tab_id