chameleon-cv 0.1.0

package/scripts/db.py

@@ -0,0 +1,331 @@
+"""
+Persistent SQLite store for scanned jobs, tailored CVs, and scan history.
+Every job, score, and tailored CV lives on disk — survives restarts.
+0 hardcoded paths. DB path from config.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from scripts.config import config
+
+_local = threading.local()
+
+
+def compute_job_id(title: str, company: str, url: str = "", source: str = "") -> str:
+    """Deterministic job ID that distinguishes separate postings at one employer."""
+    raw = f"{title}|{company}|{url}|{source}".encode()
+    try:
+        return hashlib.md5(raw, usedforsecurity=False).hexdigest()[:12]
+    except TypeError:
+        return hashlib.md5(raw).hexdigest()[:12]
+
+
+def _get_conn() -> sqlite3.Connection:
+    """Thread-local connection — safe for TUI background workers."""
+    if not hasattr(_local, "conn") or _local.conn is None:
+        db_path = config.resolve("db_path") or (
+            Path(__file__).resolve().parent.parent / ".chameleon" / "jobs.db"
+        )
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        _local.conn = sqlite3.connect(str(db_path))
+        _local.conn.row_factory = sqlite3.Row
+        _local.conn.execute("PRAGMA journal_mode=WAL")
+        _local.conn.execute("PRAGMA busy_timeout=5000")
+    return _local.conn
+
+
+def migrate():
+    """Ensure all tables exist. Idempotent — safe to call on every startup."""
+    conn = _get_conn()
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS jobs (
+            id            TEXT PRIMARY KEY,
+            title         TEXT NOT NULL,
+            company       TEXT NOT NULL,
+            url           TEXT DEFAULT '',
+            location      TEXT DEFAULT 'Remote',
+            description   TEXT DEFAULT '',
+            salary        TEXT DEFAULT '',
+            source        TEXT DEFAULT '',
+            remote        INTEGER DEFAULT 0,
+            tags          TEXT DEFAULT '[]',
+            score         INTEGER DEFAULT 0,
+            score_detail  TEXT DEFAULT '{}',
+            created_at    TEXT DEFAULT (datetime('now')),
+            updated_at    TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS tailored_cvs (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            job_id        TEXT REFERENCES jobs(id) ON DELETE CASCADE,
+            title         TEXT NOT NULL,
+            company       TEXT NOT NULL,
+            score         INTEGER DEFAULT 0,
+            yaml_path     TEXT DEFAULT '',
+            pdf_path      TEXT DEFAULT '',
+            description   TEXT DEFAULT '',
+            url           TEXT DEFAULT '',
+            location      TEXT DEFAULT 'Remote',
+            remote        INTEGER DEFAULT 0,
+            salary        TEXT DEFAULT '',
+            tags          TEXT DEFAULT '[]',
+            source        TEXT DEFAULT 'tailored',
+            aliases       TEXT DEFAULT '',
+            created_at    TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS scans (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            query         TEXT NOT NULL,
+            platform      TEXT NOT NULL,
+            job_count     INTEGER DEFAULT 0,
+            duration_ms   INTEGER DEFAULT 0,
+            scanned_at    TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_jobs_score ON jobs(score DESC);
+        CREATE INDEX IF NOT EXISTS idx_jobs_source ON jobs(source);
+        CREATE INDEX IF NOT EXISTS idx_jobs_company_title ON jobs(company, title);
+        CREATE INDEX IF NOT EXISTS idx_tailored_job_id ON tailored_cvs(job_id);
+    """)
+    conn.commit()
+
+
+# ── Jobs ─────────────────────────────────────────────────────────────────
+
+
+def save_job(
+    title: str,
+    company: str,
+    url: str = "",
+    location: str = "Remote",
+    description: str = "",
+    salary: str = "",
+    source: str = "",
+    remote: bool = False,
+    tags: list[str] | None = None,
+    score: int = 0,
+    score_detail: dict | None = None,
+    job_id: str | None = None,
+) -> str:
+    """Insert or update a job. Returns the job ID."""
+    job_id = job_id or compute_job_id(title, company, url, source)
+    conn = _get_conn()
+    conn.execute(
+        """
+        INSERT INTO jobs (id, title, company, url, location, description, salary, source, remote, tags, score, score_detail, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+        ON CONFLICT(id) DO UPDATE SET
+            url         = excluded.url,
+            location    = excluded.location,
+            description = excluded.description,
+            salary      = excluded.salary,
+            source      = excluded.source,
+            remote      = excluded.remote,
+            tags        = excluded.tags,
+            score       = excluded.score,
+            score_detail = excluded.score_detail,
+            updated_at  = datetime('now')
+        """,
+        (
+            job_id, title, company, url, location, description,
+            salary, source, int(remote),
+            json.dumps(tags or []), score, json.dumps(score_detail or {}),
+        ),
+    )
+    conn.commit()
+    return job_id
+
+
+def save_jobs(jobs: list[dict]) -> int:
+    """Save multiple jobs. Returns count saved."""
+    count = 0
+    for j in jobs:
+        save_job(
+            title=j.get("title", ""),
+            company=j.get("company", ""),
+            url=j.get("url", ""),
+            location=j.get("location", "Remote"),
+            description=j.get("description", ""),
+            salary=j.get("salary", ""),
+            source=j.get("source", ""),
+            remote=bool(j.get("remote", False)),
+            tags=j.get("tags") or [],
+            score=j.get("score", 0),
+            score_detail=j.get("score_detail") or {},
+            job_id=j.get("job_id") or j.get("id"),
+        )
+        count += 1
+    return count
+
+
+def get_all_jobs(limit: int = 500, offset: int = 0) -> list[dict]:
+    """Return all jobs ordered by score DESC."""
+    conn = _get_conn()
+    rows = conn.execute(
+        "SELECT * FROM jobs ORDER BY score DESC LIMIT ? OFFSET ?",
+        (limit, offset),
+    ).fetchall()
+    return [_row_to_job(r) for r in rows]
+
+
+def get_job(job_id: str) -> dict | None:
+    conn = _get_conn()
+    r = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
+    return _row_to_job(r) if r else None
+
+
+def find_jobs(
+    keyword: str = "",
+    source: str = "",
+    min_score: int = 0,
+    limit: int = 100,
+) -> list[dict]:
+    """Search jobs by keyword in title/company/description."""
+    conn = _get_conn()
+    parts: list[str] = ["SELECT * FROM jobs WHERE 1=1"]
+    params: list[Any] = []
+    if keyword:
+        parts.append("AND (title LIKE ? OR company LIKE ? OR description LIKE ?)")
+        kw = f"%{keyword}%"
+        params.extend([kw, kw, kw])
+    if source:
+        parts.append("AND source = ?")
+        params.append(source)
+    if min_score:
+        parts.append("AND score >= ?")
+        params.append(min_score)
+    parts.append("ORDER BY score DESC LIMIT ?")
+    params.append(limit)
+    rows = conn.execute(" ".join(parts), params).fetchall()
+    return [_row_to_job(r) for r in rows]
+
+
+def delete_job(job_id: str) -> bool:
+    conn = _get_conn()
+    c = conn.execute("DELETE FROM jobs WHERE id = ?", (job_id,))
+    conn.commit()
+    return c.rowcount > 0
+
+
+def update_job_score(job_id: str, score: int, score_detail: dict) -> bool:
+    conn = _get_conn()
+    c = conn.execute(
+        "UPDATE jobs SET score = ?, score_detail = ?, updated_at = datetime('now') WHERE id = ?",
+        (score, json.dumps(score_detail), job_id),
+    )
+    conn.commit()
+    return c.rowcount > 0
+
+
+def job_count() -> int:
+    conn = _get_conn()
+    return conn.execute("SELECT COUNT(*) FROM jobs").fetchone()[0]
+
+
+# ── Tailored CVs ──────────────────────────────────────────────────────────
+
+
+def save_tailored_cv(
+    job_id: str,
+    title: str,
+    company: str,
+    score: int = 0,
+    yaml_path: str = "",
+    pdf_path: str = "",
+    description: str = "",
+    url: str = "",
+    location: str = "Remote",
+    remote: bool = False,
+    salary: str = "",
+    tags: list[str] | None = None,
+    source: str = "tailored",
+    aliases: str = "",
+) -> int:
+    conn = _get_conn()
+    cur = conn.execute(
+        """
+        INSERT INTO tailored_cvs
+            (job_id, title, company, score, yaml_path, pdf_path,
+             description, url, location, remote, salary, tags, source, aliases)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            job_id, title, company, score, yaml_path, pdf_path,
+            description, url, location, int(remote), salary,
+            json.dumps(tags or []), source, aliases,
+        ),
+    )
+    conn.commit()
+    return cur.lastrowid or 0
+
+
+def get_tailored_cvs(limit: int = 50) -> list[dict]:
+    rows = _get_conn().execute(
+        "SELECT * FROM tailored_cvs ORDER BY created_at DESC LIMIT ?",
+        (limit,),
+    ).fetchall()
+    return [_row_to_tailored(r) for r in rows]
+
+
+def delete_tailored_cv(tailored_id: int) -> bool:
+    conn = _get_conn()
+    c = conn.execute("DELETE FROM tailored_cvs WHERE id = ?", (tailored_id,))
+    conn.commit()
+    return c.rowcount > 0
+
+
+# ── Scan history ──────────────────────────────────────────────────────────
+
+
+def record_scan(query: str, platform: str, job_count: int, duration_ms: int) -> int:
+    conn = _get_conn()
+    cur = conn.execute(
+        "INSERT INTO scans (query, platform, job_count, duration_ms) VALUES (?, ?, ?, ?)",
+        (query, platform, job_count, duration_ms),
+    )
+    conn.commit()
+    return cur.lastrowid or 0
+
+
+def get_recent_scans(limit: int = 20) -> list[dict]:
+    rows = _get_conn().execute(
+        "SELECT * FROM scans ORDER BY scanned_at DESC LIMIT ?",
+        (limit,),
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────
+
+
+def _row_to_job(r: sqlite3.Row) -> dict:
+    d = dict(r)
+    d["remote"] = bool(d["remote"])
+    d["tags"] = json.loads(d["tags"]) if isinstance(d["tags"], str) else (d["tags"] or [])
+    d["score_detail"] = json.loads(d["score_detail"]) if isinstance(d["score_detail"], str) else (d["score_detail"] or {})
+    return d
+
+
+def _row_to_tailored(r: sqlite3.Row) -> dict:
+    d = dict(r)
+    d["remote"] = bool(d["remote"])
+    d["tags"] = json.loads(d["tags"]) if isinstance(d["tags"], str) else (d["tags"] or [])
+    return d
+
+
+def close():
+    if hasattr(_local, "conn") and _local.conn:
+        _local.conn.close()
+        _local.conn = None
+
+
+# Auto-migrate on first import (idempotent)
+migrate()

package/scripts/fonts.py

@@ -0,0 +1,186 @@
+"""Font manager for CV rendering — Google Fonts integration + local fallbacks.
+
+0 hardcoded font paths. TUI can install, preview, and select fonts dynamically.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import urllib.request
+import urllib.error
+from pathlib import Path
+from typing import Any
+
+from scripts.config import config
+
+# Built-in Google Fonts that work with RenderCV/Typst
+BUILTIN_FONTS: list[dict[str, Any]] = [
+    {"family": "Source Sans Pro", "category": "sans-serif", "builtin": True},
+    {"family": "Source Serif Pro", "category": "serif", "builtin": True},
+    {"family": "Source Code Pro", "category": "monospace", "builtin": True},
+    {"family": "IBM Plex Sans", "category": "sans-serif", "builtin": True},
+    {"family": "IBM Plex Serif", "category": "serif", "builtin": True},
+    {"family": "Inter", "category": "sans-serif", "builtin": True},
+    {"family": "Roboto", "category": "sans-serif", "builtin": True},
+    {"family": "Lato", "category": "sans-serif", "builtin": True},
+    {"family": "Open Sans", "category": "sans-serif", "builtin": True},
+    {"family": "Noto Sans", "category": "sans-serif", "builtin": True},
+    {"family": "Noto Serif", "category": "serif", "builtin": True},
+    {"family": "Merriweather", "category": "serif", "builtin": True},
+    {"family": "Playfair Display", "category": "serif", "builtin": True},
+    {"family": "Fira Sans", "category": "sans-serif", "builtin": True},
+    {"family": "Cabin", "category": "sans-serif", "builtin": True},
+    {"family": "Montserrat", "category": "sans-serif", "builtin": True},
+    {"family": "Nunito", "category": "sans-serif", "builtin": True},
+    {"family": "Poppins", "category": "sans-serif", "builtin": True},
+    {"family": "Raleway", "category": "sans-serif", "builtin": True},
+    {"family": "Ubuntu", "category": "sans-serif", "builtin": True},
+]
+
+# Google Fonts CSS API base for downloading
+GFONTS_API = "https://fonts.googleapis.com/css2?family={family}:wght@300;400;500;600;700&display=swap"
+
+
+def list_available_fonts() -> list[dict[str, Any]]:
+    """List all available fonts (built-in + locally installed)."""
+    fonts = list(BUILTIN_FONTS)
+
+    # Check for locally downloaded fonts
+    fonts_dir = config.fonts_dir()
+    if fonts_dir.exists():
+        for f in fonts_dir.glob("*"):
+            if f.suffix.lower() in (".ttf", ".otf", ".woff", ".woff2"):
+                fonts.append({
+                    "family": f.stem,
+                    "category": "local",
+                    "builtin": False,
+                    "path": str(f),
+                    "format": f.suffix[1:],
+                })
+
+    # Check system fonts (Linux fc-list)
+    try:
+        result = subprocess.run(
+            ["fc-list", "--format=%{family}\n"],
+            capture_output=True, text=True, timeout=5,
+        )
+        for line in result.stdout.strip().split("\n"):
+            families = [f.strip() for f in line.split(",")]
+            for fam in families:
+                if fam and not any(
+                    f["family"].lower() == fam.lower() for f in fonts
+                ):
+                    fonts.append({
+                        "family": fam,
+                        "category": "system",
+                        "builtin": False,
+                    })
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    # Deduplicate
+    seen: set[str] = set()
+    unique: list[dict[str, Any]] = []
+    for f in fonts:
+        key = f["family"].lower()
+        if key not in seen:
+            seen.add(key)
+            unique.append(f)
+    return unique
+
+
+def download_font(family: str) -> tuple[bool, str]:
+    """Download a Google Font for local use."""
+    fonts_dir = config.fonts_dir()
+    fonts_dir.mkdir(parents=True, exist_ok=True)
+    safe_name = family.replace(" ", "_")
+    out_path = fonts_dir / f"{safe_name}.ttf"
+    if out_path.exists():
+        return True, f"Already downloaded: {out_path}"
+
+    css_url = GFONTS_API.format(family=family.replace(" ", "+"))
+    try:
+        req = urllib.request.Request(
+            css_url,
+            headers={"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"},
+        )
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            css = resp.read().decode()
+    except (urllib.error.URLError, OSError) as e:
+        return False, f"Failed to fetch font CSS: {e}"
+
+    # Extract first .ttf or .woff2 URL from the CSS
+    urls = re.findall(r"url\(([^)]+)\)", css)
+    if not urls:
+        return False, "No font URL found in Google Fonts CSS"
+
+    font_url = urls[0]
+    try:
+        req = urllib.request.Request(
+            font_url,
+            headers={"User-Agent": "Mozilla/5.0"},
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = resp.read()
+        out_path.write_bytes(data)
+        return True, f"Downloaded: {out_path} ({len(data) / 1024:.0f} KB)"
+    except (urllib.error.URLError, OSError) as e:
+        return False, f"Failed to download font file: {e}"
+
+
+def get_current_font() -> str:
+    """Get the currently configured CV font family."""
+    return config.get("cv_font_family", "Source Sans Pro")
+
+
+def set_font(family: str) -> None:
+    """Set the CV font family in config."""
+    config.set("cv_font_family", family)
+
+
+def apply_font_to_master_cv(yaml_path: Path, family: str | None = None) -> bool:
+    """Apply font settings to a CV YAML file."""
+    if not yaml_path.exists():
+        return False
+
+    family = family or get_current_font()
+    try:
+        text = yaml_path.read_text()
+        lines = text.split("\n")
+        in_design = False
+        design_end = 0
+        has_font = False
+        new_lines = []
+
+        for i, line in enumerate(lines):
+            if line.strip() == "design:":
+                in_design = True
+            if in_design and line.strip() == "":
+                in_design = False
+                design_end = i
+            if in_design and "font:" in line:
+                has_font = True
+
+        new_lines = list(lines)
+        if not has_font:
+            insert_at = design_end if design_end else len(lines) - 1
+            new_lines.insert(insert_at, f"    typography:")
+            new_lines.insert(insert_at + 1, f"      font: {family}")
+        else:
+            new_lines = [
+                re.sub(r"font:\s*.+", f"font: {family}", line)
+                for line in new_lines
+            ]
+
+        yaml_path.write_text("\n".join(new_lines))
+        return True
+    except Exception:
+        return False
+
+
+def preview_text(family: str, sample: str = "The quick brown fox jumps over the lazy dog.") -> str:
+    """Generate a text preview for a font family."""
+    return f"[bold]{family}[/bold] — {sample}"

package/scripts/ghost.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from scripts.config import config
+from scripts.ats_ghost import collect_ats_terms, inject_ghost_text, verify_ats_text
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Inject ATS ghost text into a PDF")
+    ap.add_argument("pdf_path", help="Path to the rendered PDF")
+    ap.add_argument("--jd", "-j", default="", help="Job description text file (for keyword extraction)")
+    ap.add_argument("--jd-text", default="", help="Job description text directly")
+    ap.add_argument("--extra", "-e", default="", help="Extra comma-separated ATS terms")
+    ap.add_argument("--verify", action="store_true", help="Verify ghost text is extractable")
+    ap.add_argument("--json", action="store_true", help="JSON output")
+
+    args = ap.parse_args()
+
+    pdf_path = Path(args.pdf_path)
+    if not pdf_path.exists():
+        result = {"success": False, "error": f"PDF not found: {pdf_path}"}
+        _output(result, args.json)
+        sys.exit(1)
+
+    jd_text = ""
+    if args.jd:
+        jd_path = Path(args.jd)
+        if jd_path.exists():
+            jd_text = jd_path.read_text(encoding="utf-8")
+    if args.jd_text:
+        jd_text = args.jd_text
+
+    extra_terms = args.extra or config.get("ats_ghost_extra_terms", "")
+
+    # Collect terms from JD + extras
+    if jd_text:
+        signal_terms = []
+        gap_terms = []
+        terms = collect_ats_terms(
+            jd_text,
+            extra_terms=extra_terms,
+            existing_keywords=list(set(signal_terms + gap_terms)),
+        )
+    else:
+        terms = [t.strip() for t in extra_terms.split(",") if t.strip()]
+
+    if not terms:
+        _output({"success": False, "error": "No ATS terms to inject"}, args.json)
+        sys.exit(1)
+
+    ok = inject_ghost_text(pdf_path, terms)
+
+    result = {
+        "success": ok,
+        "pdf_path": str(pdf_path),
+        "terms_injected": len(terms),
+        "terms": terms[:20],
+    }
+
+    if args.verify and ok:
+        found, found_terms = verify_ats_text(pdf_path, terms[:5])
+        result["verified"] = found
+        result["found_terms"] = found_terms
+
+    _output(result, args.json)
+    sys.exit(0 if ok else 1)
+
+
+def _output(result: dict, as_json: bool):
+    if as_json:
+        print(json.dumps(result, indent=2))
+    else:
+        if result.get("success"):
+            print(f"ATS ghost injected: {result['terms_injected']} terms into {result['pdf_path']}")
+            if result.get("verified"):
+                print(f"Verified: {len(result.get('found_terms', []))} terms extractable")
+        else:
+            print(f"Error: {result.get('error', 'unknown')}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()