draftpilot 0.1.0__py3-none-any.whl

draftpilot/__init__.py

@@ -0,0 +1,3 @@
+"""DraftPilot - Dead man's switch email outreach with AI personalization."""
+
+__version__ = "0.1.0"

draftpilot/__main__.py

@@ -0,0 +1,5 @@
+"""Enable `python -m draftpilot`."""
+
+from draftpilot.cli import app
+
+app()

draftpilot/cli.py

@@ -0,0 +1,78 @@
+"""DraftPilot CLI - Dead man's switch email outreach with AI personalization."""
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(
+    name="draftpilot",
+    help="Dead man's switch email outreach with AI personalization.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def draft(
+    batch: int = typer.Option(50, help="Number of emails per batch"),
+    csv: str = typer.Option("companies.csv", help="Path to companies CSV"),
+    delay: int = typer.Option(6, help="Hours before auto-send"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Generate without creating drafts"),
+):
+    """Generate personalized email drafts from a CSV of companies."""
+    from draftpilot.drafts import run
+    run(batch, csv, delay, dry_run)
+
+
+@app.command()
+def send():
+    """Check drafts and auto-send those past the validation window."""
+    from draftpilot.sender import run
+    run()
+
+
+@app.command()
+def status(
+    today: bool = typer.Option(False, "--today", help="Show today's stats only"),
+    list_all: bool = typer.Option(False, "--list", help="List all emails"),
+    check_drafts: bool = typer.Option(False, "--check-drafts", help="Check drafts for issues"),
+):
+    """Display outreach pipeline statistics."""
+    from draftpilot.dashboard import show_stats, list_emails, check_draft_issues
+    show_stats(today_only=today)
+    if list_all:
+        list_emails()
+    if check_drafts:
+        check_draft_issues()
+
+
+@app.command()
+def find(
+    csv: str = typer.Option(..., help="CSV with company_name column"),
+    output: str = typer.Option(None, help="Output CSV path"),
+    no_rekrute: bool = typer.Option(False, "--no-rekrute", help="Skip Rekrute.com"),
+    no_hunter: bool = typer.Option(False, "--no-hunter", help="Skip Hunter.io"),
+    no_llm: bool = typer.Option(False, "--no-llm", help="Skip LLM descriptions"),
+):
+    """Find recruitment emails for companies via web scraping."""
+    from draftpilot.finder import run
+    run(csv, output, not no_rekrute, not no_hunter, not no_llm)
+
+
+@app.command()
+def validate(
+    csv: str = typer.Option("companies.csv", help="Path to companies CSV"),
+):
+    """Validate email addresses (syntax + MX record check)."""
+    from draftpilot.validator import run
+    run(csv)
+
+
+@app.command()
+def auth():
+    """Authenticate with Gmail (first-time OAuth setup)."""
+    from draftpilot.gmail import setup_auth
+    setup_auth()
+
+
+if __name__ == "__main__":
+    app()

draftpilot/config.py

@@ -0,0 +1,168 @@
+"""Central configuration for DraftPilot.
+
+Resolves config directory, loads profile/templates, provides LLM client
+and signature rendering. All personal info comes from profile.yaml.
+"""
+
+import os
+from string import Template
+from pathlib import Path
+import yaml
+
+_profile_cache = None
+_templates_cache = None
+_llm_client = None
+
+
+def _resolve_config_dir() -> Path:
+    """Find the config directory. Priority: env var > ./config/ > ~/.draftpilot/"""
+    env = os.environ.get("DRAFTPILOT_CONFIG")
+    if env:
+        return Path(env).expanduser()
+
+    local = Path("config")
+    if local.is_dir() and (local / "profile.yaml").exists():
+        return local
+
+    home = Path.home() / ".draftpilot"
+    return home
+
+
+def get_config_dir() -> Path:
+    return _resolve_config_dir()
+
+
+def get_profile() -> dict:
+    global _profile_cache
+    if _profile_cache is not None:
+        return _profile_cache
+
+    config_dir = _resolve_config_dir()
+    profile_path = config_dir / "profile.yaml"
+
+    if not profile_path.exists():
+        raise FileNotFoundError(
+            f"Profile not found at {profile_path}. "
+            f"Copy examples/profile.yaml to {config_dir}/ and fill in your info."
+        )
+
+    with open(profile_path, "r", encoding="utf-8") as f:
+        _profile_cache = yaml.safe_load(f)
+
+    return _profile_cache
+
+
+def get_templates() -> dict:
+    global _templates_cache
+    if _templates_cache is not None:
+        return _templates_cache
+
+    config_dir = _resolve_config_dir()
+    templates_path = config_dir / "templates.yaml"
+
+    if not templates_path.exists():
+        raise FileNotFoundError(
+            f"Templates not found at {templates_path}. "
+            f"Copy examples/templates.yaml to {config_dir}/."
+        )
+
+    with open(templates_path, "r", encoding="utf-8") as f:
+        _templates_cache = yaml.safe_load(f)
+
+    return _templates_cache
+
+
+def get_db_path() -> str:
+    config_dir = _resolve_config_dir()
+    return str(config_dir / "state.db")
+
+
+def get_llm_client():
+    global _llm_client
+    if _llm_client is not None:
+        return _llm_client
+
+    from openai import OpenAI
+
+    profile = get_profile()
+    llm = profile.get("llm", {})
+
+    base_url = llm.get("base_url", "https://api.cerebras.ai/v1")
+    api_key_env = llm.get("api_key_env", "CEREBRAS_API_KEY")
+    api_key = os.environ.get(api_key_env)
+
+    if not api_key:
+        raise ValueError(
+            f"{api_key_env} not set. Export it: export {api_key_env}='your-key-here'"
+        )
+
+    _llm_client = OpenAI(base_url=base_url, api_key=api_key)
+    return _llm_client
+
+
+def get_gmail_paths() -> tuple:
+    """Returns (credentials_path, token_path)."""
+    profile = get_profile()
+    gmail = profile.get("gmail", {})
+    config_dir = _resolve_config_dir()
+
+    creds = gmail.get("credentials_path", "credentials.json")
+    token = gmail.get("token_path", "token.json")
+
+    creds_path = Path(creds).expanduser()
+    token_path = Path(token).expanduser()
+
+    if not creds_path.is_absolute():
+        creds_path = config_dir / creds_path
+    if not token_path.is_absolute():
+        token_path = config_dir / token_path
+
+    return str(creds_path), str(token_path)
+
+
+def _build_template_context(profile: dict) -> dict:
+    """Build a flat dict for Template substitution."""
+    edu = profile.get("education", {})
+    return {
+        "name": profile.get("name", ""),
+        "phone": profile.get("phone", ""),
+        "portfolio": profile.get("portfolio", ""),
+        "cv": profile.get("cv", ""),
+        "school_short": edu.get("school_short", ""),
+        "degree_short_fr": edu.get("degree_short_fr", ""),
+        "degree_short_en": edu.get("degree_short_en", ""),
+    }
+
+
+def render_signature(language: str, profile: dict = None) -> str:
+    """Render the email signature from profile config."""
+    if profile is None:
+        profile = get_profile()
+
+    sig_templates = profile.get("signature", {})
+    lang_key = "fr" if language.lower() == "fr" else "en"
+    sig_template = sig_templates.get(lang_key, "$name")
+
+    ctx = _build_template_context(profile)
+    return Template(sig_template).safe_substitute(ctx)
+
+
+def render_subject_fallback(language: str, profile: dict = None) -> str:
+    """Render the subject line fallback from profile config."""
+    if profile is None:
+        profile = get_profile()
+
+    fallbacks = profile.get("subject_fallback", {})
+    lang_key = "fr" if language.lower() == "fr" else "en"
+    fallback = fallbacks.get(lang_key, "")
+
+    ctx = _build_template_context(profile)
+    return Template(fallback).safe_substitute(ctx)
+
+
+def reset_cache():
+    """Reset all cached config. Useful for testing."""
+    global _profile_cache, _templates_cache, _llm_client
+    _profile_cache = None
+    _templates_cache = None
+    _llm_client = None

draftpilot/dashboard.py

@@ -0,0 +1,173 @@
+"""Status dashboard for the outreach pipeline.
+
+Displays statistics, lists emails, and checks drafted emails for common issues.
+"""
+
+from datetime import datetime
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from draftpilot import db
+
+console = Console()
+
+
+def show_stats(today_only: bool = False):
+    stats = db.get_today_stats() if today_only else db.get_stats()
+    period = "Today" if today_only else "All time"
+
+    total = sum(stats.values())
+    drafted = stats.get("drafted", 0)
+    sent = stats.get("sent", 0)
+    cancelled = stats.get("cancelled", 0)
+    errors = stats.get("error", 0)
+    pending = stats.get("pending", 0)
+
+    lines = [
+        f"Period:     {period}",
+        f"Date:       {datetime.now().strftime('%Y-%m-%d %H:%M')}",
+        "",
+        f"Total:      {total}",
+        f"Pending:    {pending}",
+        f"Drafted:    {drafted}  (awaiting review)",
+        f"Sent:       {sent}",
+        f"Cancelled:  {cancelled}  (you deleted the draft)",
+        f"Errors:     {errors}",
+    ]
+    if total > 0:
+        lines.append(f"Send rate:  {sent / total * 100:.1f}%")
+        if cancelled > 0:
+            lines.append(f"Veto rate:  {cancelled / total * 100:.1f}%")
+
+    console.print(Panel("\n".join(lines), title="Email Outreach Dashboard", border_style="blue"))
+
+
+def list_emails():
+    conn = db.get_conn()
+    rows = conn.execute("""
+        SELECT id, company_name, email, status, template_used, subject,
+               created_at, sent_at
+        FROM emails
+        ORDER BY created_at DESC
+        LIMIT 100
+    """).fetchall()
+    conn.close()
+
+    if not rows:
+        console.print("\nNo emails in the database yet.\n")
+        return
+
+    table = Table(title="Recent Emails (last 100)")
+    table.add_column("ID", style="dim", width=5)
+    table.add_column("Status", width=11)
+    table.add_column("Company", width=25)
+    table.add_column("Email", width=30)
+    table.add_column("Subject", width=40)
+
+    status_labels = {
+        "pending": "[yellow]PENDING[/yellow]",
+        "drafted": "[cyan]DRAFTED[/cyan]",
+        "sent": "[green]SENT[/green]",
+        "cancelled": "[red]CANCELLED[/red]",
+        "error": "[bold red]ERROR[/bold red]",
+    }
+
+    for row in rows:
+        label = status_labels.get(row["status"], row["status"])
+        subject = (row["subject"] or "")[:38]
+        company = (row["company_name"] or "")[:23]
+        email = (row["email"] or "")[:28]
+
+        table.add_row(str(row["id"]), label, company, email, subject)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def check_draft_issues():
+    """Check drafted emails for common issues.
+
+    Looks for:
+    - Empty or very short body text
+    - Wrong call-to-action dates (e.g. dates in the past)
+    - Duplicate or misplaced signatures
+    """
+    from draftpilot.config import get_profile
+    profile = get_profile()
+    user_name = profile.get("name", "")
+
+    conn = db.get_conn()
+    rows = conn.execute("""
+        SELECT id, company_name, email, subject, body
+        FROM emails
+        WHERE status = 'drafted'
+        ORDER BY created_at DESC
+    """).fetchall()
+    conn.close()
+
+    if not rows:
+        console.print("\nNo drafted emails to check.\n")
+        return
+
+    issues_found = 0
+
+    table = Table(title="Draft Issues Report")
+    table.add_column("ID", style="dim", width=5)
+    table.add_column("Company", width=25)
+    table.add_column("Issue", width=50)
+
+    for row in rows:
+        row_issues = []
+        body = row["body"] or ""
+        subject = row["subject"] or ""
+
+        # Check for empty or very short body
+        if len(body.strip()) < 50:
+            row_issues.append("Body is empty or very short (under 50 chars)")
+
+        # Check for empty subject
+        if len(subject.strip()) == 0:
+            row_issues.append("Subject line is empty")
+
+        # Check for wrong call dates (dates in the past)
+        now = datetime.now()
+        import re
+        date_patterns = re.findall(r'\d{1,2}/\d{1,2}/\d{4}', body)
+        for date_str in date_patterns:
+            try:
+                d = datetime.strptime(date_str, "%d/%m/%Y")
+                if d < now:
+                    row_issues.append(f"Past date found in body: {date_str}")
+            except ValueError:
+                pass
+
+        # Check for duplicate signatures
+        if user_name:
+            name_count = body.lower().count(user_name.lower())
+            if name_count > 1:
+                row_issues.append(
+                    f"Possible duplicate signature ({user_name} appears {name_count} times)"
+                )
+
+        for issue in row_issues:
+            company = (row["company_name"] or "")[:23]
+            table.add_row(str(row["id"]), company, issue)
+            issues_found += 1
+
+    console.print()
+    if issues_found == 0:
+        console.print(Panel(
+            f"Checked {len(rows)} drafted email(s) - no issues found.",
+            title="Draft Check",
+            border_style="green",
+        ))
+    else:
+        console.print(table)
+        console.print(Panel(
+            f"Found {issues_found} issue(s) across {len(rows)} drafted email(s).",
+            title="Draft Check",
+            border_style="yellow",
+        ))

draftpilot/db.py

@@ -0,0 +1,159 @@
+"""SQLite state management for the email pipeline.
+
+Tracks every email through its lifecycle:
+pending -> drafted -> sent/cancelled/error
+"""
+
+import sqlite3
+from datetime import datetime, timezone
+
+_db_path = None
+_initialized = False
+
+
+def set_db_path(path: str):
+    """Set the database file path."""
+    global _db_path
+    _db_path = path
+
+
+def _get_path():
+    if _db_path:
+        return _db_path
+    from draftpilot.config import get_db_path
+    return get_db_path()
+
+
+def get_conn():
+    path = _get_path()
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    _ensure_initialized(conn)
+    return conn
+
+
+def _ensure_initialized(conn):
+    global _initialized
+    if _initialized:
+        return
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS emails (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_name TEXT NOT NULL,
+            email TEXT NOT NULL,
+            language TEXT DEFAULT 'fr',
+            subject TEXT,
+            body TEXT,
+            template_used TEXT,
+            gmail_draft_id TEXT,
+            gmail_message_id TEXT,
+            status TEXT DEFAULT 'pending',
+            created_at TEXT DEFAULT (datetime('now')),
+            drafted_at TEXT,
+            send_after TEXT,
+            sent_at TEXT,
+            error_msg TEXT
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_status ON emails(status)")
+    conn.commit()
+    _initialized = True
+
+
+def already_processed(email: str) -> bool:
+    """Check if we already drafted/sent to this email address."""
+    conn = get_conn()
+    row = conn.execute(
+        "SELECT 1 FROM emails WHERE email = ? AND status IN ('drafted', 'sent', 'cancelled')",
+        (email,)
+    ).fetchone()
+    conn.close()
+    return row is not None
+
+
+def insert_pending(company_name: str, email: str, language: str) -> int:
+    conn = get_conn()
+    cur = conn.execute(
+        "INSERT INTO emails (company_name, email, language) VALUES (?, ?, ?)",
+        (company_name, email, language)
+    )
+    conn.commit()
+    row_id = cur.lastrowid
+    conn.close()
+    return row_id
+
+
+def mark_drafted(row_id: int, subject: str, body: str, template_used: str,
+                 gmail_draft_id: str, send_after: str, gmail_message_id: str = None):
+    conn = get_conn()
+    conn.execute("""
+        UPDATE emails
+        SET status = 'drafted', subject = ?, body = ?, template_used = ?,
+            gmail_draft_id = ?, gmail_message_id = ?,
+            drafted_at = datetime('now'), send_after = ?
+        WHERE id = ?
+    """, (subject, body, template_used, gmail_draft_id, gmail_message_id, send_after, row_id))
+    conn.commit()
+    conn.close()
+
+
+def mark_sent(row_id: int, gmail_message_id: str = None):
+    conn = get_conn()
+    conn.execute("""
+        UPDATE emails
+        SET status = 'sent', sent_at = datetime('now'),
+            gmail_message_id = COALESCE(?, gmail_message_id)
+        WHERE id = ?
+    """, (gmail_message_id, row_id))
+    conn.commit()
+    conn.close()
+
+
+def mark_cancelled(row_id: int):
+    conn = get_conn()
+    conn.execute("UPDATE emails SET status = 'cancelled' WHERE id = ?", (row_id,))
+    conn.commit()
+    conn.close()
+
+
+def mark_error(row_id: int, error_msg: str):
+    conn = get_conn()
+    conn.execute(
+        "UPDATE emails SET status = 'error', error_msg = ? WHERE id = ?",
+        (error_msg, row_id)
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_ready_to_send() -> list:
+    """Get all drafted emails whose validation window has passed."""
+    conn = get_conn()
+    rows = conn.execute("""
+        SELECT * FROM emails
+        WHERE status = 'drafted'
+        AND REPLACE(REPLACE(send_after, '+00:00', ''), 'T', ' ') <= datetime('now')
+    """).fetchall()
+    conn.close()
+    return rows
+
+
+def get_stats() -> dict:
+    conn = get_conn()
+    rows = conn.execute(
+        "SELECT status, COUNT(*) as count FROM emails GROUP BY status"
+    ).fetchall()
+    conn.close()
+    return {row["status"]: row["count"] for row in rows}
+
+
+def get_today_stats() -> dict:
+    conn = get_conn()
+    rows = conn.execute("""
+        SELECT status, COUNT(*) as count FROM emails
+        WHERE DATE(created_at) = DATE('now')
+        GROUP BY status
+    """).fetchall()
+    conn.close()
+    return {row["status"]: row["count"] for row in rows}