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

receipts/tui/ama_app.py

@@ -0,0 +1,454 @@
+"""Textual TUI for the AMA / mock-interview mode.
+
+Chat-style interface: questions appear in the log, user types answers
+in an input box at the bottom, verdicts and summaries are color-coded.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Footer, Header, Input, RichLog
+
+from receipts.tui.widgets.status_bar import StatusBar
+
+
+class AmaApp(App):
+    """Chat-style TUI for mock interviews."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "mock interview"
+
+    CSS = """
+    #chat-log {
+        height: 1fr;
+        border-bottom: solid $primary;
+    }
+    #answer-input {
+        dock: bottom;
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "quit", "Quit"),
+    ]
+
+    def __init__(
+        self,
+        resume_path: Path,
+        source_path: Path,
+        *,
+        n_rounds: int = 5,
+        threshold: float = 0.5,
+        sections: list[str] | None = None,
+        entries: list[str] | None = None,
+        style: str | None = None,
+        save_session: bool = True,
+        kb_dir: Path | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.resume_path = resume_path
+        self.source_path = source_path
+        self.n_rounds = n_rounds
+        self.threshold = threshold
+        self.sections = sections
+        self.entries = entries
+        self.style = style
+        self.save_session = save_session
+        # Pre-resolved KB dir (git URLs / manifest aliases); None → derive
+        # from source_path like always.
+        self.kb_dir = kb_dir
+        self._pending_answer: str | None = None
+        self._waiting_for_input = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield RichLog(id="chat-log", markup=True, wrap=True)
+        yield StatusBar(id="status-bar")
+        inp = Input(
+            placeholder="Type your answer here...",
+            id="answer-input",
+            disabled=True,
+        )
+        yield inp
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._run_interview, thread=True)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if not self._waiting_for_input:
+            return
+        self._pending_answer = event.value
+        event.input.value = ""
+        event.input.disabled = True
+        self._waiting_for_input = False
+
+    def _ask_user(self, log: RichLog, inp: Input) -> str:
+        """Block the worker thread until the user submits an answer."""
+        import time
+
+        self._pending_answer = None
+        self._waiting_for_input = True
+        self.call_from_thread(self._enable_input)
+        while self._pending_answer is None:
+            time.sleep(0.05)
+        answer = self._pending_answer
+        log.write(f"[dim]You:[/dim] {answer}")
+        log.write("")
+        return answer
+
+    def _enable_input(self) -> None:
+        inp = self.query_one("#answer-input", Input)
+        inp.disabled = False
+        inp.focus()
+
+    async def _run_interview(self) -> None:
+        log = self.query_one("#chat-log", RichLog)
+        status = self.query_one("#status-bar", StatusBar)
+        inp = self.query_one("#answer-input", Input)
+
+        from receipts.ama.interviewer import (
+            InterviewRound,
+            assess_answer,
+            generate_follow_up,
+            generate_model_answer,
+            generate_question,
+            generate_summary,
+            select_bullets,
+        )
+        from receipts.config import load_settings
+        from receipts.llm.factory import get_provider
+        from receipts.llm.provider import CompletionResult
+        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 (
+            group_claims_by_bullet,
+            verify_bullet_claims,
+            verify_claim,
+        )
+
+        # --- Setup ---
+        settings = load_settings()
+        try:
+            provider = get_provider(settings, verify=True)
+        except Exception as exc:
+            log.write(f"[red]Provider error: {exc}[/red]")
+            log.write(
+                "[red]Check your .env config and that your provider is running.[/red]"
+            )
+            return
+
+        status.provider_name = provider.name
+        log.write("[bold]Preparing interview...[/bold]")
+        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
+
+        kb_dir = self.kb_dir or default_kb_dir(self.source_path)
+        kb = KnowledgeBase(kb_dir)
+        if kb.count() == 0:
+            log.write(
+                "[red]Knowledge base is empty. Run 'receipts ingest' first.[/red]"
+            )
+            return
+
+        # --- Verify claims first ---
+        status.status_text = "Verifying claims..."
+        resume = load_resume(self.resume_path)
+        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"Verifying {len(claims)} claim(s)...")
+
+        use_batch = provider.name != "ollama"
+        groups = group_claims_by_bullet(claims) if use_batch else [[c] for c in claims]
+
+        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,
+                        )
+                    ]
+                for r in group_results:
+                    results.append(r)
+                    if r.completion:
+                        status.add_tokens(
+                            r.completion.input_tokens, r.completion.output_tokens
+                        )
+            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 — fix your .env / environment"
+                        " (run 'receipts check') and retry.[/red]"
+                    )
+                    return
+                errors += len(group)
+                log.write(
+                    f"[red]Error verifying '{group[0].bullet_text[:60]}':"
+                    f" {exc}[/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(
+            f"[green]{verified} verified[/green], "
+            f"[yellow]{plausible} plausible[/yellow], "
+            f"[red]{unsupported} unsupported[/red]"
+        )
+        if errors:
+            log.write(f"[red]{errors} claim(s) failed due to API errors.[/red]")
+        log.write("")
+
+        # --- Select bullets ---
+        selected = select_bullets(results, self.n_rounds)
+        if not selected:
+            log.write("[yellow]No bullets to interview on.[/yellow]")
+            return
+
+        log.write(f"[bold]Starting mock interview — {len(selected)} round(s).[/bold]")
+        log.write("[dim]Type your answers below. Press Escape to quit early.[/dim]")
+        log.write("")
+
+        # --- Interview loop ---
+        interview_rounds: list[InterviewRound] = []
+
+        for i, result in enumerate(selected, 1):
+            status.status_text = f"Round {i}/{len(selected)}"
+
+            verdict_color = {
+                "verified": "green",
+                "plausible": "yellow",
+                "unsupported": "red",
+            }.get(result.verdict, "white")
+
+            log.write(f"[bold]━━━ Round {i}/{len(selected)} ━━━[/bold]")
+            log.write(
+                f"[{verdict_color}][{result.verdict}][/{verdict_color}] "
+                f"{result.claim.bullet_text[:120]}"
+            )
+            log.write("")
+
+            # --- Question ---
+            status.status_text = f"Round {i} — generating question..."
+            try:
+                question, q_comp = generate_question(result, provider, style=self.style)
+            except Exception as exc:
+                log.write(f"[red]Error generating question: {exc}[/red]")
+                log.write("[dim]Skipping this round...[/dim]")
+                log.write("")
+                continue
+            status.add_tokens(q_comp.input_tokens, q_comp.output_tokens)
+
+            log.write(f"[bold cyan]Q:[/bold cyan] {question}")
+            log.write("")
+
+            # --- User answer ---
+            answer = self._ask_user(log, inp)
+            if answer.strip().lower() in ("quit", "q"):
+                log.write("[dim]Interview ended early.[/dim]")
+                break
+
+            # --- Follow-up ---
+            status.status_text = f"Round {i} — follow-up..."
+            try:
+                follow_up, fu_comp = generate_follow_up(question, answer, provider)
+            except Exception as exc:
+                log.write(f"[red]Error generating follow-up: {exc}[/red]")
+                follow_up = "Could you elaborate on your answer?"
+                fu_comp = CompletionResult(
+                    text="",
+                    input_tokens=0,
+                    output_tokens=0,
+                    provider=provider.name,
+                    model="fallback",
+                )
+            status.add_tokens(fu_comp.input_tokens, fu_comp.output_tokens)
+
+            log.write(f"[bold cyan]Follow-up:[/bold cyan] {follow_up}")
+            log.write("")
+
+            # --- Follow-up answer ---
+            fu_answer = self._ask_user(log, inp)
+            if fu_answer.strip().lower() in ("quit", "q"):
+                log.write("[dim]Interview ended early.[/dim]")
+                break
+
+            # --- Assessment ---
+            status.status_text = f"Round {i} — assessing..."
+            combined = f"{answer}\n\nFollow-up: {fu_answer}"
+            try:
+                held_up, assessment, a_comp = assess_answer(
+                    result.claim.bullet_text, question, combined, provider
+                )
+            except Exception as exc:
+                log.write(f"[red]Error assessing answer: {exc}[/red]")
+                held_up = False
+                assessment = "Assessment failed due to API error."
+                a_comp = CompletionResult(
+                    text="",
+                    input_tokens=0,
+                    output_tokens=0,
+                    provider=provider.name,
+                    model="fallback",
+                )
+            status.add_tokens(a_comp.input_tokens, a_comp.output_tokens)
+
+            if held_up:
+                log.write(f"[bold green]Held up:[/bold green] {assessment}")
+            else:
+                log.write(f"[bold red]Did not hold up:[/bold red] {assessment}")
+            log.write("")
+
+            # --- Model answer (the reveal) ---
+            status.status_text = f"Round {i} — model answer..."
+            try:
+                model_answer, ma_comp = generate_model_answer(
+                    result, question, provider
+                )
+            except Exception as exc:
+                log.write(f"[red]Error generating model answer: {exc}[/red]")
+                model_answer = ""
+                ma_comp = CompletionResult(
+                    text="",
+                    input_tokens=0,
+                    output_tokens=0,
+                    provider=provider.name,
+                    model="fallback",
+                )
+            status.add_tokens(ma_comp.input_tokens, ma_comp.output_tokens)
+
+            if model_answer:
+                log.write(
+                    f"[bold blue]A strong, honest answer:[/bold blue] {model_answer}"
+                )
+                log.write("")
+
+            interview_rounds.append(
+                InterviewRound(
+                    bullet_text=result.claim.bullet_text,
+                    section=result.claim.section,
+                    heading=result.claim.entry_heading,
+                    verdict=result.verdict,
+                    question=question,
+                    answer=answer,
+                    follow_up=follow_up,
+                    follow_up_answer=fu_answer,
+                    held_up=held_up,
+                    assessment=assessment,
+                    model_answer=model_answer,
+                    completions=[q_comp, fu_comp, a_comp, ma_comp],
+                )
+            )
+
+        if not interview_rounds:
+            return
+
+        # --- Summary ---
+        status.status_text = "Generating summary..."
+        log.write("[bold]━━━ Interview Summary ━━━[/bold]")
+        log.write("")
+
+        try:
+            summary = generate_summary(interview_rounds, provider)
+        except Exception as exc:
+            log.write(f"[red]Error generating summary: {exc}[/red]")
+            held = sum(1 for r in interview_rounds if r.held_up)
+            total = len(interview_rounds)
+            log.write(f"[bold]Score: {held}/{total} rounds held up.[/bold]")
+            status.status_text = "Interview complete (summary failed)"
+            return
+
+        if summary.completion:
+            status.add_tokens(
+                summary.completion.input_tokens,
+                summary.completion.output_tokens,
+            )
+
+        if summary.strong:
+            log.write("[bold green]Strengths:[/bold green]")
+            for pt in summary.strong:
+                log.write(f"  [green]+[/green] {pt}")
+            log.write("")
+
+        if summary.weak:
+            log.write("[bold red]Weaknesses:[/bold red]")
+            for pt in summary.weak:
+                log.write(f"  [red]-[/red] {pt}")
+            log.write("")
+
+        log.write(f"[bold]Overall:[/bold] {summary.overall}")
+        log.write("")
+
+        held = sum(1 for r in interview_rounds if r.held_up)
+        total = len(interview_rounds)
+        log.write(f"[bold]Score: {held}/{total} rounds held up.[/bold]")
+
+        # --- Persist for readiness tracking ---
+        if self.save_session:
+            try:
+                from receipts.prep.readiness import ReadinessStore, readiness_delta
+
+                store = ReadinessStore()
+                try:
+                    store.save_session(
+                        interview_rounds,
+                        resume_name=resume.name,
+                        source=str(self.source_path),
+                    )
+                    sessions = store.sessions(resume_name=resume.name)
+                finally:
+                    store.close()
+
+                log.write("")
+                log.write(
+                    "[dim]Session saved — run 'receipts readiness' to"
+                    " track progress.[/dim]"
+                )
+                delta = readiness_delta(sessions)
+                if delta:
+                    latest, previous = delta
+                    change = (latest - previous) * 100
+                    color = "green" if change >= 0 else "red"
+                    log.write(
+                        f"[{color}]Held-up rate: {latest:.0%}"
+                        f" ({change:+.0f} pts vs previous session)[/{color}]"
+                    )
+            except Exception as exc:
+                log.write(f"[yellow]Could not save session: {exc}[/yellow]")
+
+        status.status_text = "Interview complete"