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

receipts/tui/rewrite_app.py

@@ -0,0 +1,463 @@
+"""Textual TUI for the rewrite pipeline.
+
+Full-screen dashboard: verify claims, generate rewrites, show diffs,
+produce optimized .tex file, optionally compile to PDF.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, RichLog, TabbedContent, TabPane
+
+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 RewriteApp(App):
+    """Full-screen TUI for the ATS rewrite pipeline."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "rewrite pipeline"
+
+    CSS = """
+    #activity-log {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("c", "show_tab('claims-pane')", "Claims"),
+        ("r", "show_tab('rewrites-pane')", "Rewrites"),
+        ("o", "show_tab('output-pane')", "Output"),
+        ("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,
+        compile_pdf: bool = False,
+        jd_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
+        self.compile_pdf = compile_pdf
+        self.jd_path = jd_path
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        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("Output", id="output-pane"):
+                yield RichLog(id="output-log", markup=True, wrap=True)
+            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_rewrite, thread=True)
+
+    async def _run_rewrite(self) -> None:
+        log = self.query_one("#activity-log", RichLog)
+        output_log = self.query_one("#output-log", RichLog)
+        status = self.query_one("#status-bar", StatusBar)
+        table = self.query_one("#claims-table", ClaimsTable)
+        diff = self.query_one("#diff-view", DiffView)
+
+        from receipts.config import load_settings
+        from receipts.llm.factory import get_provider
+        from receipts.mine.code_metrics import mine_code_facts
+        from receipts.mine.git_evidence import mine_git_evidence
+        from receipts.resume.claim_extractor import extract_claims
+        from receipts.resume.tex_parser import parse_file
+        from receipts.rewrite.optimizer import (
+            group_results_by_bullet,
+            optimize_rewrites,
+        )
+        from receipts.rewrite.tex_rewriter import rewrite_tex
+        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,
+        )
+
+        log.write("[bold]Starting rewrite pipeline...[/bold]")
+
+        # --- Provider ---
+        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(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 ---
+        kb_dir = 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
+
+        log.write(f"Knowledge base: {kb.count()} artifact(s)")
+
+        # --- Mine provable facts (zero LLM calls) ---
+        status.status_text = "Mining code facts..."
+        code_facts = mine_code_facts(self.source_path)
+        git_ev = mine_git_evidence(self.source_path)
+        log.write("")
+        log.write("[bold]Provable facts mined from the codebase:[/bold]")
+        for line in code_facts.summary_lines():
+            log.write(f"  {line}")
+        for line in git_ev.summary_lines():
+            log.write(f"  {line}")
+
+        grounded_facts = code_facts.prompt_facts()
+        if git_ev.available:
+            grounded_facts += "\n" + git_ev.prompt_facts()
+
+        # --- Parse ---
+        status.status_text = "Parsing resume..."
+        resume = parse_file(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"Parsed [bold]{self.resume_path.name}[/bold]: {len(claims)} claim(s)"
+        )
+
+        # --- Verify, 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 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(
+            f"[green]{verified} verified[/green], "
+            f"[yellow]{plausible} plausible[/yellow], "
+            f"[red]{unsupported} unsupported[/red]"
+        )
+
+        # --- JD keywords the code can justify adding ---
+        addable_keywords: list[str] = []
+        if self.jd_path and self.jd_path.is_file():
+            from receipts.verify.keyword_gap import analyze_gap
+
+            status.status_text = "Analyzing JD keyword gap..."
+            try:
+                gap = analyze_gap(
+                    self.jd_path.read_text(encoding="utf-8"),
+                    resume,
+                    kb,
+                    provider,
+                    distance_threshold=self.threshold,
+                )
+                if gap.completion:
+                    status.add_tokens(
+                        gap.completion.input_tokens, gap.completion.output_tokens
+                    )
+                addable_keywords = [i.keyword for i in gap.addable]
+                if addable_keywords:
+                    log.write(
+                        f"Code-supported JD keywords: {', '.join(addable_keywords)}"
+                    )
+            except Exception as exc:
+                log.write(f"[yellow]Keyword gap analysis failed: {exc}[/yellow]")
+
+        # --- Rewrite (grounded in mined facts) ---
+        status.status_text = "Generating rewrites..."
+        log.write("")
+        log.write("[bold]Generating rewrites for weak bullets...[/bold]")
+
+        try:
+            rewrites = rewrite_weak_bullets(
+                results,
+                provider,
+                grounded_facts=grounded_facts or None,
+                addable_keywords=addable_keywords or None,
+            )
+        except Exception as exc:
+            log.write(f"[red]Rewrite failed: {exc}[/red]")
+            rewrites = []
+
+        # --- Score-aware pass: retry rewrites that regressed ATS dimensions ---
+        if rewrites:
+            status.status_text = "Score-aware check..."
+            try:
+                optimized = optimize_rewrites(
+                    rewrites,
+                    group_results_by_bullet(results),
+                    provider,
+                    grounded_facts=grounded_facts or None,
+                    addable_keywords=addable_keywords or None,
+                )
+                retried = sum(1 for o in optimized if o.retried)
+                fixed = sum(1 for o in optimized if o.retry_fixed)
+                if retried:
+                    log.write(
+                        f"Score-aware pass: {retried} rewrite(s) regressed,"
+                        f" {fixed} fixed on retry."
+                    )
+                rewrites = [o.result for o in optimized]
+            except Exception as exc:
+                log.write(f"[yellow]Score-aware pass failed: {exc}[/yellow]")
+
+        if not rewrites:
+            self.call_from_thread(diff.show_no_rewrites)
+            log.write("[green]All bullets verified — no rewrites needed.[/green]")
+            status.status_text = "Done (no rewrites needed)"
+            return
+
+        actual_changes = 0
+        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
+                )
+            if rw.original != rw.rewritten:
+                actual_changes += 1
+
+        log.write(
+            f"Generated {len(rewrites)} rewrite(s), {actual_changes} with changes."
+        )
+
+        if actual_changes == 0:
+            log.write("[green]No actual changes to apply.[/green]")
+            status.status_text = "Done"
+            return
+
+        # --- Surgical TeX replacement ---
+        status.status_text = "Generating .tex file..."
+        log.write("")
+        log.write("[bold]Producing optimized .tex file...[/bold]")
+
+        section_filter = self.sections[0] if self.sections else None
+        try:
+            report = rewrite_tex(
+                self.resume_path,
+                rewrites,
+                output_path=self.output_path,
+                section_filter=section_filter,
+            )
+        except Exception as exc:
+            log.write(f"[red]TeX generation failed: {exc}[/red]")
+            status.status_text = "Done (TeX generation failed)"
+            return
+
+        output_log.write("")
+        output_log.write("[bold]Optimized TeX File[/bold]")
+        output_log.write("")
+        output_log.write(f"  Replacements: [green]{report.replacements}[/green]")
+        if report.skipped:
+            output_log.write(
+                f"  Skipped:      [yellow]{report.skipped}[/yellow] "
+                f"(could not match to TeX source)"
+            )
+        output_log.write(f"  Output:       [bold]{report.output_path}[/bold]")
+
+        log.write(f"  Replacements: {report.replacements}")
+        log.write(f"  Output: {report.output_path}")
+
+        # --- Optional PDF compilation ---
+        if self.compile_pdf:
+            status.status_text = "Compiling PDF..."
+            log.write("")
+            log.write("[bold]Compiling to PDF...[/bold]")
+
+            from receipts.rewrite.compiler import compile_tex
+
+            comp = compile_tex(report.output_path)
+
+            if comp.success:
+                output_log.write("")
+                output_log.write(
+                    f"  PDF:          [bold green]{comp.pdf_path}[/bold green]"
+                )
+                output_log.write(f"  Compiler:     {comp.tool_used}")
+                log.write(
+                    f"  [green]PDF: {comp.pdf_path} (via {comp.tool_used})[/green]"
+                )
+            else:
+                output_log.write("")
+                output_log.write(
+                    f"  [yellow]PDF compilation failed: {comp.error}[/yellow]"
+                )
+                output_log.write("  You can compile manually or use Overleaf.")
+                log.write(f"  [yellow]Compilation failed: {comp.error}[/yellow]")
+
+        # --- ATS score comparison if JD provided ---
+        if self.jd_path and self.jd_path.is_file():
+            status.status_text = "Scoring..."
+            log.write("")
+            log.write("[bold]Scoring original vs optimized...[/bold]")
+
+            from receipts.ats.comparator import compare_tex_files
+
+            jd_text = self.jd_path.read_text(encoding="utf-8")
+
+            try:
+                comparison = compare_tex_files(
+                    self.resume_path, report.output_path, jd_text
+                )
+
+                output_log.write("")
+                output_log.write("[bold]━━━ ATS Score Comparison ━━━[/bold]")
+                output_log.write("")
+                output_log.write(
+                    f"  Composite: {comparison.before.composite:.1f} → "
+                    f"{comparison.after.composite:.1f}"
+                )
+
+                if comparison.improved:
+                    output_log.write(
+                        f"  [bold green]Improved by "
+                        f"{comparison.composite_delta:+.1f} points[/bold green]"
+                    )
+                else:
+                    output_log.write(
+                        f"  [bold yellow]Changed by "
+                        f"{comparison.composite_delta:+.1f} points[/bold yellow]"
+                    )
+
+                output_log.write("")
+                for d in comparison.deltas:
+                    if d.delta > 0:
+                        color = "green"
+                    elif d.delta < 0:
+                        color = "red"
+                    else:
+                        color = "dim"
+                    output_log.write(
+                        f"  [{color}]{d.name:<22} "
+                        f"{d.before:>3} → {d.after:>3}  ({d.delta:+d})[/{color}]"
+                    )
+
+                log.write(
+                    f"  Composite: {comparison.before.composite:.1f} → {comparison.after.composite:.1f}"
+                )
+            except Exception as exc:
+                log.write(f"  [red]Scoring failed: {exc}[/red]")
+
+        status.status_text = "Done"
+        log.write("")
+        log.write("[bold green]Rewrite pipeline 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")

receipts/tui/score_app.py

@@ -0,0 +1,237 @@
+"""Textual TUI for the ATS scoring & comparison flow.
+
+Full-screen dashboard: dimension scores with visual bars, bullet analysis,
+optional before/after comparison, and statistical confidence intervals.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.widgets import DataTable, Footer, Header, RichLog, TabbedContent, TabPane
+
+from receipts.tui.widgets.status_bar import StatusBar
+
+
+class ScoreApp(App):
+    """Full-screen TUI for ATS resume scoring."""
+
+    TITLE = "Receipts"
+    SUB_TITLE = "ATS score"
+
+    CSS = """
+    #score-log {
+        height: 1fr;
+    }
+    #bullet-table {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("s", "show_tab('score-pane')", "Scores"),
+        ("b", "show_tab('bullets-pane')", "Bullets"),
+        ("l", "show_tab('log-pane')", "Log"),
+    ]
+
+    def __init__(
+        self,
+        resume_path: Path,
+        jd_path: Path,
+        *,
+        compare_path: Path | None = None,
+        show_stats: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.resume_path = resume_path
+        self.jd_path = jd_path
+        self.compare_path = compare_path
+        self.show_stats = show_stats
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with TabbedContent(id="main-area"):
+            with TabPane("Scores", id="score-pane"):
+                yield RichLog(id="score-log", markup=True, wrap=True)
+            with TabPane("Bullets", id="bullets-pane"):
+                yield DataTable(id="bullet-table")
+            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:
+        bt = self.query_one("#bullet-table", DataTable)
+        bt.add_columns("Bullet", "Section", "Action Verb", "Has Number", "Words")
+        bt.cursor_type = "row"
+        bt.zebra_stripes = True
+
+        self.run_worker(self._run_score, thread=True)
+
+    async def _run_score(self) -> None:
+        score_log = self.query_one("#score-log", RichLog)
+        activity = self.query_one("#activity-log", RichLog)
+        bt = self.query_one("#bullet-table", DataTable)
+        status = self.query_one("#status-bar", StatusBar)
+
+        from receipts.ats.scorer import score_tex_file
+
+        activity.write("[bold]Starting ATS scoring...[/bold]")
+
+        if not self.resume_path.is_file():
+            activity.write(f"[red]Resume not found: {self.resume_path}[/red]")
+            return
+        if not self.jd_path.is_file():
+            activity.write(f"[red]JD file not found: {self.jd_path}[/red]")
+            return
+
+        jd_text = self.jd_path.read_text(encoding="utf-8")
+
+        status.status_text = "Scoring resume..."
+        activity.write(
+            f"Scoring [bold]{self.resume_path.name}[/bold] against [bold]{self.jd_path.name}[/bold]..."
+        )
+
+        result = score_tex_file(self.resume_path, jd_text)
+
+        activity.write(f"  Composite: {result.composite:.1f}/100")
+        activity.write(f"  Bullets analyzed: {len(result.bullet_scores)}")
+
+        # --- Render dimension scores ---
+        score_log.write("")
+        score_log.write(f"[bold]ATS Score: {result.composite:.1f}/100[/bold]")
+        score_log.write("")
+
+        for dim in result.dimensions:
+            filled = dim.score // 5
+            empty = 20 - filled
+
+            if dim.score >= 70:
+                color = "green"
+            elif dim.score >= 40:
+                color = "yellow"
+            else:
+                color = "red"
+
+            bar = f"[{color}]{'█' * filled}[/{color}]{'░' * empty}"
+            score_log.write(f"  {dim.name:<22} {dim.score:>3}/100  {bar}")
+            score_log.write(f"    [dim]{_escape(dim.detail)}[/dim]")
+            score_log.write("")
+
+        score_log.write(f"  [dim]Bullets analyzed: {len(result.bullet_scores)}[/dim]")
+
+        # --- Populate bullet table ---
+        for bs in result.bullet_scores:
+            verb_str = "[green]Yes[/green]" if bs.has_action_verb else "[red]No[/red]"
+            num_str = "[green]Yes[/green]" if bs.has_number else "[red]No[/red]"
+            text = bs.text[:80] + "..." if len(bs.text) > 80 else bs.text
+            self.call_from_thread(
+                bt.add_row, text, bs.section, verb_str, num_str, str(bs.word_count)
+            )
+
+        # --- Comparison ---
+        if self.compare_path:
+            status.status_text = "Comparing..."
+            activity.write("")
+            activity.write(
+                f"Comparing against [bold]{self.compare_path.name}[/bold]..."
+            )
+
+            if not self.compare_path.is_file():
+                activity.write(
+                    f"[red]Comparison file not found: {self.compare_path}[/red]"
+                )
+            else:
+                from receipts.ats.comparator import compare_tex_files
+
+                report = compare_tex_files(self.resume_path, self.compare_path, jd_text)
+
+                score_log.write("")
+                score_log.write("[bold]━━━ Before / After Comparison ━━━[/bold]")
+                score_log.write("")
+                score_log.write(
+                    f"  Composite: {report.before.composite:.1f} → "
+                    f"{report.after.composite:.1f} "
+                )
+
+                if report.improved:
+                    score_log.write(
+                        f"  [bold green]Improved by {report.composite_delta:+.1f} points[/bold green]"
+                    )
+                else:
+                    score_log.write(
+                        f"  [bold yellow]Changed by {report.composite_delta:+.1f} points[/bold yellow]"
+                    )
+
+                score_log.write("")
+
+                for d in report.deltas:
+                    if d.delta > 0:
+                        color = "green"
+                        arrow = "▲"
+                    elif d.delta < 0:
+                        color = "red"
+                        arrow = "▼"
+                    else:
+                        color = "dim"
+                        arrow = "─"
+
+                    score_log.write(
+                        f"  [{color}]{arrow} {d.name:<22} "
+                        f"{d.before:>3} → {d.after:>3}  ({d.delta:+d})[/{color}]"
+                    )
+
+                activity.write(f"  Composite delta: {report.composite_delta:+.1f}")
+
+                # --- Statistical analysis ---
+                if self.show_stats:
+                    status.status_text = "Computing statistics..."
+                    from receipts.ats.stats import compute_improvement
+
+                    improvement = compute_improvement(report.before, report.after)
+
+                    score_log.write("")
+                    score_log.write("[bold]━━━ Statistical Analysis ━━━[/bold]")
+                    score_log.write("")
+
+                    sig_color = "green" if improvement.significant else "yellow"
+                    score_log.write(
+                        f"  Significant: [{sig_color}]"
+                        f"{'Yes' if improvement.significant else 'No'}[/{sig_color}]"
+                    )
+                    score_log.write(
+                        f"  Bullets: {improvement.n_bullets_before} → "
+                        f"{improvement.n_bullets_after}"
+                    )
+                    score_log.write("")
+
+                    for ci, name in [
+                        (improvement.keyword_match_ci, "Keyword match"),
+                        (improvement.action_verbs_ci, "Action verbs"),
+                        (improvement.quantification_ci, "Quantification"),
+                    ]:
+                        if ci:
+                            score_log.write(
+                                f"  {name:<18} {ci.mean:+.2f} "
+                                f"\\[{ci.lower:+.2f}, {ci.upper:+.2f}] "
+                                f"({int(ci.confidence * 100)}% CI, n={ci.n_samples})"
+                            )
+
+                    activity.write(
+                        f"  Significant: {'Yes' if improvement.significant else 'No'}"
+                    )
+
+        status.status_text = "Done"
+        activity.write("")
+        activity.write("[bold green]Scoring complete.[/bold green]")
+
+    def action_show_tab(self, tab_id: str) -> None:
+        tc = self.query_one("#main-area", TabbedContent)
+        tc.active = tab_id
+
+
+def _escape(text: str) -> str:
+    return text.replace("[", "\\[")