interview-coach-cli 0.3.0__py3-none-any.whl

meeting_plans.py

@@ -0,0 +1,218 @@
+"""
+Meeting Plans — per-conversation game plans.
+
+A MeetingPlan captures the shape of a specific upcoming conversation so the
+coach can give structured, context-aware guidance during it. Think of it as
+what a prep coach would write for you before a big call.
+
+Fields mirror how you'd think about ANY high-stakes conversation:
+  * purpose        — what you want out of this specific conversation
+  * counterparty   — who you're talking with (name + role)
+  * duration_min   — planned length, so section allocations make sense
+  * sections       — ordered agenda blocks (title, minutes, goal)
+  * answers_prep   — things you're prepared to be asked about
+  * questions_ask  — questions you want to ask them
+  * traps_avoid    — mistakes to preempt (e.g. "don't oversell the AI angle")
+  * commitments    — concrete outcomes you want to leave with
+
+Storage lives in the same SQLite DB as sessions/profiles.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime
+from typing import Optional
+
+from sessions import _connect
+
+
+def _ensure_schema():
+    with _connect() as conn:
+        conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS meeting_plans (
+                id             INTEGER PRIMARY KEY AUTOINCREMENT,
+                profile_id     INTEGER,
+                title          TEXT NOT NULL,
+                counterparty   TEXT,
+                purpose        TEXT,
+                duration_min   INTEGER,
+                sections_json  TEXT NOT NULL DEFAULT '[]',
+                answers_json   TEXT NOT NULL DEFAULT '[]',
+                questions_json TEXT NOT NULL DEFAULT '[]',
+                traps_json     TEXT NOT NULL DEFAULT '[]',
+                commitments_json TEXT NOT NULL DEFAULT '[]',
+                notes          TEXT DEFAULT '',
+                created_at     TEXT NOT NULL,
+                updated_at     TEXT NOT NULL
+            );
+            """
+        )
+        # Add plan_id to sessions so a session can be linked to a plan
+        try:
+            conn.execute("ALTER TABLE sessions ADD COLUMN plan_id INTEGER")
+        except sqlite3.OperationalError:
+            pass
+        # Add briefing + raw research to plans (migration for older DBs)
+        for col in ("briefing TEXT DEFAULT ''", "raw_research_json TEXT DEFAULT ''"):
+            try:
+                conn.execute(f"ALTER TABLE meeting_plans ADD COLUMN {col}")
+            except sqlite3.OperationalError:
+                pass
+
+
+_ensure_schema()
+
+
+def _now() -> str:
+    return datetime.utcnow().isoformat(timespec="seconds")
+
+
+def create_plan(
+    title: str,
+    profile_id: Optional[int] = None,
+    counterparty: str = "",
+    purpose: str = "",
+    duration_min: int = 45,
+    sections: Optional[list[dict]] = None,
+    answers_prep: Optional[list[str]] = None,
+    questions_ask: Optional[list[str]] = None,
+    traps_avoid: Optional[list[str]] = None,
+    commitments: Optional[list[str]] = None,
+    notes: str = "",
+) -> int:
+    now = _now()
+    with _connect() as conn:
+        cur = conn.execute(
+            """
+            INSERT INTO meeting_plans (
+                profile_id, title, counterparty, purpose, duration_min,
+                sections_json, answers_json, questions_json, traps_json,
+                commitments_json, notes, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                profile_id, title, counterparty, purpose, duration_min,
+                json.dumps(sections or []),
+                json.dumps(answers_prep or []),
+                json.dumps(questions_ask or []),
+                json.dumps(traps_avoid or []),
+                json.dumps(commitments or []),
+                notes, now, now,
+            ),
+        )
+        return cur.lastrowid
+
+
+def list_plans(profile_id: Optional[int] = None, limit: int = 30) -> list[sqlite3.Row]:
+    with _connect() as conn:
+        if profile_id is not None:
+            cur = conn.execute(
+                "SELECT * FROM meeting_plans WHERE profile_id = ? "
+                "ORDER BY updated_at DESC LIMIT ?",
+                (profile_id, limit),
+            )
+        else:
+            cur = conn.execute(
+                "SELECT * FROM meeting_plans ORDER BY updated_at DESC LIMIT ?",
+                (limit,),
+            )
+        return cur.fetchall()
+
+
+def get_plan(plan_id: int) -> Optional[dict]:
+    with _connect() as conn:
+        cur = conn.execute("SELECT * FROM meeting_plans WHERE id = ?", (plan_id,))
+        row = cur.fetchone()
+    if not row:
+        return None
+    d = dict(row)
+    for k in ("sections", "answers", "questions", "traps", "commitments"):
+        d[k if k == "sections" else f"{k}_prep" if k == "answers" else
+          f"{k}_ask" if k == "questions" else
+          f"{k}_avoid" if k == "traps" else
+          k] = json.loads(d.pop(f"{k}_json", "[]"))
+    # Clean up mapping
+    d.setdefault("answers_prep", d.pop("answers", []) if "answers" in d else [])
+    d.setdefault("questions_ask", d.pop("questions", []) if "questions" in d else [])
+    d.setdefault("traps_avoid", d.pop("traps", []) if "traps" in d else [])
+    return d
+
+
+def update_plan(plan_id: int, **fields):
+    if not fields:
+        return
+    now = _now()
+    list_fields = {
+        "sections": "sections_json",
+        "answers_prep": "answers_json",
+        "questions_ask": "questions_json",
+        "traps_avoid": "traps_json",
+        "commitments": "commitments_json",
+    }
+    sets = []
+    vals: list = []
+    for k, v in fields.items():
+        if k in list_fields:
+            sets.append(f"{list_fields[k]} = ?")
+            vals.append(json.dumps(v))
+        else:
+            sets.append(f"{k} = ?")
+            vals.append(v)
+    sets.append("updated_at = ?")
+    vals.append(now)
+    vals.append(plan_id)
+    with _connect() as conn:
+        conn.execute(f"UPDATE meeting_plans SET {', '.join(sets)} WHERE id = ?", vals)
+
+
+def delete_plan(plan_id: int):
+    with _connect() as conn:
+        conn.execute("DELETE FROM meeting_plans WHERE id = ?", (plan_id,))
+
+
+def render_plan_for_prompt(plan: dict) -> str:
+    """Format a plan for injection into the LLM system prompt."""
+    lines = [
+        f"MEETING PLAN — {plan.get('title', '(untitled)')}",
+        f"Counterparty: {plan.get('counterparty') or '(not specified)'}",
+        f"Purpose: {plan.get('purpose') or '(not specified)'}",
+        f"Planned duration: {plan.get('duration_min') or '?'} minutes",
+    ]
+
+    sections = plan.get("sections", []) or []
+    if sections:
+        lines.append("\nAGENDA")
+        for i, s in enumerate(sections, 1):
+            title = s.get("title", "(untitled)")
+            minutes = s.get("minutes", "?")
+            goal = s.get("goal", "")
+            lines.append(f"  {i}. [{minutes} min] {title}")
+            if goal:
+                lines.append(f"     Goal: {goal}")
+
+    for label, key in [
+        ("ANSWERS TO PREPARE", "answers_prep"),
+        ("QUESTIONS TO ASK THEM", "questions_ask"),
+        ("TRAPS TO AVOID", "traps_avoid"),
+        ("COMMITMENTS TO SECURE", "commitments"),
+    ]:
+        items = plan.get(key, []) or []
+        if items:
+            lines.append(f"\n{label}")
+            for it in items:
+                lines.append(f"  • {it}")
+
+    notes = plan.get("notes", "").strip()
+    if notes:
+        lines.append(f"\nNOTES\n{notes}")
+
+    briefing = (plan.get("briefing") or "").strip()
+    if briefing:
+        lines.append("\n" + "─" * 60)
+        lines.append("COUNTERPARTY BRIEFING (from research):")
+        lines.append("─" * 60)
+        lines.append(briefing)
+
+    return "\n".join(lines)

onboarding.py

@@ -0,0 +1,189 @@
+"""
+Onboarding wizard: profile creation, template selection, profile management.
+
+Runs automatically when no profile exists; can be re-run with --onboard.
+"""
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+import profile_store
+from templates import list_template_choices
+
+console = Console()
+
+
+def _multiline_input(prompt: str, placeholder: str = "") -> str:
+    """Read multi-line input until an empty line."""
+    console.print(f"[cyan]{prompt}[/]")
+    if placeholder:
+        console.print(f"[dim]  Example: {placeholder}[/]")
+    console.print("[dim]  (Blank line ends input, Enter to skip)[/]")
+    lines = []
+    while True:
+        try:
+            line = input("  ▸ ")
+        except EOFError:
+            break
+        if line == "":
+            break
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def create_profile_wizard() -> int:
+    console.print(
+        Panel(
+            Text("Let's build your profile — this is what tailors every answer.",
+                 style="bold white"),
+            title="[bold bright_green]👤 New profile[/]",
+            border_style="bright_green",
+            padding=(1, 2),
+        )
+    )
+
+    name = ""
+    while not name:
+        name = console.input("[cyan]  Your name[/]: ").strip()
+    pronouns = console.input("[cyan]  Pronouns[/] [dim](she/her, he/him, they/them)[/]: ").strip() or "they/them"
+
+    console.print()
+    background = _multiline_input(
+        "Your background",
+        "AI/software engineer with a BSc in CS from KNUST. Have stuttered since childhood.",
+    )
+    console.print()
+    target_role = console.input(
+        "[cyan]  What role or opportunity are you preparing for?[/]\n  ▸ "
+    ).strip()
+    console.print()
+    strengths = _multiline_input(
+        "Strengths to lean on (things you want the coach to surface)",
+        "Cross-domain thinking; lived experience of stuttering; ML systems.",
+    )
+    console.print()
+    weaknesses = _multiline_input(
+        "Weaknesses to defuse (things to preempt without dwelling on)",
+        "No formal neuroscience training yet; first-time PhD applicant.",
+    )
+    console.print()
+    extra = _multiline_input(
+        "Anything else the coach should know (upcoming calls, key people, quirks)?",
+        "Call with Dr. Toyomura late Sep; Dr. Höbler Nov 6.",
+    )
+
+    pid = profile_store.create_profile(
+        name=name,
+        pronouns=pronouns,
+        background=background,
+        target_role=target_role,
+        strengths=strengths,
+        weaknesses=weaknesses,
+        extra_context=extra,
+    )
+    profile_store.set_active_profile(pid)
+    console.print(f"\n[green]  ✓ Profile #{pid} created and set active.[/]\n")
+    return pid
+
+
+def pick_or_create_profile() -> int:
+    """If any profiles exist, let user pick/create. Otherwise run first-time wizard."""
+    profiles = profile_store.list_profiles()
+
+    if not profiles:
+        console.print(
+            Panel(
+                Text("First time here? Let's set up your profile.",
+                     style="bold white"),
+                title="[bold bright_cyan]Welcome[/]",
+                border_style="bright_cyan",
+                padding=(1, 2),
+            )
+        )
+        return create_profile_wizard()
+
+    table = Table(title="Your profiles", border_style="dim")
+    table.add_column("#", style="bold cyan", width=3)
+    table.add_column("Name", style="white")
+    table.add_column("Target", style="yellow")
+    table.add_column("Active", style="green")
+    for i, p in enumerate(profiles, 1):
+        active_mark = "✓" if p["is_active"] else ""
+        table.add_row(str(i), p["name"], p["target_role"] or "-", active_mark)
+    console.print(table)
+
+    while True:
+        raw = console.input(
+            "\n[bold]Pick profile[/]: [cyan]<number>[/]  "
+            "[bold green]n[/]=new  [bold red]d<number>[/]=delete  "
+            "[dim](Enter=keep active)[/] ▸ "
+        ).strip().lower()
+
+        active = profile_store.get_active_profile()
+        if raw == "" and active:
+            return active["id"]
+        if raw == "n":
+            return create_profile_wizard()
+        if raw.startswith("d") and raw[1:].isdigit():
+            idx = int(raw[1:]) - 1
+            if 0 <= idx < len(profiles):
+                profile_store.delete_profile(profiles[idx]["id"])
+                console.print(f"[red]  ✗ Deleted profile '{profiles[idx]['name']}'[/]\n")
+                return pick_or_create_profile()
+        if raw.isdigit():
+            idx = int(raw) - 1
+            if 0 <= idx < len(profiles):
+                pid = profiles[idx]["id"]
+                profile_store.set_active_profile(pid)
+                return pid
+        console.print("[yellow]  Invalid choice.[/]")
+
+
+def pick_template(default: str = "academic-phd") -> str:
+    choices = list_template_choices()
+
+    table = Table(title="Interview / conversation templates", border_style="dim")
+    table.add_column("#", style="bold cyan", width=3)
+    table.add_column("Template", style="white")
+    table.add_column("ID", style="dim")
+    for i, (tid, label) in enumerate(choices, 1):
+        marker = "  ← default" if tid == default else ""
+        table.add_row(str(i), label + marker, tid)
+    console.print(table)
+
+    while True:
+        raw = console.input(
+            f"\n[bold]Pick template (1-{len(choices)}, Enter for default)[/] ▸ "
+        ).strip()
+        if raw == "":
+            return default
+        if raw.isdigit() and 1 <= int(raw) <= len(choices):
+            return choices[int(raw) - 1][0]
+        console.print("[yellow]  Invalid choice.[/]")
+
+
+def edit_profile_wizard(profile_id: int):
+    p = profile_store.get_profile(profile_id)
+    if not p:
+        console.print("[red]  Profile not found.[/]")
+        return
+
+    console.print(f"\n[bold]Editing profile:[/] {p['name']}\n")
+    fields = ["name", "pronouns", "background", "target_role",
+              "strengths", "weaknesses", "extra_context"]
+    updates = {}
+    for f in fields:
+        current = p[f] or ""
+        preview = (current[:60] + "…") if len(current) > 60 else current
+        console.print(f"[dim]  {f}: {preview}[/]")
+        new = console.input(f"  [cyan]{f}[/] [dim](Enter to keep)[/] ▸ ").strip()
+        if new:
+            updates[f] = new
+    if updates:
+        profile_store.update_profile(profile_id, **updates)
+        console.print(f"\n[green]  ✓ Updated {len(updates)} field(s).[/]\n")
+    else:
+        console.print("\n[dim]  No changes.[/]\n")

plan_wizard.py

@@ -0,0 +1,175 @@
+"""
+Interactive wizard to build a MeetingPlan.
+
+Two paths:
+  * `create_plan_wizard()`  — fully interactive, asks every field
+  * `create_plan_from_template(name, profile_id)` — preload common shapes
+
+The templates encode structures like the one drafted for the Eric Jackson call
+so users can start from a working plan and just fill in specifics.
+"""
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+import meeting_plans
+
+console = Console()
+
+
+def _multiline(label: str, placeholder: str = "") -> str:
+    console.print(f"[cyan]  {label}[/]")
+    if placeholder:
+        console.print(f"[dim]    e.g. {placeholder}[/]")
+    console.print("[dim]    (empty line ends)[/]")
+    lines = []
+    while True:
+        try:
+            line = input("    ▸ ")
+        except EOFError:
+            break
+        if line == "":
+            break
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def _list_input(label: str, placeholder: str = "") -> list[str]:
+    console.print(f"[cyan]  {label}[/]")
+    if placeholder:
+        console.print(f"[dim]    e.g. {placeholder}[/]")
+    console.print("[dim]    (one per line; empty line ends)[/]")
+    items = []
+    while True:
+        try:
+            line = input(f"    {len(items)+1}. ").strip()
+        except EOFError:
+            break
+        if not line:
+            break
+        items.append(line)
+    return items
+
+
+def _sections_input() -> list[dict]:
+    console.print("[cyan]  Agenda sections[/] [dim](title, minutes, goal — empty title to finish)[/]")
+    sections = []
+    while True:
+        try:
+            title = input(f"    Section {len(sections)+1} title ▸ ").strip()
+        except EOFError:
+            break
+        if not title:
+            break
+        try:
+            minutes_raw = input(f"      minutes ▸ ").strip()
+            minutes = int(minutes_raw) if minutes_raw.isdigit() else 5
+            goal = input(f"      goal ▸ ").strip()
+        except EOFError:
+            break
+        sections.append({"title": title, "minutes": minutes, "goal": goal})
+    return sections
+
+
+def create_plan_wizard(profile_id: int | None = None) -> int:
+    console.print(Panel(
+        Text("Meeting plan — set the shape of the conversation so the coach can guide you live.",
+             style="bold white"),
+        title="[bold bright_cyan]📋 New meeting plan[/]",
+        border_style="bright_cyan",
+        padding=(1, 2),
+    ))
+
+    title = ""
+    while not title:
+        title = console.input("[cyan]  Plan title[/] [dim](e.g. 'Call with Dr. Eric Jackson — NYU')[/]: ").strip()
+    counterparty = console.input("[cyan]  Counterparty[/] [dim](name + role)[/]: ").strip()
+    purpose = console.input("[cyan]  Purpose of this conversation[/]:\n    ▸ ").strip()
+    duration_raw = console.input("[cyan]  Planned duration in minutes[/] [dim](Enter for 45)[/]: ").strip()
+    duration_min = int(duration_raw) if duration_raw.isdigit() else 45
+
+    console.print()
+    sections = _sections_input()
+    console.print()
+    answers_prep = _list_input("Things you should be ready to ANSWER",
+                                "Why research and not just personal? / How your AI background fits")
+    console.print()
+    questions_ask = _list_input("Questions you want to ASK them",
+                                 "Are you taking students for 2027? / Who else would you point me to?")
+    console.print()
+    traps_avoid = _list_input("Traps to avoid",
+                              "Don't oversell AI angle / Don't dwell on personal story")
+    console.print()
+    commitments = _list_input("Concrete commitments to leave with",
+                              "Follow-up email in 2 weeks / Reading list from them / Next call date")
+    console.print()
+    notes = _multiline("Any other notes",
+                       "'She emphasises variability in her 2021 paper'")
+
+    pid = meeting_plans.create_plan(
+        title=title,
+        profile_id=profile_id,
+        counterparty=counterparty,
+        purpose=purpose,
+        duration_min=duration_min,
+        sections=sections,
+        answers_prep=answers_prep,
+        questions_ask=questions_ask,
+        traps_avoid=traps_avoid,
+        commitments=commitments,
+        notes=notes,
+    )
+    console.print(f"\n[green]  ✓ Plan #{pid} saved.[/]\n")
+    return pid
+
+
+def pick_plan(profile_id: int | None = None) -> int | None:
+    """Show a picker. Returns plan_id, or None if user picked 'no plan'."""
+    rows = meeting_plans.list_plans(profile_id=profile_id, limit=20)
+    if not rows:
+        console.print("[dim]  No meeting plans saved.[/]")
+        raw = console.input(
+            "[bold]Create one now?[/] [green]y[/]=create  [dim]Enter[/]=skip ▸ "
+        ).strip().lower()
+        if raw == "y":
+            return create_plan_wizard(profile_id=profile_id)
+        return None
+
+    table = Table(title="Meeting plans", border_style="dim")
+    table.add_column("#", style="bold cyan", width=3)
+    table.add_column("Title", style="white")
+    table.add_column("Counterparty", style="yellow")
+    table.add_column("Sections", style="green", justify="right")
+    table.add_column("Updated", style="dim")
+    for i, r in enumerate(rows, 1):
+        import json
+        n_sections = len(json.loads(r["sections_json"] or "[]"))
+        table.add_row(
+            str(i), r["title"], r["counterparty"] or "-",
+            str(n_sections), r["updated_at"].replace("T", " "),
+        )
+    console.print(table)
+
+    while True:
+        raw = console.input(
+            "\n[bold]Pick plan[/]: [cyan]<n>[/]=use  [bold green]n[/]=new  "
+            "[bold red]d<n>[/]=delete  [dim]Enter[/]=no plan ▸ "
+        ).strip().lower()
+        if raw == "":
+            return None
+        if raw == "n":
+            return create_plan_wizard(profile_id=profile_id)
+        if raw.startswith("d") and raw[1:].isdigit():
+            idx = int(raw[1:]) - 1
+            if 0 <= idx < len(rows):
+                meeting_plans.delete_plan(rows[idx]["id"])
+                console.print(f"[red]  ✗ Deleted '{rows[idx]['title']}'[/]")
+                return pick_plan(profile_id=profile_id)
+        if raw.isdigit():
+            idx = int(raw) - 1
+            if 0 <= idx < len(rows):
+                return rows[idx]["id"]
+        console.print("[yellow]  Invalid choice.[/]")

profile_store.py

@@ -0,0 +1,118 @@
+"""
+User profile storage — one profile per user, stored in the sessions DB.
+
+A profile is the personal context the LLM needs to give tailored answers:
+name, background, target role, key strengths, weaknesses to defuse, and
+free-form context. No hardcoded names anywhere in the codebase.
+"""
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime
+from typing import Optional
+
+from sessions import _connect
+
+
+def _ensure_schema():
+    with _connect() as conn:
+        conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS profiles (
+                id             INTEGER PRIMARY KEY AUTOINCREMENT,
+                name           TEXT NOT NULL,
+                pronouns       TEXT,
+                background     TEXT,
+                target_role    TEXT,
+                strengths      TEXT,
+                weaknesses     TEXT,
+                extra_context  TEXT,
+                is_active      INTEGER NOT NULL DEFAULT 0,
+                created_at     TEXT NOT NULL,
+                updated_at     TEXT NOT NULL
+            );
+            """
+        )
+        # Add profile_id column to sessions (migration for older DBs)
+        try:
+            conn.execute("ALTER TABLE sessions ADD COLUMN profile_id INTEGER")
+        except sqlite3.OperationalError:
+            pass
+        try:
+            conn.execute("ALTER TABLE sessions ADD COLUMN template_id TEXT")
+        except sqlite3.OperationalError:
+            pass
+
+
+_ensure_schema()
+
+
+def create_profile(name: str, **fields) -> int:
+    now = datetime.utcnow().isoformat(timespec="seconds")
+    cols = ["name", "pronouns", "background", "target_role",
+            "strengths", "weaknesses", "extra_context", "is_active",
+            "created_at", "updated_at"]
+    vals = [
+        name,
+        fields.get("pronouns", ""),
+        fields.get("background", ""),
+        fields.get("target_role", ""),
+        fields.get("strengths", ""),
+        fields.get("weaknesses", ""),
+        fields.get("extra_context", ""),
+        0,
+        now, now,
+    ]
+    with _connect() as conn:
+        cur = conn.execute(
+            f"INSERT INTO profiles ({','.join(cols)}) VALUES ({','.join(['?'] * len(cols))})",
+            vals,
+        )
+        pid = cur.lastrowid
+    # If no active profile exists, make this the active one
+    if get_active_profile() is None:
+        set_active_profile(pid)
+    return pid
+
+
+def list_profiles() -> list[sqlite3.Row]:
+    with _connect() as conn:
+        cur = conn.execute(
+            "SELECT * FROM profiles ORDER BY is_active DESC, updated_at DESC"
+        )
+        return cur.fetchall()
+
+
+def get_profile(profile_id: int) -> Optional[sqlite3.Row]:
+    with _connect() as conn:
+        cur = conn.execute("SELECT * FROM profiles WHERE id = ?", (profile_id,))
+        return cur.fetchone()
+
+
+def get_active_profile() -> Optional[sqlite3.Row]:
+    with _connect() as conn:
+        cur = conn.execute("SELECT * FROM profiles WHERE is_active = 1 LIMIT 1")
+        return cur.fetchone()
+
+
+def set_active_profile(profile_id: int):
+    with _connect() as conn:
+        conn.execute("UPDATE profiles SET is_active = 0")
+        conn.execute("UPDATE profiles SET is_active = 1 WHERE id = ?", (profile_id,))
+
+
+def update_profile(profile_id: int, **fields):
+    if not fields:
+        return
+    now = datetime.utcnow().isoformat(timespec="seconds")
+    set_clause = ", ".join(f"{k} = ?" for k in fields)
+    with _connect() as conn:
+        conn.execute(
+            f"UPDATE profiles SET {set_clause}, updated_at = ? WHERE id = ?",
+            [*fields.values(), now, profile_id],
+        )
+
+
+def delete_profile(profile_id: int):
+    with _connect() as conn:
+        conn.execute("DELETE FROM profiles WHERE id = ?", (profile_id,))