finch-cli 0.1.1__py3-none-any.whl

finch_cli/tui.py

@@ -0,0 +1,782 @@
+"""Finch TUI - jobs / library / tailor in one terminal app."""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime
+from pathlib import Path
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical
+from textual.reactive import reactive
+from textual.screen import ModalScreen
+from textual.widgets import (
+    Button,
+    DataTable,
+    Footer,
+    Header,
+    Input,
+    Label,
+    Markdown,
+    Static,
+    TabbedContent,
+    TabPane,
+    TextArea,
+)
+
+from .fetch import FetchError, fetch_job
+from .jobs import Job, filter_jobs, load_jobs
+from .score import MatchResult, bar, score_label, score_match
+from .storage import SavedResume, list_tailored, save_tailored
+from .tailor import DEFAULT_MODEL, TailorError, detected_key_env, tailor_resume
+
+# In a pip-installed wheel the example files live alongside the package at
+# finch_cli/_data/. In a dev checkout they're at <repo>/examples/. Try both,
+# in installed-wheel order, so neither path is "the special one".
+_HERE = Path(__file__).resolve().parent
+_DATA_CANDIDATES = (_HERE / "_data", _HERE.parent / "examples")
+
+
+def _resource(name: str) -> Path | None:
+    for base in _DATA_CANDIDATES:
+        p = base / name
+        if p.exists():
+            return p
+    return None
+
+
+EXAMPLES = next((p for p in _DATA_CANDIDATES if p.exists()), _DATA_CANDIDATES[0])
+
+
+# ────────────────────────────────────────────────────────────────────────
+# helpers
+# ────────────────────────────────────────────────────────────────────────
+
+
+def _job_to_markdown(job: Job, *, match: MatchResult | None = None) -> str:
+    locs = ", ".join(job.locations) if job.locations else "-"
+    terms = ", ".join(job.terms) if job.terms else "-"
+    degrees = ", ".join(job.degrees) if job.degrees else "-"
+    spon = job.sponsorship or "-"
+    body = (
+        f"# {job.title}\n\n"
+        f"**{job.company}**  ·  {locs}\n\n"
+        f"`{job.source}` · posted {job.age_label()} ago · terms: {terms}\n\n"
+        f"degrees: {degrees}  ·  sponsorship: {spon}\n\n"
+    )
+    if match is not None and match.total > 0:
+        lbl, _ = score_label(match.score)
+        body += (
+            f"---\n\n"
+            f"### your match: **{match.score:.0f}%** ({lbl})\n\n"
+            f"`{bar(match.score, 20)}`  {match.matched_count} of {match.total} keywords\n\n"
+        )
+        if match.matched:
+            body += "**matched:** " + ", ".join(match.matched[:15])
+            if len(match.matched) > 15:
+                body += f", +{len(match.matched) - 15} more"
+            body += "\n\n"
+        if match.missing:
+            body += "**missing:** " + ", ".join(match.missing[:10])
+            if len(match.missing) > 10:
+                body += f", +{len(match.missing) - 10} more"
+            body += "\n\n"
+    body += f"---\n\nApply: {job.url or '(no link)'}\n"
+    return body
+
+
+# ────────────────────────────────────────────────────────────────────────
+# modals
+# ────────────────────────────────────────────────────────────────────────
+
+
+class FilePathScreen(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, prompt: str, default: str = "") -> None:
+        super().__init__()
+        self.prompt = prompt
+        self.default = default
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="modal_box"):
+            yield Label(self.prompt)
+            yield Input(value=self.default, id="path_input")
+            with Horizontal(id="modal_buttons"):
+                yield Button("OK", variant="primary", id="ok")
+                yield Button("Cancel", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "ok":
+            self.dismiss(self.query_one("#path_input", Input).value or None)
+        else:
+            self.dismiss(None)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value or None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class URLInputScreen(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="modal_box"):
+            yield Label("Paste a job posting URL")
+            yield Input(placeholder="https://...", id="url_input")
+            with Horizontal(id="modal_buttons"):
+                yield Button("Fetch", variant="primary", id="ok")
+                yield Button("Cancel", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "ok":
+            self.dismiss(self.query_one("#url_input", Input).value or None)
+        else:
+            self.dismiss(None)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value or None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+# ────────────────────────────────────────────────────────────────────────
+# panes
+# ────────────────────────────────────────────────────────────────────────
+
+
+class JobsPane(Container):
+    """Job browser: filter + DataTable + detail preview."""
+
+    DEFAULT_CSS = """
+    JobsPane { layout: vertical; }
+    #jobs_filter_row { height: 3; padding: 1 1 0 1; }
+    #jobs_filter_row Input { width: 1fr; margin: 0 1 0 0; }
+    #jobs_filter_row Input.narrow { width: 18; }
+    #jobs_filter_row Input.tiny { width: 14; }
+    #jobs_body { height: 1fr; padding: 1 1 0 1; }
+    #jobs_table_wrap {
+        width: 2fr;
+        border: round #2a2d34;
+        padding: 0;
+        margin: 0 1 0 0;
+        min-width: 50;
+    }
+    #jobs_detail {
+        width: 1fr;
+        border: round #f15a29 30%;
+        padding: 1 2;
+        min-width: 35;
+    }
+    DataTable { background: $surface; height: 1fr; padding: 0; }
+    #jobs_stats { dock: bottom; height: 1; color: $text-muted; padding: 0 2; }
+    """
+
+    jobs_all: reactive[list[Job]] = reactive(list, recompose=False)
+    selected_job_id: reactive[str] = reactive("")
+    base_resume_text: reactive[str] = reactive("")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._displayed: list[Job] = []
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="jobs_filter_row"):
+            yield Input(placeholder="search title / company / location...", id="jobs_filter")
+            yield Input(placeholder="source", classes="narrow", id="jobs_source")
+            yield Input(placeholder="term", classes="tiny", id="jobs_term")
+        with Horizontal(id="jobs_body"):
+            with Vertical(id="jobs_table_wrap"):
+                yield DataTable(id="jobs_table", cursor_type="row", zebra_stripes=True)
+            with Vertical(id="jobs_detail"):
+                yield Markdown("Pick a job on the left to see details.\n\nLoad a base resume (`Ctrl+O`) to see your match score per job.", id="jobs_detail_md")
+        yield Static("loading job feeds...", id="jobs_stats")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#jobs_table", DataTable)
+        table.add_columns("Title", "Company", "Loc", "Term", "Sponsorship", "Posted")
+        self._load_jobs_worker()
+
+    @work(thread=True, exclusive=True)
+    def _load_jobs_worker(self, *, force: bool = False) -> None:
+        try:
+            jobs = load_jobs(force_refresh=force)
+        except Exception as e:
+            self.app.call_from_thread(self._set_stats, f"fetch failed: {e}")
+            return
+        self.app.call_from_thread(self._apply_jobs, jobs)
+
+    def _apply_jobs(self, jobs: list[Job]) -> None:
+        self.jobs_all = jobs
+        self._rebuild_table()
+
+    def _set_stats(self, text: str) -> None:
+        try:
+            self.query_one("#jobs_stats", Static).update(text)
+        except Exception:
+            pass
+
+    def _current_filter(self) -> tuple[str, str | None, str | None]:
+        q = self.query_one("#jobs_filter", Input).value or ""
+        src = (self.query_one("#jobs_source", Input).value or "").strip().lower() or None
+        if src not in (None, "intern", "newgrad"):
+            src = None
+        term = (self.query_one("#jobs_term", Input).value or "").strip() or None
+        return q, src, term
+
+    def _rebuild_table(self) -> None:
+        q, src, term = self._current_filter()
+        filtered = filter_jobs(self.jobs_all, query=q, source=src, term_substring=term)
+        self._displayed = filtered
+        table = self.query_one("#jobs_table", DataTable)
+        table.clear()
+        for j in filtered[:1500]:
+            table.add_row(
+                j.title[:50],
+                j.company[:24],
+                j.loc_label()[:20],
+                j.term_label()[:14],
+                j.sponsorship_label()[:10],
+                j.age_label(),
+                key=j.id,
+            )
+        intern = sum(1 for j in self.jobs_all if j.source == "intern")
+        newgrad = sum(1 for j in self.jobs_all if j.source == "newgrad")
+        shown = len(filtered)
+        match_hint = (
+            "" if not self.base_resume_text.strip() else "  ·  base resume loaded, match scores visible"
+        )
+        self._set_stats(
+            f"{shown:,} shown  ·  {len(self.jobs_all):,} active  "
+            f"({intern:,} intern + {newgrad:,} new-grad)  ·  "
+            f"refreshed {datetime.now().strftime('%H:%M:%S')}{match_hint}"
+        )
+        if filtered:
+            table.move_cursor(row=0)
+            self._update_detail(filtered[0])
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id in ("jobs_filter", "jobs_source", "jobs_term"):
+            self._rebuild_table()
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        if event.row_key is None:
+            return
+        job_id = str(event.row_key.value)
+        self.selected_job_id = job_id
+        job = self._find_job(job_id)
+        if job:
+            self._update_detail(job)
+
+    def _find_job(self, job_id: str) -> Job | None:
+        for j in self._displayed:
+            if j.id == job_id:
+                return j
+        return None
+
+    def _update_detail(self, job: Job) -> None:
+        match: MatchResult | None = None
+        if self.base_resume_text.strip():
+            match = score_match(self.base_resume_text, job.title + " " + (job.category or ""))
+        try:
+            self.query_one("#jobs_detail_md", Markdown).update(
+                _job_to_markdown(job, match=match)
+            )
+        except Exception:
+            pass
+
+    def current_selection(self) -> Job | None:
+        return self._find_job(self.selected_job_id)
+
+    def refresh_feed(self) -> None:
+        self._set_stats("refetching feeds...")
+        self._load_jobs_worker(force=True)
+
+
+class LibraryPane(Container):
+    """Saved tailored resumes."""
+
+    DEFAULT_CSS = """
+    LibraryPane { layout: vertical; }
+    #lib_body { height: 1fr; padding: 1 1 0 1; }
+    #lib_table_wrap { width: 2fr; border: round #2a2d34; margin: 0 1 0 0; min-width: 50; }
+    #lib_preview_wrap { width: 1fr; border: round #f15a29 30%; padding: 1 2; min-width: 35; }
+    #lib_stats { dock: bottom; height: 1; color: $text-muted; padding: 0 2; }
+    DataTable { background: $surface; height: 1fr; }
+    """
+
+    items: reactive[list[SavedResume]] = reactive(list, recompose=False)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="lib_body"):
+            with Vertical(id="lib_table_wrap"):
+                yield DataTable(id="lib_table", cursor_type="row", zebra_stripes=True)
+            with Vertical(id="lib_preview_wrap"):
+                yield Markdown(
+                    "No tailored resumes yet.\n\nGo to the Tailor tab, run `Ctrl+T`, then `Ctrl+L` to save it here.",
+                    id="lib_preview",
+                )
+        yield Static("", id="lib_stats")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#lib_table", DataTable)
+        table.add_columns("Date", "Company", "Title", "Size")
+        self.reload()
+
+    def reload(self) -> None:
+        items = list_tailored()
+        self.items = items
+        table = self.query_one("#lib_table", DataTable)
+        table.clear()
+        for r in items:
+            table.add_row(
+                r.timestamp.strftime("%Y-%m-%d %H:%M"),
+                r.company[:24],
+                r.title[:40],
+                f"{r.size_bytes:,}",
+                key=str(r.path),
+            )
+        self.query_one("#lib_stats", Static).update(
+            f"{len(items)} saved tailored resume(s)  ·  ~/.local/share/finch-cli/resumes/"
+        )
+        if items:
+            table.move_cursor(row=0)
+            self._show(items[0])
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        if event.row_key is None:
+            return
+        path = Path(str(event.row_key.value))
+        item = next((r for r in self.items if r.path == path), None)
+        if item:
+            self._show(item)
+
+    def _show(self, item: SavedResume) -> None:
+        try:
+            text = item.path.read_text(encoding="utf-8")
+            self.query_one("#lib_preview", Markdown).update(text)
+        except Exception as e:
+            self.query_one("#lib_preview", Markdown).update(f"Could not read {item.path}: {e}")
+
+
+class MatchPanel(Container):
+    """Bottom-of-tailor panel: ATS-style score + matched / missing keywords."""
+
+    DEFAULT_CSS = """
+    MatchPanel {
+        height: 9;
+        border: round #f15a29 50%;
+        padding: 0 2;
+        margin: 1 1 0 1;
+    }
+    #match_title { color: $accent; text-style: bold; height: 1; }
+    #match_score_row { height: 1; }
+    #match_score_row > Static { height: 1; }
+    #match_score_label { width: auto; padding: 0 2 0 0; }
+    #match_score_bar { width: 1fr; color: #f4a261; }
+    #match_score_delta { width: auto; padding: 0 0 0 2; color: $text-muted; }
+    #match_matched { color: #a8d2a0; height: 2; }
+    #match_missing { color: #f4a261; height: 2; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static("Match analysis", id="match_title")
+        with Horizontal(id="match_score_row"):
+            yield Static("no resume + job loaded", id="match_score_label")
+            yield Static("", id="match_score_bar")
+            yield Static("", id="match_score_delta")
+        yield Static("matched:  -", id="match_matched")
+        yield Static("missing:  -", id="match_missing")
+
+    def update_match(
+        self,
+        *,
+        base: MatchResult | None,
+        tailored: MatchResult | None,
+    ) -> None:
+        focus = tailored if (tailored and tailored.total > 0) else base
+        if not focus or focus.total == 0:
+            self.query_one("#match_score_label", Static).update("no resume + job loaded")
+            self.query_one("#match_score_bar", Static).update("")
+            self.query_one("#match_score_delta", Static).update("")
+            self.query_one("#match_matched", Static).update("matched:  -")
+            self.query_one("#match_missing", Static).update("missing:  -")
+            return
+
+        lbl, color = score_label(focus.score)
+        self.query_one("#match_score_label", Static).update(
+            f"[{color}]{focus.score:>5.1f}% {lbl}[/]  ·  {focus.matched_count} of {focus.total} keywords"
+        )
+        self.query_one("#match_score_bar", Static).update(bar(focus.score, 30))
+        if base and tailored and base.total > 0:
+            delta = tailored.score - base.score
+            sign = "+" if delta >= 0 else ""
+            color_d = "green" if delta > 0 else ("red" if delta < 0 else "white")
+            self.query_one("#match_score_delta", Static).update(
+                f"[dim]base[/] {base.score:.0f}%  →  [{color_d}]{sign}{delta:.0f}[/]"
+            )
+        else:
+            self.query_one("#match_score_delta", Static).update("")
+
+        matched_str = ", ".join(focus.matched[:18])
+        if len(focus.matched) > 18:
+            matched_str += f", +{len(focus.matched) - 18} more"
+        self.query_one("#match_matched", Static).update(
+            f"[green]✓ matched ({focus.matched_count}):[/] {matched_str or '-'}"
+        )
+        missing_str = ", ".join(focus.missing[:14])
+        if len(focus.missing) > 14:
+            missing_str += f", +{len(focus.missing) - 14} more"
+        self.query_one("#match_missing", Static).update(
+            f"[#f4a261]✗ missing ({len(focus.missing)}):[/] {missing_str or '-'}"
+        )
+
+
+class TailorPane(Container):
+    """Three-pane editor + match-analysis panel."""
+
+    DEFAULT_CSS = """
+    TailorPane { layout: vertical; }
+    #tailor_row { height: 1fr; padding: 1 1 0 1; }
+    .tailor_col {
+        width: 1fr;
+        border: round #2a2d34;
+        margin: 0 1 0 0;
+        min-width: 30;
+    }
+    .tailor_col:last-of-type { margin-right: 0; }
+    .tailor_col Label.pane_label {
+        height: 1; background: #f15a29 25%; color: #fff1e1;
+        padding: 0 1; text-style: bold;
+    }
+    TextArea { height: 1fr; border: none; padding: 0 1; }
+    #tailor_status { dock: bottom; height: 1; color: $text-muted; padding: 0 2; }
+    """
+
+    busy: reactive[bool] = reactive(False)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="tailor_row"):
+            with Vertical(classes="tailor_col"):
+                yield Label("Base resume (markdown)", classes="pane_label")
+                yield TextArea.code_editor("", language="markdown", id="resume_ta")
+            with Vertical(classes="tailor_col"):
+                yield Label("Job posting", classes="pane_label")
+                yield TextArea("", id="job_ta")
+            with Vertical(classes="tailor_col"):
+                yield Label("Tailored resume", classes="pane_label")
+                yield TextArea.code_editor("", language="markdown", read_only=True, id="out_ta")
+        yield MatchPanel(id="match_panel")
+        yield Static(
+            "Ctrl+T tailor  ·  Ctrl+U paste URL  ·  Ctrl+O open resume  ·  Ctrl+L save to library  ·  Ctrl+S save to file",
+            id="tailor_status",
+        )
+
+    def set_resume(self, text: str) -> None:
+        self.query_one("#resume_ta", TextArea).text = text
+        self.recompute_match()
+
+    def set_job(self, text: str) -> None:
+        self.query_one("#job_ta", TextArea).text = text
+        self.recompute_match()
+
+    def load_demo(self) -> None:
+        rp = EXAMPLES / "base_resume.md"
+        jp = EXAMPLES / "job_post.txt"
+        if rp.exists():
+            self.query_one("#resume_ta", TextArea).text = rp.read_text(encoding="utf-8")
+        if jp.exists():
+            self.query_one("#job_ta", TextArea).text = jp.read_text(encoding="utf-8")
+        self.query_one("#tailor_status", Static).update("demo loaded  ·  Ctrl+T to tailor")
+        self.recompute_match()
+
+    def get_resume(self) -> str:
+        return self.query_one("#resume_ta", TextArea).text
+
+    def get_job(self) -> str:
+        return self.query_one("#job_ta", TextArea).text
+
+    def get_output(self) -> str:
+        return self.query_one("#out_ta", TextArea).text
+
+    def set_output(self, text: str) -> None:
+        self.query_one("#out_ta", TextArea).text = text
+        self.recompute_match()
+
+    def set_status(self, text: str) -> None:
+        self.query_one("#tailor_status", Static).update(text)
+
+    def recompute_match(self) -> None:
+        resume = self.get_resume()
+        job = self.get_job()
+        out = self.get_output()
+        base = score_match(resume, job)
+        tailored = score_match(out, job) if out.strip() else None
+        try:
+            self.query_one(MatchPanel).update_match(base=base, tailored=tailored)
+        except Exception:
+            pass
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        # Debounced match recompute would be nicer; keystroke recompute is
+        # cheap enough at this corpus size.
+        if event.text_area.id in ("resume_ta", "job_ta", "out_ta"):
+            self.recompute_match()
+
+
+# ────────────────────────────────────────────────────────────────────────
+# app
+# ────────────────────────────────────────────────────────────────────────
+
+
+class FinchTUI(App):
+    """Finch terminal client."""
+
+    CSS = """
+    Screen { layout: vertical; background: #16181d; }
+    Header { background: #f15a29 20%; color: #f7d4a4; }
+    #branding {
+        dock: top; height: 1; background: #f15a29 30%;
+        color: #fff1e1; padding: 0 2; layout: horizontal;
+    }
+    #branding > Label { width: 1fr; }
+    #branding > .right { width: auto; color: #fcc28b; text-align: right; }
+    TabbedContent { height: 1fr; }
+    TabPane { padding: 0; }
+    Tabs { background: #1d2026; }
+    Tabs > Tab { color: #d0d4dc; padding: 0 2; }
+    Tabs > Tab:focus { color: #ffb781; }
+    Tabs > Tab.-active { background: #f15a29 25%; color: #fff1e1; text-style: bold; }
+    DataTable { background: #16181d; color: #d0d4dc; }
+    DataTable > .datatable--header { background: #2a2d34; color: #f4a261; text-style: bold; }
+    DataTable > .datatable--cursor { background: #f15a29 25%; }
+    DataTable > .datatable--odd-row { background: #1a1d23; }
+    Markdown { background: #16181d; color: #d0d4dc; padding: 0; }
+    Markdown > MarkdownH1 { color: #f4a261; text-style: bold; }
+    Markdown > MarkdownH3 { color: #f4a261; text-style: bold; }
+    Markdown > MarkdownFence { background: #1d2026; }
+    Input { background: #1d2026; color: #d0d4dc; border: round #2a2d34; }
+    Input:focus { border: round #f15a29; }
+    TextArea { background: #16181d; color: #d0d4dc; }
+    #modal_box {
+        background: #1d2026; border: thick #f15a29; padding: 1 2;
+        width: 70; max-width: 90%; height: auto; offset: 50% 30%;
+    }
+    #modal_buttons { height: 3; padding-top: 1; align: center middle; }
+    Button { margin: 0 1; }
+    Footer { background: #1d2026; color: #d0d4dc; }
+    Footer > .footer--highlight { background: #f15a29 50%; color: #fff1e1; }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+t", "tailor_action", "Tailor", priority=True),
+        Binding("ctrl+u", "paste_url", "Paste URL"),
+        Binding("ctrl+o", "open_resume", "Open resume"),
+        Binding("ctrl+s", "save_file", "Save to file"),
+        Binding("ctrl+l", "save_library", "Save to library"),
+        Binding("ctrl+r", "refresh_jobs", "Refresh jobs"),
+        Binding("ctrl+d", "load_demo", "Demo"),
+        Binding("ctrl+q", "quit", "Quit", priority=True),
+        Binding("1", "show_jobs", "Jobs", show=False),
+        Binding("2", "show_library", "Library", show=False),
+        Binding("3", "show_tailor", "Tailor", show=False),
+    ]
+
+    TITLE = "finch  ·  applyfinch.com"
+
+    def __init__(self, *, demo: bool = False, model: str = DEFAULT_MODEL) -> None:
+        super().__init__()
+        self.demo = demo
+        self.model = model
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        with Horizontal(id="branding"):
+            yield Label(
+                "Finch  ·  tailor resumes for any job, from your terminal",
+                id="brand_left",
+            )
+            key_env = detected_key_env()
+            key_state = key_env if key_env else "unset"
+            yield Label(
+                f"model: {self.model}  ·  key: {key_state}",
+                classes="right",
+            )
+        with TabbedContent(initial="tab_jobs", id="tabs"):
+            with TabPane("Jobs", id="tab_jobs"):
+                yield JobsPane()
+            with TabPane("Library", id="tab_library"):
+                yield LibraryPane()
+            with TabPane("Tailor", id="tab_tailor"):
+                yield TailorPane()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        if self.demo:
+            self.query_one(TailorPane).load_demo()
+            # Also push the demo resume into JobsPane so per-job scores show
+            self.query_one(JobsPane).base_resume_text = self.query_one(TailorPane).get_resume()
+
+    # ── tab nav ──
+    def action_show_jobs(self) -> None:
+        self.query_one(TabbedContent).active = "tab_jobs"
+
+    def action_show_library(self) -> None:
+        self.query_one(TabbedContent).active = "tab_library"
+        self.query_one(LibraryPane).reload()
+
+    def action_show_tailor(self) -> None:
+        self.query_one(TabbedContent).active = "tab_tailor"
+        self.query_one(TailorPane).recompute_match()
+
+    # ── actions ──
+    def action_refresh_jobs(self) -> None:
+        self.query_one(JobsPane).refresh_feed()
+
+    def action_load_demo(self) -> None:
+        self.query_one(TailorPane).load_demo()
+        self.query_one(JobsPane).base_resume_text = self.query_one(TailorPane).get_resume()
+        self.action_show_tailor()
+
+    def action_paste_url(self) -> None:
+        self.push_screen(URLInputScreen(), self._on_url_entered)
+
+    def _on_url_entered(self, url: str | None) -> None:
+        if not url:
+            return
+        tailor = self.query_one(TailorPane)
+        tailor.set_status(f"fetching {url}...")
+        self.action_show_tailor()
+        self._fetch_job_url(url)
+
+    @work(thread=True)
+    def _fetch_job_url(self, url: str) -> None:
+        try:
+            text = fetch_job(url)
+        except FetchError as e:
+            self.call_from_thread(self.query_one(TailorPane).set_status, f"fetch failed: {e}")
+            return
+        except Exception as e:
+            self.call_from_thread(
+                self.query_one(TailorPane).set_status, f"{type(e).__name__}: {e}"
+            )
+            return
+
+        def apply() -> None:
+            tailor = self.query_one(TailorPane)
+            tailor.set_job(text)
+            tailor.set_status(f"fetched {len(text):,} chars from {url}")
+
+        self.call_from_thread(apply)
+
+    def action_open_resume(self) -> None:
+        default = str(EXAMPLES / "base_resume.md")
+        self.push_screen(FilePathScreen("Open base resume", default), self._on_resume_chosen)
+
+    def _on_resume_chosen(self, path: str | None) -> None:
+        if not path:
+            return
+        p = Path(path).expanduser()
+        if not p.exists():
+            self.query_one(TailorPane).set_status(f"file not found: {p}")
+            return
+        try:
+            text = p.read_text(encoding="utf-8")
+            self.query_one(TailorPane).set_resume(text)
+            self.query_one(JobsPane).base_resume_text = text
+            self.query_one(TailorPane).set_status(f"loaded {p}")
+            self.action_show_tailor()
+        except Exception as e:
+            self.query_one(TailorPane).set_status(f"open failed: {e}")
+
+    def action_save_file(self) -> None:
+        self.push_screen(FilePathScreen("Save tailored resume to file", "tailored.md"), self._on_save_chosen)
+
+    def _on_save_chosen(self, path: str | None) -> None:
+        if not path:
+            return
+        p = Path(path).expanduser()
+        try:
+            p.write_text(self.query_one(TailorPane).get_output(), encoding="utf-8")
+            self.query_one(TailorPane).set_status(f"saved to {p}")
+        except Exception as e:
+            self.query_one(TailorPane).set_status(f"save failed: {e}")
+
+    def action_save_library(self) -> None:
+        out = self.query_one(TailorPane).get_output().strip()
+        if not out:
+            self.query_one(TailorPane).set_status("nothing to save (output is empty)")
+            return
+        job = self.query_one(JobsPane).current_selection()
+        company = job.company if job else "manual"
+        title = job.title if job else "tailored"
+        p = save_tailored(out, company=company, title=title)
+        self.query_one(TailorPane).set_status(f"saved to library: {p}")
+        self.query_one(LibraryPane).reload()
+
+    def action_tailor_action(self) -> None:
+        tabs = self.query_one(TabbedContent)
+        if tabs.active == "tab_jobs":
+            job = self.query_one(JobsPane).current_selection()
+            if job:
+                self.query_one(TailorPane).set_job(_job_to_markdown(job))
+                self.action_show_tailor()
+        if self.query_one(TailorPane).busy:
+            return
+        self._run_tailor()
+
+    def _run_tailor(self) -> None:
+        tailor = self.query_one(TailorPane)
+        resume = tailor.get_resume().strip()
+        job = tailor.get_job().strip()
+        if not resume:
+            tailor.set_status("base resume is empty - load one with Ctrl+O")
+            self.action_show_tailor()
+            return
+        if not job:
+            tailor.set_status("job posting is empty - pick one from Jobs tab or paste with Ctrl+U")
+            self.action_show_tailor()
+            return
+        if not detected_key_env():
+            tailor.set_status(
+                "no API key set - export DEEPSEEK_API_KEY (or FINCH_API_KEY, or OPENAI_API_KEY) and relaunch"
+            )
+            self.action_show_tailor()
+            return
+        tailor.busy = True
+        tailor.set_status("tailoring against the job...")
+        tailor.set_output("")
+        self.action_show_tailor()
+        self._tailor_worker(resume, job)
+
+    @work(thread=True)
+    def _tailor_worker(self, resume: str, job: str) -> None:
+        try:
+            out = tailor_resume(resume, job, model=self.model)
+        except TailorError as e:
+            self.call_from_thread(self._finish_tailor, None, str(e))
+            return
+        except Exception as e:
+            self.call_from_thread(self._finish_tailor, None, f"{type(e).__name__}: {e}")
+            return
+        self.call_from_thread(self._finish_tailor, out, None)
+
+    def _finish_tailor(self, out: str | None, err: str | None) -> None:
+        tailor = self.query_one(TailorPane)
+        tailor.busy = False
+        if err:
+            tailor.set_status(f"tailoring failed: {err}")
+            return
+        tailor.set_output(out or "")
+        tailor.set_status(
+            f"done  ·  {len(out or ''):,} chars  ·  Ctrl+L save to library, Ctrl+S save to file"
+        )
+
+
+def run(*, demo: bool = False, model: str = DEFAULT_MODEL) -> None:
+    FinchTUI(demo=demo, model=model).run()