"""
Minimal dev-only FastAPI server for the Vue SPA.
Reads directly from /devl/job-seeker/staging.db.
Run with:
conda run -n job-seeker uvicorn dev-api:app --port 8600 --reload
"""
import imaplib
import json
import logging
import os
import re
import socket
import sqlite3
import ssl as ssl_mod
import subprocess
import sys
import threading
from contextvars import ContextVar
from datetime import datetime, timezone
from pathlib import Path
from typing import Optional, List
from urllib.parse import urlparse
import requests
import yaml
from bs4 import BeautifulSoup
from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException, Request, Response, UploadFile
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
# Allow importing peregrine scripts for cover letter generation.
# Resolved from __file__ so it works both in Docker (/app) and on the dev
# machine (/Library/Development/CircuitForge/peregrine) without hardcoding.
PEREGRINE_ROOT = Path(__file__).resolve().parent
if str(PEREGRINE_ROOT) not in sys.path:
sys.path.insert(0, str(PEREGRINE_ROOT))
from circuitforge_core.api import make_feedback_router as _make_feedback_router # noqa: E402
from circuitforge_core.config.settings import load_env as _load_env # noqa: E402
from scripts.credential_store import get_credential, set_credential, delete_credential # noqa: E402
DB_PATH = os.environ.get("STAGING_DB", "/devl/job-seeker/staging.db")
_CLOUD_MODE = os.environ.get("CLOUD_MODE", "").lower() in ("1", "true")
_CLOUD_DATA_ROOT = Path(os.environ.get("CLOUD_DATA_ROOT", "/devl/menagerie-data"))
_DIRECTUS_SECRET = os.environ.get("DIRECTUS_JWT_SECRET", "")
# Per-request DB path — set by cloud_session_middleware; falls back to DB_PATH
_request_db: ContextVar[str | None] = ContextVar("_request_db", default=None)
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Load .env then run pending SQLite migrations on startup."""
# Load .env before any runtime env reads — safe because lifespan doesn't run
# when dev_api is imported by tests (only when uvicorn actually starts).
_load_env(PEREGRINE_ROOT / ".env")
from scripts.db_migrate import migrate_db
migrate_db(Path(DB_PATH))
# Cloud mode: sweep all known user DBs at startup so schema changes land
# for every user on deploy, not only on their next request.
if _CLOUD_MODE and _CLOUD_DATA_ROOT.is_dir():
import logging as _log
_sweep_log = _log.getLogger("peregrine.startup")
for user_db in _CLOUD_DATA_ROOT.glob("*/peregrine/staging.db"):
try:
migrate_db(user_db)
_migrated_db_paths.add(str(user_db))
_sweep_log.info("Migrated user DB: %s", user_db)
except Exception as exc:
_sweep_log.warning("Migration failed for %s: %s", user_db, exc)
yield
app = FastAPI(title="Peregrine Dev API", lifespan=lifespan)
app.add_middleware(
CORSMiddleware,
allow_origins=["http://localhost:5173", "http://10.1.10.71:5173"],
allow_methods=["*"],
allow_headers=["*"],
)
_feedback_router = _make_feedback_router(
repo="Circuit-Forge/peregrine",
product="peregrine",
demo_mode_fn=lambda: (
_CLOUD_MODE or os.environ.get("DEMO_MODE", "").lower() in ("1", "true", "yes")
),
)
app.include_router(_feedback_router, prefix="/api/feedback")
_log = logging.getLogger("peregrine.session")
def _resolve_cf_user_id(cookie_str: str) -> str | None:
"""Extract cf_session JWT from Cookie string and return Directus user_id.
Directus signs with the raw bytes of its JWT_SECRET (which is base64-encoded
in env). Try the raw string first, then fall back to base64-decoded bytes.
"""
if not cookie_str:
_log.debug("_resolve_cf_user_id: empty cookie string")
return None
m = re.search(r'(?:^|;)\s*cf_session=([^;]+)', cookie_str)
if not m:
_log.debug("_resolve_cf_user_id: no cf_session in cookie: %s…", cookie_str[:80])
return None
token = m.group(1).strip()
import base64
import jwt # PyJWT
secrets_to_try: list[str | bytes] = [_DIRECTUS_SECRET]
try:
secrets_to_try.append(base64.b64decode(_DIRECTUS_SECRET))
except Exception:
pass
# Skip exp verification — we use the token for routing only, not auth.
# Directus manages actual auth; Caddy gates on cookie presence.
decode_opts = {"verify_exp": False}
for secret in secrets_to_try:
try:
payload = jwt.decode(token, secret, algorithms=["HS256"], options=decode_opts)
user_id = payload.get("id") or payload.get("sub")
if user_id:
_log.debug("_resolve_cf_user_id: resolved user_id=%s", user_id)
return user_id
except Exception as exc:
_log.debug("_resolve_cf_user_id: decode failed (%s): %s", type(exc).__name__, exc)
continue
_log.warning("_resolve_cf_user_id: all secrets failed for token prefix %s…", token[:20])
return None
@app.middleware("http")
async def cloud_session_middleware(request: Request, call_next):
"""In cloud mode, resolve per-user staging.db from the X-CF-Session header."""
if _CLOUD_MODE and _DIRECTUS_SECRET:
cookie_header = request.headers.get("X-CF-Session", "")
user_id = _resolve_cf_user_id(cookie_header)
if user_id:
user_db = str(_CLOUD_DATA_ROOT / user_id / "peregrine" / "staging.db")
if user_db not in _migrated_db_paths:
from scripts.db_migrate import migrate_db
migrate_db(Path(user_db))
_migrated_db_paths.add(user_db)
token = _request_db.set(user_db)
try:
return await call_next(request)
finally:
_request_db.reset(token)
return await call_next(request)
_migrated_db_paths: set[str] = set()
def _get_db():
path = _request_db.get() or DB_PATH
if path not in _migrated_db_paths:
from scripts.db_migrate import migrate_db
migrate_db(Path(path))
_migrated_db_paths.add(path)
db = sqlite3.connect(path)
db.row_factory = sqlite3.Row
return db
def _strip_html(text: str | None) -> str | None:
"""Strip HTML tags and normalize whitespace in email body text."""
if not text:
return text
plain = BeautifulSoup(text, 'html.parser').get_text(separator='\n')
# Strip trailing whitespace from each line
lines = [line.rstrip() for line in plain.split('\n')]
# Collapse 3+ consecutive blank lines to at most 2
cleaned = re.sub(r'\n{3,}', '\n\n', '\n'.join(lines))
return cleaned.strip() or None
# ── Link extraction helpers ───────────────────────────────────────────────
_JOB_DOMAINS = frozenset({
'greenhouse.io', 'lever.co', 'workday.com', 'linkedin.com',
'ashbyhq.com', 'smartrecruiters.com', 'icims.com', 'taleo.net',
'jobvite.com', 'breezy.hr', 'recruitee.com', 'bamboohr.com',
'myworkdayjobs.com',
})
_JOB_PATH_SEGMENTS = frozenset({'careers', 'jobs'})
_FILTER_RE = re.compile(
r'(unsubscribe|mailto:|/track/|pixel\.|\.gif|\.png|\.jpg'
r'|/open\?|/click\?|list-unsubscribe)',
re.I,
)
_URL_RE = re.compile(r'https?://[^\s<>"\')\]]+', re.I)
def _score_url(url: str) -> int:
"""Return 2 for likely job URLs, 1 for others, -1 to exclude."""
if _FILTER_RE.search(url):
return -1
parsed = urlparse(url)
hostname = (parsed.hostname or '').lower()
path = parsed.path.lower()
for domain in _JOB_DOMAINS:
if domain in hostname:
return 2
for seg in _JOB_PATH_SEGMENTS:
if f'/{seg}/' in path or path.startswith(f'/{seg}'):
return 2
return 1
def _extract_links(body: str) -> list[dict]:
"""Extract and rank URLs from raw HTML email body."""
if not body:
return []
seen: set[str] = set()
results = []
for m in _URL_RE.finditer(body):
url = m.group(0).rstrip('.,;)')
if url in seen:
continue
seen.add(url)
score = _score_url(url)
if score < 0:
continue
start = max(0, m.start() - 60)
hint = body[start:m.start()].strip().split('\n')[-1].strip()
results.append({'url': url, 'score': score, 'hint': hint})
results.sort(key=lambda x: -x['score'])
return results
def _row_to_job(row) -> dict:
d = dict(row)
d["is_remote"] = bool(d.get("is_remote", 0))
return d
def _shadow_score(date_posted: str | None, date_found: str | None) -> str | None:
"""Return 'shadow', 'stale', or None based on posting age when discovered.
A job posted >30 days before discovery is a shadow candidate (posted to
satisfy legal/HR requirements, likely already filled). 14-30 days is stale.
Returns None when dates are unavailable.
"""
if not date_posted or not date_found:
return None
try:
posted = datetime.fromisoformat(date_posted.replace("Z", "+00:00")).replace(tzinfo=timezone.utc)
found = datetime.fromisoformat(date_found.replace("Z", "+00:00")).replace(tzinfo=timezone.utc)
days = (found - posted).days
if days >= 30:
return "shadow"
if days >= 14:
return "stale"
except (ValueError, TypeError):
pass
return None
# ── GET /api/jobs ─────────────────────────────────────────────────────────────
@app.get("/api/jobs")
def list_jobs(status: str = "pending", limit: int = 50, fields: str = ""):
db = _get_db()
rows = db.execute(
"SELECT id, title, company, url, source, location, is_remote, salary, "
"description, match_score, keyword_gaps, date_found, date_posted, status, cover_letter "
"FROM jobs WHERE status = ? ORDER BY match_score DESC NULLS LAST LIMIT ?",
(status, limit),
).fetchall()
db.close()
result = []
for r in rows:
d = _row_to_job(r)
d["has_cover_letter"] = bool(d.get("cover_letter"))
d["shadow_score"] = _shadow_score(d.get("date_posted"), d.get("date_found"))
d.pop("cover_letter", None)
result.append(d)
return result
# ── GET /api/jobs/counts ──────────────────────────────────────────────────────
@app.get("/api/jobs/counts")
def job_counts():
db = _get_db()
rows = db.execute("SELECT status, count(*) as n FROM jobs GROUP BY status").fetchall()
db.close()
counts = {r["status"]: r["n"] for r in rows}
return {
"pending": counts.get("pending", 0),
"approved": counts.get("approved", 0),
"applied": counts.get("applied", 0),
"synced": counts.get("synced", 0),
"rejected": counts.get("rejected", 0),
"total": sum(counts.values()),
}
# ── POST /api/jobs/{id}/approve ───────────────────────────────────────────────
@app.post("/api/jobs/{job_id}/approve")
def approve_job(job_id: int):
db = _get_db()
db.execute("UPDATE jobs SET status = 'approved' WHERE id = ?", (job_id,))
db.commit()
db.close()
return {"ok": True}
# ── POST /api/jobs/{id}/reject ────────────────────────────────────────────────
@app.post("/api/jobs/{job_id}/reject")
def reject_job(job_id: int):
db = _get_db()
db.execute("UPDATE jobs SET status = 'rejected' WHERE id = ?", (job_id,))
db.commit()
db.close()
return {"ok": True}
# ── POST /api/jobs/{id}/revert ────────────────────────────────────────────────
class RevertBody(BaseModel):
status: str
@app.post("/api/jobs/{job_id}/revert")
def revert_job(job_id: int, body: RevertBody):
allowed = {"pending", "approved", "rejected", "applied", "synced"}
if body.status not in allowed:
raise HTTPException(400, f"Invalid status: {body.status}")
db = _get_db()
db.execute("UPDATE jobs SET status = ? WHERE id = ?", (body.status, job_id))
db.commit()
db.close()
return {"ok": True}
# ── GET /api/system/status ────────────────────────────────────────────────────
@app.get("/api/system/status")
def system_status():
return {
"enrichment_enabled": False,
"enrichment_last_run": None,
"enrichment_next_run": None,
"tasks_running": 0,
"integration_name": "Notion",
"integration_unsynced": 0,
}
# ── GET /api/jobs/:id ────────────────────────────────────────────────────────
@app.get("/api/jobs/{job_id}")
def get_job(job_id: int):
db = _get_db()
row = db.execute(
"SELECT id, title, company, url, source, location, is_remote, salary, "
"description, match_score, keyword_gaps, date_found, status, cover_letter "
"FROM jobs WHERE id = ?",
(job_id,),
).fetchone()
db.close()
if not row:
raise HTTPException(404, "Job not found")
d = _row_to_job(row)
d["has_cover_letter"] = bool(d.get("cover_letter"))
return d
# ── POST /api/jobs/:id/applied ────────────────────────────────────────────────
@app.post("/api/jobs/{job_id}/applied")
def mark_applied(job_id: int):
db = _get_db()
db.execute(
"UPDATE jobs SET status = 'applied', applied_at = datetime('now') WHERE id = ?",
(job_id,),
)
db.commit()
db.close()
return {"ok": True}
# ── PATCH /api/jobs/:id/cover_letter ─────────────────────────────────────────
class CoverLetterBody(BaseModel):
text: str
@app.patch("/api/jobs/{job_id}/cover_letter")
def save_cover_letter(job_id: int, body: CoverLetterBody):
db = _get_db()
db.execute("UPDATE jobs SET cover_letter = ? WHERE id = ?", (body.text, job_id))
db.commit()
db.close()
return {"ok": True}
# ── POST /api/jobs/:id/cover_letter/generate ─────────────────────────────────
@app.post("/api/jobs/{job_id}/cover_letter/generate")
def generate_cover_letter(job_id: int):
try:
from scripts.task_runner import submit_task
task_id, is_new = submit_task(
db_path=Path(_request_db.get() or DB_PATH),
task_type="cover_letter",
job_id=job_id,
)
return {"task_id": task_id, "is_new": is_new}
except Exception as e:
raise HTTPException(500, str(e))
# ── GET /api/jobs/:id/cover_letter/task ──────────────────────────────────────
@app.get("/api/jobs/{job_id}/cover_letter/task")
def cover_letter_task(job_id: int):
db = _get_db()
row = db.execute(
"SELECT status, stage, error FROM background_tasks "
"WHERE task_type = 'cover_letter' AND job_id = ? "
"ORDER BY id DESC LIMIT 1",
(job_id,),
).fetchone()
db.close()
if not row:
return {"status": "none", "stage": None, "message": None}
return {
"status": row["status"],
"stage": row["stage"],
"message": row["error"],
}
# ── Interview Prep endpoints ─────────────────────────────────────────────────
@app.get("/api/jobs/{job_id}/research")
def get_research_brief(job_id: int):
db = _get_db()
row = db.execute(
"SELECT job_id, company_brief, ceo_brief, talking_points, tech_brief, "
"funding_brief, red_flags, accessibility_brief, generated_at "
"FROM company_research WHERE job_id = ? LIMIT 1",
(job_id,),
).fetchone()
db.close()
if not row:
raise HTTPException(404, "No research found for this job")
return dict(row)
@app.post("/api/jobs/{job_id}/research/generate")
def generate_research(job_id: int):
try:
from scripts.task_runner import submit_task
task_id, is_new = submit_task(db_path=Path(_request_db.get() or DB_PATH), task_type="company_research", job_id=job_id)
return {"task_id": task_id, "is_new": is_new}
except Exception as e:
raise HTTPException(500, str(e))
@app.get("/api/jobs/{job_id}/research/task")
def research_task_status(job_id: int):
db = _get_db()
row = db.execute(
"SELECT status, stage, error FROM background_tasks "
"WHERE task_type = 'company_research' AND job_id = ? "
"ORDER BY id DESC LIMIT 1",
(job_id,),
).fetchone()
db.close()
if not row:
return {"status": "none", "stage": None, "message": None}
return {"status": row["status"], "stage": row["stage"], "message": row["error"]}
# ── ATS Resume Optimizer endpoints ───────────────────────────────────────────
@app.get("/api/jobs/{job_id}/resume_optimizer")
def get_optimized_resume(job_id: int):
"""Return the current optimized resume and ATS gap report for a job."""
from scripts.db import get_optimized_resume as _get
import json
result = _get(db_path=Path(_request_db.get() or DB_PATH), job_id=job_id)
gap_report = result.get("ats_gap_report", "")
try:
gap_report_parsed = json.loads(gap_report) if gap_report else []
except Exception:
gap_report_parsed = []
return {
"optimized_resume": result.get("optimized_resume", ""),
"ats_gap_report": gap_report_parsed,
}
class ResumeOptimizeBody(BaseModel):
full_rewrite: bool = False
@app.post("/api/jobs/{job_id}/resume_optimizer/generate")
def generate_optimized_resume(job_id: int, body: ResumeOptimizeBody):
"""Queue an ATS resume optimization task for this job.
full_rewrite=False (default) → free tier: gap report only, no LLM rewrite.
full_rewrite=True → paid tier: per-section LLM rewrite + hallucination check.
"""
import json
try:
from scripts.task_runner import submit_task
params = json.dumps({"full_rewrite": body.full_rewrite})
task_id, is_new = submit_task(
db_path=Path(_request_db.get() or DB_PATH),
task_type="resume_optimize",
job_id=job_id,
params=params,
)
return {"task_id": task_id, "is_new": is_new}
except Exception as e:
raise HTTPException(500, str(e))
@app.get("/api/jobs/{job_id}/resume_optimizer/task")
def resume_optimizer_task_status(job_id: int):
"""Poll the latest resume_optimize task status for this job."""
db = _get_db()
row = db.execute(
"SELECT status, stage, error FROM background_tasks "
"WHERE task_type = 'resume_optimize' AND job_id = ? "
"ORDER BY id DESC LIMIT 1",
(job_id,),
).fetchone()
db.close()
if not row:
return {"status": "none", "stage": None, "message": None}
return {"status": row["status"], "stage": row["stage"], "message": row["error"]}
@app.get("/api/jobs/{job_id}/resume_optimizer/review")
def get_resume_review(job_id: int):
"""Return the pending review draft for this job (populated when task is awaiting_review)."""
from scripts.db import get_resume_draft as _get_draft
draft = _get_draft(db_path=Path(_request_db.get() or DB_PATH), job_id=job_id)
if not draft:
return {"draft": None}
return {"draft": draft}
class GapFramingDecision(BaseModel):
skill: str
# "adjacent" — has related experience, inject bridging sentence into bullets
# "learning" — actively developing the skill, add structured note to skills list
# "skip" — no connection, omit entirely
mode: str = "skip"
context: str = "" # candidate's own words; required for adjacent/learning
class ResumeReviewBody(BaseModel):
# Per-section decisions. Keys are section names; values are section-type-specific.
# skills: {"approved_additions": [...]}
# summary: {"accepted": bool}
# experience: {"accepted_entries": [{"title": str, "company": str, "accepted": bool}]}
decisions: dict
# One entry per rejected skill, describing how to frame the gap honestly.
gap_framings: list[GapFramingDecision] = []
@app.post("/api/jobs/{job_id}/resume_optimizer/review")
def preview_resume_review(job_id: int, body: ResumeReviewBody):
"""Apply review decisions + gap framings and return the assembled resume for preview.
Does NOT save yet — the user sees the full assembled resume and confirms
via POST /approve before anything is persisted.
Flow:
1. apply_review_decisions() — merges approved skills, summary, experience choices
2. frame_skill_gaps() — injects adjacent/learning framing for rejected skills
3. render_resume_text() — renders to plain text for the preview panel
Returns: {preview_text, preview_struct} — struct preserved for the approve step.
"""
import json as _json
from scripts.db import get_resume_draft as _get_draft
from scripts.resume_optimizer import (
apply_review_decisions, frame_skill_gaps, render_resume_text,
)
db_path = Path(_request_db.get() or DB_PATH)
draft = _get_draft(db_path=db_path, job_id=job_id)
if not draft:
raise HTTPException(404, "No pending review draft for this job")
# Step 1: apply section-level decisions
struct = apply_review_decisions(draft, body.decisions)
# Step 2: inject gap framing for rejected skills (adjacent / learning)
framings = [f.model_dump() for f in body.gap_framings if f.mode in ("adjacent", "learning")]
if framings:
db_path_obj = Path(_request_db.get() or DB_PATH)
job_row = _get_db().execute(
"SELECT title, company FROM jobs WHERE id=?", (job_id,)
).fetchone()
_get_db().close()
job = {"title": job_row[0], "company": job_row[1]} if job_row else {}
from scripts.user_profile import UserProfile
from app.cloud_session import get_config_dir
_user_yaml = get_config_dir() / "user.yaml"
candidate_voice = UserProfile(_user_yaml).candidate_voice if UserProfile.exists(_user_yaml) else ""
struct = frame_skill_gaps(struct, framings, job, candidate_voice)
preview_text = render_resume_text(struct)
return {"preview_text": preview_text, "preview_struct": struct}
@app.post("/api/jobs/{job_id}/resume_optimizer/approve")
def approve_resume(job_id: int, body: dict):
"""Save the user-approved assembled resume struct and mark the task complete.
Expects body: {"preview_struct": {...}} — the struct returned by /review.
Saves both the rendered plain text and the struct (for YAML export).
"""
import json as _json
from scripts.db import finalize_resume as _finalize
db_path = Path(_request_db.get() or DB_PATH)
struct = body.get("preview_struct")
if not struct:
raise HTTPException(400, "preview_struct is required")
from scripts.resume_optimizer import render_resume_text
final_text = render_resume_text(struct)
# Persist plain text + struct (struct enables YAML export later)
_finalize(db_path=db_path, job_id=job_id, final_text=final_text)
# Store struct alongside the text so YAML round-trip is possible
db = _get_db()
db.execute(
"UPDATE jobs SET resume_final_struct=? WHERE id=?",
(_json.dumps(struct), job_id),
)
db.execute(
"UPDATE background_tasks SET status='completed', updated_at=datetime('now') "
"WHERE task_type='resume_optimize' AND job_id=? AND status='awaiting_review'",
(job_id,),
)
db.commit()
db.close()
saved_resume_id: int | None = None
if body.get("save_to_library"):
from scripts.db import create_resume as _create_r
import json as _json2
resume_name = (body.get("resume_name") or "").strip() or f"Optimized for job {job_id}"
saved = _create_r(
db_path,
name=resume_name,
text=final_text,
source="optimizer",
job_id=job_id,
struct_json=_json.dumps(struct) if struct else None,
)
saved_resume_id = saved["id"]
return {"optimized_resume": final_text, "saved_resume_id": saved_resume_id}
def _get_final_struct(job_id: int) -> dict:
"""Return the approved resume struct for a job, or raise 404."""
import json as _json
db = _get_db()
row = db.execute(
"SELECT resume_final_struct FROM jobs WHERE id=?", (job_id,)
).fetchone()
db.close()
if not row or not row[0]:
raise HTTPException(404, "No approved resume struct for this job — approve first")
return _json.loads(row[0])
@app.get("/api/jobs/{job_id}/resume_optimizer/export-pdf")
def export_resume_pdf(job_id: int):
"""Generate a PDF from the approved resume struct and return it as a download."""
import tempfile
from scripts.resume_optimizer import export_pdf
from fastapi.responses import FileResponse
struct = _get_final_struct(job_id)
tmp = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
tmp.close()
export_pdf(struct, tmp.name)
return FileResponse(
tmp.name,
media_type="application/pdf",
filename=f"resume-optimized-job-{job_id}.pdf",
)
@app.get("/api/jobs/{job_id}/resume_optimizer/export-yaml")
def export_resume_yaml(job_id: int):
"""Return the approved resume struct as a downloadable YAML file."""
import yaml
from fastapi.responses import Response
struct = _get_final_struct(job_id)
yaml_text = yaml.dump(struct, default_flow_style=False, allow_unicode=True)
return Response(
content=yaml_text,
media_type="application/x-yaml",
headers={"Content-Disposition": f"attachment; filename=resume-optimized-job-{job_id}.yaml"},
)
@app.get("/api/jobs/{job_id}/resume_optimizer/history")
def get_resume_history(job_id: int):
"""Return the archive of past finalized resume versions (newest first)."""
from scripts.db import get_resume_archive as _get_archive
archive = _get_archive(db_path=Path(_request_db.get() or DB_PATH), job_id=job_id)
return {"history": archive}
# ── Resume library endpoints ───────────────────────────────────────────────────
@app.get("/api/resumes")
def list_resumes_endpoint():
from scripts.db import list_resumes as _list
return {"resumes": _list(Path(_request_db.get() or DB_PATH))}
@app.post("/api/resumes")
def create_resume_endpoint(body: dict):
from scripts.db import create_resume as _create
name = (body.get("name") or "").strip()
text = (body.get("text") or "").strip()
if not name or not text:
raise HTTPException(400, "name and text are required")
return _create(
Path(_request_db.get() or DB_PATH),
name=name, text=text,
source=body.get("source", "manual"),
job_id=body.get("job_id"),
struct_json=body.get("struct_json"),
)
@app.post("/api/resumes/import")
async def import_resume_endpoint(file: UploadFile, name: str = ""):
import os, tempfile, json as _json
from scripts.db import create_resume as _create
db_path = Path(_request_db.get() or DB_PATH)
content = await file.read()
MAX_IMPORT_BYTES = 5 * 1024 * 1024 # 5 MB
if len(content) > MAX_IMPORT_BYTES:
raise HTTPException(413, "File too large — 5 MB maximum")
filename = file.filename or ""
ext = Path(filename).suffix.lower()
struct_json: str | None = None
if ext in (".txt", ".md"):
text = content.decode("utf-8", errors="replace")
elif ext in (".pdf", ".docx", ".odt"):
from scripts.resume_parser import (
extract_text_from_pdf as _extract_pdf,
extract_text_from_docx as _extract_docx,
extract_text_from_odt as _extract_odt,
)
if ext == ".pdf":
text = _extract_pdf(content)
elif ext == ".docx":
text = _extract_docx(content)
else:
text = _extract_odt(content)
elif ext in (".yaml", ".yml"):
import yaml as _yaml
from scripts.task_runner import _normalize_aihawk_resume
raw = _yaml.safe_load(content.decode("utf-8", errors="replace")) or {}
struct = _normalize_aihawk_resume(raw)
struct_json = _json.dumps(struct)
lines = [struct.get("career_summary", "")]
for exp in struct.get("experience", []):
lines.append(f"{exp.get('title', '')} at {exp.get('company', '')}")
lines.extend(f"• {b}" for b in exp.get("bullets", []))
text = "\n".join(lines)
if not text.strip():
raise HTTPException(400, "YAML file contains no readable content")
else:
raise HTTPException(
400,
f"Unsupported file type: {ext}. Accepted: .txt .md .pdf .docx .odt .yaml .yml",
)
resume_name = name.strip() or Path(filename).stem or "Imported Resume"
return _create(db_path, name=resume_name, text=text.strip(), source="import", struct_json=struct_json)
@app.get("/api/resumes/{resume_id}")
def get_resume_endpoint(resume_id: int):
from scripts.db import get_resume as _get
r = _get(Path(_request_db.get() or DB_PATH), resume_id)
if not r:
raise HTTPException(404, "Resume not found")
return r
@app.patch("/api/resumes/{resume_id}")
def update_resume_endpoint(resume_id: int, body: dict):
from scripts.db import get_resume as _get, update_resume as _update
db_path = Path(_request_db.get() or DB_PATH)
if not _get(db_path, resume_id):
raise HTTPException(404, "Resume not found")
return _update(db_path, resume_id, name=body.get("name"), text=body.get("text"))
@app.delete("/api/resumes/{resume_id}")
def delete_resume_endpoint(resume_id: int):
from scripts.db import get_resume as _get, list_resumes as _list, delete_resume as _delete
db_path = Path(_request_db.get() or DB_PATH)
r = _get(db_path, resume_id)
if not r:
raise HTTPException(404, "Resume not found")
if len(_list(db_path)) == 1:
raise HTTPException(409, "Cannot delete the only resume")
if r["is_default"]:
raise HTTPException(409, "Cannot delete the default resume — set a new default first")
_delete(db_path, resume_id)
return {"ok": True}
@app.post("/api/resumes/{resume_id}/set-default")
def set_default_resume_endpoint(resume_id: int):
import yaml as _yaml
from scripts.db import get_resume as _get, set_default_resume as _set_default
db_path = Path(_request_db.get() or DB_PATH)
if not _get(db_path, resume_id):
raise HTTPException(404, "Resume not found")
_set_default(db_path, resume_id)
_user_yaml = db_path.parent / "config" / "user.yaml"
if _user_yaml.exists():
profile = _yaml.safe_load(_user_yaml.read_text(encoding="utf-8")) or {}
profile["default_resume_id"] = resume_id
_user_yaml.write_text(_yaml.dump(profile, default_flow_style=False, allow_unicode=True))
return {"ok": True}
@app.post("/api/resumes/{resume_id}/apply-to-profile")
def apply_resume_to_profile(resume_id: int):
"""Sync a library resume entry to the active profile (library→profile direction).
Workflow:
1. Load the library entry (must have struct_json).
2. Load current profile to preserve metadata fields.
3. Backup current profile content as a new auto-named library entry.
4. Merge content fields from the library entry into the profile.
5. Write updated plain_text_resume.yaml.
6. Mark the library entry synced_at.
7. Return backup details for the frontend notification.
"""
import json as _json
from scripts.resume_sync import (
library_to_profile_content,
profile_to_library,
make_auto_backup_name,
)
from scripts.db import get_resume as _get, create_resume as _create
db_path = Path(_request_db.get() or DB_PATH)
entry = _get(db_path, resume_id)
if not entry:
raise HTTPException(404, "Resume not found")
struct_json: dict = {}
if entry.get("struct_json"):
try:
struct_json = _json.loads(entry["struct_json"])
except Exception:
raise HTTPException(422, "Library entry has malformed struct_json — re-import the resume to repair it.")
resume_path = _resume_path()
current_profile: dict = {}
if resume_path.exists():
with open(resume_path, encoding="utf-8") as f:
current_profile = yaml.safe_load(f) or {}
# Backup current content to library before overwriting
backup_text, backup_struct = profile_to_library(current_profile)
backup_name = make_auto_backup_name(entry["name"])
backup = _create(
db_path,
name=backup_name,
text=backup_text,
source="auto_backup",
struct_json=_json.dumps(backup_struct),
)
# Merge: overwrite content fields, preserve metadata
content = library_to_profile_content(struct_json)
CONTENT_FIELDS = {
"name", "surname", "email", "phone", "career_summary",
"experience", "skills", "education", "achievements",
}
for field in CONTENT_FIELDS:
current_profile[field] = content[field]
resume_path.parent.mkdir(parents=True, exist_ok=True)
with open(resume_path, "w", encoding="utf-8") as f:
yaml.dump(current_profile, f, allow_unicode=True, default_flow_style=False)
from scripts.db import update_resume_synced_at as _mark_synced
_mark_synced(db_path, resume_id)
return {
"ok": True,
"backup_id": backup["id"],
"backup_name": backup_name,
"fields_updated": sorted(CONTENT_FIELDS),
}
# ── Per-job resume endpoints ───────────────────────────────────────────────────
@app.get("/api/jobs/{job_id}/resume")
def get_job_resume_endpoint(job_id: int):
from scripts.db import get_job_resume as _get
r = _get(Path(_request_db.get() or DB_PATH), job_id)
if not r:
raise HTTPException(404, "No resume configured — add one in Resume Manager")
return r
@app.patch("/api/jobs/{job_id}/resume")
def set_job_resume_endpoint(job_id: int, body: dict):
from scripts.db import get_resume as _get_r, set_job_resume as _set, get_job_resume as _get_job
db_path = Path(_request_db.get() or DB_PATH)
resume_id = body.get("resume_id")
if not resume_id or not _get_r(db_path, resume_id):
raise HTTPException(404, "Resume not found")
_set(db_path, job_id=job_id, resume_id=resume_id)
return _get_job(db_path, job_id)
# ── GET /api/imitate/samples ──────────────────────────────────────────────────
# Avocet "Imitate" tab uses this to build the EXACT prompt Peregrine sends to
# its LLM — including user voice, mission context, style examples, and full job
# context. Avocet then routes these prompts through different local models to
# compare generation quality against the real Peregrine pipeline.
def _imitate_load_profile():
"""Load UserProfile from config/user.yaml, or None if missing."""
try:
from scripts.user_profile import UserProfile
_yaml = PEREGRINE_ROOT / "config" / "user.yaml"
return UserProfile(_yaml) if UserProfile.exists(_yaml) else None
except Exception:
return None
def _imitate_cover_letter(db, profile, limit: int) -> dict:
from scripts.generate_cover_letter import (
build_prompt, _build_system_context,
load_corpus, find_similar_letters, detect_mission_alignment,
)
rows = db.execute(
"SELECT id, title, company, description, cover_letter, status FROM jobs "
"WHERE description IS NOT NULL AND description != '' "
" AND status IN ('applied','phone_screen','interviewing','offer','hired') "
"ORDER BY applied_at DESC NULLS LAST LIMIT ?",
(limit,),
).fetchall()
system_ctx = _build_system_context(profile)
try:
corpus = load_corpus()
except Exception:
corpus = []
samples = []
for r in rows:
desc = r["description"] or ""
examples = find_similar_letters(desc, corpus) if corpus else []
mission_hint = detect_mission_alignment(r["company"], desc)
prompt = build_prompt(
title=r["title"],
company=r["company"],
description=desc,
examples=examples,
mission_hint=mission_hint,
system_context=system_ctx,
candidate_name=profile.name if profile else None,
)
samples.append({
"id": r["id"],
"job_title": r["title"],
"company": r["company"],
"status": r["status"],
"system_prompt": system_ctx,
"input_text": prompt,
"output_text": r["cover_letter"] or "",
})
return {"samples": samples, "total": len(samples), "type": "cover_letter"}
def _imitate_company_research(db, profile, limit: int) -> dict:
rows = db.execute(
"SELECT j.id, j.title, j.company, j.description, j.status, "
" cr.raw_output, cr.company_brief "
"FROM jobs j LEFT JOIN company_research cr ON cr.job_id = j.id "
"WHERE j.description IS NOT NULL AND j.description != '' "
" AND j.status IN ('phone_screen','interviewing','offer','hired') "
"ORDER BY j.phone_screen_at DESC NULLS LAST LIMIT ?",
(limit,),
).fetchall()
name = profile.name if profile else "the candidate"
career_summary = profile.career_summary if profile else ""
# Load plain-text resume for context
resume_ctx = ""
try:
import yaml as _yaml
_rpath = PEREGRINE_ROOT / "config" / "plain_text_resume.yaml"
if _rpath.exists():
_rd = _yaml.safe_load(_rpath.read_text(encoding="utf-8")) or {}
parts = []
for section in ("experience", "skills", "education", "summary"):
val = _rd.get(section)
if val:
parts.append(f"### {section.title()}\n{val if isinstance(val, str) else str(val)}")
resume_ctx = "\n\n".join(parts)[:2000]
except Exception:
pass
samples = []
for r in rows:
jd = (r["description"] or "")[:1500].strip()
resume_block = f"\n## Candidate Background\n{resume_ctx}" if resume_ctx else ""
career_block = f"Candidate background: {career_summary}\n\n" if career_summary else ""
prompt = (
f"You are preparing {name} for a job interview.\n"
f"{career_block}"
f"Role: **{r['title']}** at **{r['company']}**\n\n"
f"## Job Description\n{jd}"
f"{resume_block}\n\n"
f"---\n\n"
f"Produce a structured research brief with exactly these markdown section headers:\n\n"
f"## Company Overview\n"
f"What {r['company']} does, core product/service, business model, size/stage, market positioning.\n\n"
f"## Leadership & Culture\n"
f"CEO background and leadership style, mission/values statements, Glassdoor themes.\n\n"
f"## Tech Stack & Product\n"
f"Technologies, platforms, and product direction relevant to the {r['title']} role.\n\n"
f"## Funding & Market Position\n"
f"Funding stage, key investors, recent rounds, competitor landscape.\n\n"
f"## Recent Developments\n"
f"News, launches, acquisitions, or press from the past 12-18 months.\n\n"
f"## Red Flags & Watch-outs\n"
f"Culture issues, layoffs, financial stress, or Glassdoor concerns worth knowing. "
f"If nothing notable, write 'No significant red flags identified.'\n\n"
f"## Talking Points for {name}\n"
f"Five specific talking points for the phone screen. Each must reference a concrete "
f"experience and connect to a specific JD signal. 1-2 sentences, ready to speak aloud. "
f"Never give generic advice.\n\n"
f"---\n"
f"⚠️ This brief uses LLM training knowledge only (no live web data). "
f"Verify key facts before the call."
)
samples.append({
"id": r["id"],
"job_title": r["title"],
"company": r["company"],
"status": r["status"],
"system_prompt": "",
"input_text": prompt,
"output_text": r["raw_output"] or r["company_brief"] or "",
})
return {"samples": samples, "total": len(samples), "type": "company_research"}
def _imitate_interview_prep(db, profile, limit: int) -> dict:
rows = db.execute(
"SELECT j.id, j.title, j.company, j.status, "
" cr.talking_points, cr.company_brief "
"FROM jobs j LEFT JOIN company_research cr ON cr.job_id = j.id "
"WHERE j.status IN ('phone_screen','interviewing','offer','hired') "
"ORDER BY j.phone_screen_at DESC NULLS LAST LIMIT ?",
(limit,),
).fetchall()
name = profile.name if profile else "the candidate"
samples = []
for r in rows:
system_prompt = (
f"You are a recruiter at {r['company']} conducting a phone screen for the "
f"{r['title']} role. Ask one question at a time. After {name} answers, give "
f"brief feedback (1-2 sentences), then ask your next question. Be professional but warm."
)
ctx_parts = []
if r["talking_points"]:
ctx_parts.append(f"[Candidate talking points]\n{r['talking_points']}")
if r["company_brief"]:
ctx_parts.append(f"[Company context]\n{r['company_brief'][:500]}")
ctx_block = ("\n\n".join(ctx_parts) + "\n\n") if ctx_parts else ""
input_text = (
f"{ctx_block}"
f"Start the mock phone screen for the {r['title']} role at {r['company']}. "
f"Ask your first question. Keep it realistic and concise."
)
samples.append({
"id": r["id"],
"job_title": r["title"],
"company": r["company"],
"status": r["status"],
"system_prompt": system_prompt,
"input_text": input_text,
"output_text": "",
})
return {"samples": samples, "total": len(samples), "type": "interview_prep"}
def _imitate_ats_resume(db, profile, limit: int) -> dict:
rows = db.execute(
"SELECT id, title, company, description, ats_gap_report, status FROM jobs "
"WHERE description IS NOT NULL AND description != '' "
" AND status IN ('applied','phone_screen','interviewing','offer','hired') "
"ORDER BY applied_at DESC NULLS LAST LIMIT ?",
(limit,),
).fetchall()
candidate_voice = profile.candidate_voice if profile else ""
voice_block = (
f"\nCandidate voice/style: {candidate_voice}\n"
"Preserve this tone in any phrasing suggestions."
) if candidate_voice else ""
resume_text = ""
try:
_rpath = PEREGRINE_ROOT / "config" / "plain_text_resume.yaml"
if _rpath.exists():
resume_text = _rpath.read_text(encoding="utf-8")[:3000]
except Exception:
pass
resume_block = f"\n## Current Resume\n{resume_text}" if resume_text else ""
samples = []
for r in rows:
desc = (r["description"] or "")[:1500].strip()
prompt = (
f"You are an ATS (applicant tracking system) keyword optimization expert.\n\n"
f"Analyze the resume below against this job description. Identify keyword gaps "
f"(terms in the JD missing or underrepresented in the resume) and for each gap "
f"specify which section it belongs in (summary, skills, or experience).\n\n"
f"Job: {r['title']} at {r['company']}\n\n"
f"## Job Description\n{desc}"
f"{resume_block}"
f"{voice_block}\n\n"
f"Return a JSON array of gap objects, each with keys:\n"
f' "term": the missing keyword\n'
f' "section": summary | skills | experience\n'
f' "priority": high | medium | low\n'
f' "rationale": one sentence explaining the gap\n\n'
f"Order by priority descending. Return ONLY the JSON array."
)
samples.append({
"id": r["id"],
"job_title": r["title"],
"company": r["company"],
"status": r["status"],
"system_prompt": "",
"input_text": prompt,
"output_text": r["ats_gap_report"] or "",
})
return {"samples": samples, "total": len(samples), "type": "ats_resume"}
@app.get("/api/imitate/samples")
def imitate_samples(type: str = "cover_letter", limit: int = 5):
"""Return the assembled generation prompt Peregrine would send to its LLM.
Each sample has:
system_prompt the system context (candidate voice, career summary)
input_text the full assembled user prompt (JD + resume + mission + style examples)
output_text existing generated output for comparison (may be empty)
Avocet sends system_prompt + input_text through different local models to
compare which best replicates Peregrine's generation quality.
type: cover_letter | company_research | interview_prep | ats_resume
"""
limit = max(1, min(limit, 20))
db = _get_db()
profile = _imitate_load_profile()
try:
if type == "cover_letter":
result = _imitate_cover_letter(db, profile, limit)
elif type == "company_research":
result = _imitate_company_research(db, profile, limit)
elif type == "interview_prep":
result = _imitate_interview_prep(db, profile, limit)
elif type == "ats_resume":
result = _imitate_ats_resume(db, profile, limit)
else:
raise HTTPException(
400,
f"Unknown type '{type}'. Use: cover_letter, company_research, interview_prep, ats_resume",
)
finally:
db.close()
return result
@app.get("/api/jobs/{job_id}/contacts")
def get_job_contacts(job_id: int):
db = _get_db()
rows = db.execute(
"SELECT id, direction, subject, from_addr, body, received_at "
"FROM job_contacts WHERE job_id = ? ORDER BY received_at DESC",
(job_id,),
).fetchall()
db.close()
return [dict(r) for r in rows]
class LogContactBody(BaseModel):
direction: str
subject: str
from_addr: Optional[str] = None
body: Optional[str] = None
received_at: Optional[str] = None
@app.post("/api/jobs/{job_id}/contacts")
def log_contact(job_id: int, payload: LogContactBody):
"""Log a manually entered inbound or outbound email contact for a job."""
db = _get_db()
received_at = payload.received_at or datetime.utcnow().isoformat()
db.execute(
"INSERT INTO job_contacts (job_id, direction, subject, from_addr, body, received_at) "
"VALUES (?, ?, ?, ?, ?, ?)",
(job_id, payload.direction, payload.subject, payload.from_addr, payload.body, received_at),
)
db.commit()
db.close()
return {"ok": True}
class InterviewDateBody(BaseModel):
interview_date: Optional[str] = None
@app.patch("/api/jobs/{job_id}/interview_date")
def set_interview_date(job_id: int, payload: InterviewDateBody):
"""Set or clear the interview date for a job without changing its pipeline status."""
interview_date = payload.interview_date # ISO string or null
db = _get_db()
db.execute("UPDATE jobs SET interview_date = ? WHERE id = ?", (interview_date, job_id))
db.commit()
db.close()
return {"ok": True}
@app.post("/api/jobs/{job_id}/calendar_push")
def calendar_push(job_id: int):
"""Push the job's interview event to the first configured calendar integration."""
from scripts.calendar_push import push_interview_event
db_path = Path(_request_db.get() or DB_PATH)
cfg_dir = db_path.parent / "config"
result = push_interview_event(
db_path=db_path,
job_id=job_id,
config_dir=cfg_dir,
)
if not result.get("ok"):
raise HTTPException(400, result.get("error", "Calendar push failed"))
return result
# ── Survey endpoints ─────────────────────────────────────────────────────────
# Module-level imports so tests can patch dev_api.LLMRouter etc.
from scripts.llm_router import LLMRouter
from scripts.db import insert_survey_response, get_survey_responses
_SURVEY_SYSTEM = (
"You are a job application advisor helping a candidate answer a culture-fit survey. "
"The candidate values collaborative teamwork, clear communication, growth, and impact. "
"Choose answers that present them in the best professional light."
)
def _build_text_prompt(text: str, mode: str) -> str:
if mode == "quick":
return (
"Answer each survey question below. For each, give ONLY the letter of the best "
"option and a single-sentence reason. Format exactly as:\n"
"1. B — reason here\n2. A — reason here\n\n"
f"Survey:\n{text}"
)
return (
"Analyze each survey question below. For each question:\n"
"- Briefly evaluate each option (1 sentence each)\n"
"- State your recommendation with reasoning\n\n"
f"Survey:\n{text}"
)
def _build_image_prompt(mode: str) -> str:
if mode == "quick":
return (
"This is a screenshot of a culture-fit survey. Read all questions and answer each "
"with the letter of the best option for a collaborative, growth-oriented candidate. "
"Format: '1. B — brief reason' on separate lines."
)
return (
"This is a screenshot of a culture-fit survey. For each question, evaluate each option "
"and recommend the best choice for a collaborative, growth-oriented candidate. "
"Include a brief breakdown per option and a clear recommendation."
)
@app.get("/api/vision/health")
def vision_health():
try:
r = requests.get("http://localhost:8002/health", timeout=2)
return {"available": r.status_code == 200}
except Exception:
return {"available": False}
class SurveyAnalyzeBody(BaseModel):
text: Optional[str] = None
image_b64: Optional[str] = None
mode: str # "quick" or "detailed"
@app.post("/api/jobs/{job_id}/survey/analyze")
def survey_analyze(job_id: int, body: SurveyAnalyzeBody):
if body.mode not in ("quick", "detailed"):
raise HTTPException(400, f"Invalid mode: {body.mode!r}")
try:
router = LLMRouter()
if body.image_b64:
prompt = _build_image_prompt(body.mode)
output = router.complete(
prompt,
images=[body.image_b64],
fallback_order=router.config.get("vision_fallback_order"),
)
source = "screenshot"
else:
prompt = _build_text_prompt(body.text or "", body.mode)
output = router.complete(
prompt,
system=_SURVEY_SYSTEM,
fallback_order=router.config.get("research_fallback_order"),
)
source = "text_paste"
return {"output": output, "source": source}
except Exception as e:
raise HTTPException(500, str(e))
class SurveySaveBody(BaseModel):
survey_name: Optional[str] = None
mode: str
source: str
raw_input: Optional[str] = None
image_b64: Optional[str] = None
llm_output: str
reported_score: Optional[str] = None
@app.post("/api/jobs/{job_id}/survey/responses")
def save_survey_response(job_id: int, body: SurveySaveBody):
if body.mode not in ("quick", "detailed"):
raise HTTPException(400, f"Invalid mode: {body.mode!r}")
received_at = datetime.now().isoformat()
image_path = None
if body.image_b64:
try:
import base64
screenshots_dir = Path(DB_PATH).parent / "survey_screenshots" / str(job_id)
screenshots_dir.mkdir(parents=True, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
img_path = screenshots_dir / f"{timestamp}.png"
img_path.write_bytes(base64.b64decode(body.image_b64))
image_path = str(img_path)
except Exception:
raise HTTPException(400, "Invalid image data")
row_id = insert_survey_response(
db_path=Path(_request_db.get() or DB_PATH),
job_id=job_id,
survey_name=body.survey_name,
received_at=received_at,
source=body.source,
raw_input=body.raw_input,
image_path=image_path,
mode=body.mode,
llm_output=body.llm_output,
reported_score=body.reported_score,
)
return {"id": row_id}
@app.get("/api/jobs/{job_id}/survey/responses")
def get_survey_history(job_id: int):
return get_survey_responses(db_path=Path(_request_db.get() or DB_PATH), job_id=job_id)
# ── GET /api/jobs/:id/cover_letter/pdf ───────────────────────────────────────
@app.get("/api/jobs/{job_id}/cover_letter/pdf")
def download_pdf(job_id: int):
db = _get_db()
row = db.execute(
"SELECT title, company, cover_letter FROM jobs WHERE id = ?", (job_id,)
).fetchone()
db.close()
if not row or not row["cover_letter"]:
raise HTTPException(404, "No cover letter found")
try:
from reportlab.lib.pagesizes import letter as letter_size
from reportlab.lib.units import inch
from reportlab.lib.colors import HexColor
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.enums import TA_LEFT
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
import io
buf = io.BytesIO()
doc = SimpleDocTemplate(buf, pagesize=letter_size,
leftMargin=inch, rightMargin=inch,
topMargin=inch, bottomMargin=inch)
dark = HexColor("#1a2338")
body_style = ParagraphStyle(
"Body", fontName="Helvetica", fontSize=11,
textColor=dark, leading=16, spaceAfter=12, alignment=TA_LEFT,
)
story = []
for para in row["cover_letter"].split("\n\n"):
para = para.strip()
if para:
story.append(Paragraph(para.replace("\n", "
"), body_style))
story.append(Spacer(1, 2))
doc.build(story)
company_safe = re.sub(r"[^a-zA-Z0-9]", "", row["company"] or "Company")
date_str = datetime.now().strftime("%Y-%m-%d")
filename = f"CoverLetter_{company_safe}_{date_str}.pdf"
return Response(
content=buf.getvalue(),
media_type="application/pdf",
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
)
except ImportError:
raise HTTPException(501, "reportlab not installed — install it to generate PDFs")
# ── Application Q&A endpoints ─────────────────────────────────────────────────
def _ensure_qa_column(db) -> None:
"""Add application_qa TEXT column to jobs if not present (idempotent)."""
try:
db.execute("ALTER TABLE jobs ADD COLUMN application_qa TEXT")
db.commit()
except Exception:
pass # Column already exists
class QAItem(BaseModel):
id: str
question: str
answer: str
class QAPayload(BaseModel):
items: List[QAItem]
class QASuggestPayload(BaseModel):
question: str
@app.get("/api/jobs/{job_id}/qa")
def get_qa(job_id: int):
db = _get_db()
_ensure_qa_column(db)
row = db.execute("SELECT application_qa FROM jobs WHERE id = ?", (job_id,)).fetchone()
db.close()
if not row:
raise HTTPException(404, "Job not found")
try:
items = json.loads(row["application_qa"] or "[]")
except Exception:
items = []
return {"items": items}
@app.patch("/api/jobs/{job_id}/qa")
def save_qa(job_id: int, payload: QAPayload):
db = _get_db()
_ensure_qa_column(db)
row = db.execute("SELECT id FROM jobs WHERE id = ?", (job_id,)).fetchone()
if not row:
db.close()
raise HTTPException(404, "Job not found")
db.execute(
"UPDATE jobs SET application_qa = ? WHERE id = ?",
(json.dumps([item.model_dump() for item in payload.items]), job_id),
)
db.commit()
db.close()
return {"ok": True}
@app.post("/api/jobs/{job_id}/qa/suggest")
def suggest_qa_answer(job_id: int, payload: QASuggestPayload):
"""Synchronously generate an LLM answer for an application Q&A question."""
db = _get_db()
job_row = db.execute(
"SELECT title, company, description FROM jobs WHERE id = ?", (job_id,)
).fetchone()
db.close()
if not job_row:
raise HTTPException(404, "Job not found")
# Load resume summary for context
resume_context = ""
try:
resume_path = _resume_path()
if resume_path.exists():
with open(resume_path) as f:
resume_data = yaml.safe_load(f) or {}
parts = []
if resume_data.get("name"):
parts.append(f"Candidate: {resume_data['name']}")
if resume_data.get("skills"):
parts.append(f"Skills: {', '.join(resume_data['skills'][:20])}")
if resume_data.get("experience"):
exp = resume_data["experience"]
if isinstance(exp, list) and exp:
titles = [e.get("title", "") for e in exp[:3] if e.get("title")]
if titles:
parts.append(f"Recent roles: {', '.join(titles)}")
if resume_data.get("career_summary"):
parts.append(f"Summary: {resume_data['career_summary'][:400]}")
resume_context = "\n".join(parts)
except Exception:
pass
prompt = (
f"You are helping a job applicant answer an application question.\n\n"
f"Job: {job_row['title']} at {job_row['company']}\n"
f"Job description excerpt:\n{(job_row['description'] or '')[:800]}\n\n"
f"Candidate background:\n{resume_context or 'Not provided'}\n\n"
f"Application question: {payload.question}\n\n"
"Write a concise, professional answer (2–4 sentences) in first person. "
"Be specific and genuine. Do not use hollow filler phrases."
)
try:
from scripts.llm_router import LLMRouter
router = LLMRouter()
answer = router.complete(prompt)
return {"answer": answer.strip()}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
# ── POST /api/jobs/:id/hired-feedback ─────────────────────────────────────────
class HiredFeedbackPayload(BaseModel):
what_helped: str = ""
factors: list[str] = []
@app.post("/api/jobs/{job_id}/hired-feedback")
def save_hired_feedback(job_id: int, payload: HiredFeedbackPayload):
db = _get_db()
row = db.execute("SELECT status FROM jobs WHERE id = ?", (job_id,)).fetchone()
if not row:
raise HTTPException(404, "Job not found")
if row["status"] != "hired":
raise HTTPException(400, "Feedback only accepted for hired jobs")
db.execute(
"UPDATE jobs SET hired_feedback = ? WHERE id = ?",
(json.dumps({"what_helped": payload.what_helped, "factors": payload.factors}), job_id),
)
db.commit()
db.close()
return {"ok": True}
# ── GET /api/contacts ──────────────────────────────────────────────────────────
@app.get("/api/contacts")
def list_contacts(job_id: Optional[int] = None, direction: Optional[str] = None,
search: Optional[str] = None, limit: int = 100, offset: int = 0):
db = _get_db()
query = """
SELECT jc.id, jc.job_id, jc.direction, jc.subject, jc.from_addr, jc.to_addr,
jc.received_at, jc.stage_signal,
j.title AS job_title, j.company AS job_company
FROM job_contacts jc
LEFT JOIN jobs j ON j.id = jc.job_id
WHERE 1=1
"""
params: list = []
if job_id is not None:
query += " AND jc.job_id = ?"
params.append(job_id)
if direction:
query += " AND jc.direction = ?"
params.append(direction)
if search:
query += " AND (jc.from_addr LIKE ? OR jc.to_addr LIKE ? OR jc.subject LIKE ?)"
like = f"%{search}%"
params += [like, like, like]
query += " ORDER BY jc.received_at DESC LIMIT ? OFFSET ?"
params += [limit, offset]
rows = db.execute(query, params).fetchall()
total = db.execute(
"SELECT COUNT(*) FROM job_contacts" + (" WHERE job_id = ?" if job_id else ""),
([job_id] if job_id else []),
).fetchone()[0]
db.close()
return {"total": total, "contacts": [dict(r) for r in rows]}
# ── References ─────────────────────────────────────────────────────────────────
class ReferencePayload(BaseModel):
name: str
relationship: str = ""
company: str = ""
email: str = ""
phone: str = ""
notes: str = ""
tags: list[str] = []
class PrepEmailPayload(BaseModel):
job_id: int
class RecLetterPayload(BaseModel):
job_id: int
talking_points: str = ""
@app.get("/api/references")
def list_references():
db = _get_db()
rows = db.execute(
"SELECT * FROM references_ ORDER BY name ASC"
).fetchall()
db.close()
return [dict(r) for r in rows]
@app.post("/api/references")
def create_reference(payload: ReferencePayload):
db = _get_db()
cur = db.execute(
"""INSERT INTO references_ (name, relationship, company, email, phone, notes, tags)
VALUES (?, ?, ?, ?, ?, ?, ?)""",
(payload.name, payload.relationship, payload.company,
payload.email, payload.phone, payload.notes,
json.dumps(payload.tags)),
)
db.commit()
row = db.execute("SELECT * FROM references_ WHERE id = ?", (cur.lastrowid,)).fetchone()
db.close()
return dict(row)
@app.patch("/api/references/{ref_id}")
def update_reference(ref_id: int, payload: ReferencePayload):
db = _get_db()
row = db.execute("SELECT id FROM references_ WHERE id = ?", (ref_id,)).fetchone()
if not row:
raise HTTPException(404, "Reference not found")
db.execute(
"""UPDATE references_ SET name=?, relationship=?, company=?, email=?, phone=?,
notes=?, tags=?, updated_at=datetime('now') WHERE id=?""",
(payload.name, payload.relationship, payload.company,
payload.email, payload.phone, payload.notes,
json.dumps(payload.tags), ref_id),
)
db.commit()
updated = db.execute("SELECT * FROM references_ WHERE id = ?", (ref_id,)).fetchone()
db.close()
return dict(updated)
@app.delete("/api/references/{ref_id}")
def delete_reference(ref_id: int):
db = _get_db()
db.execute("DELETE FROM references_ WHERE id = ?", (ref_id,))
db.commit()
db.close()
return {"ok": True}
@app.get("/api/references/for-job/{job_id}")
def references_for_job(job_id: int):
db = _get_db()
rows = db.execute(
"""SELECT r.*, jr.prep_email, jr.rec_letter, jr.id AS jr_id
FROM references_ r
JOIN job_references jr ON jr.reference_id = r.id
WHERE jr.job_id = ?
ORDER BY r.name ASC""",
(job_id,),
).fetchall()
db.close()
return [dict(r) for r in rows]
@app.post("/api/references/{ref_id}/link-job")
def link_reference_to_job(ref_id: int, body: PrepEmailPayload):
db = _get_db()
try:
db.execute(
"INSERT INTO job_references (job_id, reference_id) VALUES (?, ?)",
(body.job_id, ref_id),
)
db.commit()
except Exception:
pass # already linked
db.close()
return {"ok": True}
@app.delete("/api/references/{ref_id}/unlink-job/{job_id}")
def unlink_reference_from_job(ref_id: int, job_id: int):
db = _get_db()
db.execute(
"DELETE FROM job_references WHERE reference_id = ? AND job_id = ?",
(ref_id, job_id),
)
db.commit()
db.close()
return {"ok": True}
@app.post("/api/references/{ref_id}/prep-email")
def generate_prep_email(ref_id: int, payload: PrepEmailPayload):
"""Draft a short 'heads up' email to send a reference before they hear from the hiring team."""
db = _get_db()
ref_row = db.execute("SELECT * FROM references_ WHERE id = ?", (ref_id,)).fetchone()
if not ref_row:
db.close()
raise HTTPException(404, "Reference not found")
job_row = db.execute(
"SELECT title, company, description FROM jobs WHERE id = ?", (payload.job_id,)
).fetchone()
if not job_row:
db.close()
raise HTTPException(404, "Job not found")
ref = dict(ref_row)
job = dict(job_row)
db.close()
prompt = f"""Draft a short, warm email to send to a professional reference before a job interview.
Reference: {ref['name']} ({ref['relationship']} at {ref['company']})
Role applying for: {job['title']} at {job['company']}
Job description excerpt: {(job['description'] or '')[:500]}
The email should:
- Be 3-4 short paragraphs max
- Thank them for being a reference
- Briefly describe the role and why it's a good fit
- Mention 1-2 specific accomplishments they could speak to
- Give them a heads-up they may be contacted soon
- Be warm and professional, not overly formal
Return only the email body (no subject line)."""
try:
from scripts.llm_router import LLMRouter
router = LLMRouter()
email_text = router.complete(prompt)
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
# Persist to job_references
db = _get_db()
db.execute(
"""INSERT INTO job_references (job_id, reference_id, prep_email)
VALUES (?, ?, ?)
ON CONFLICT(job_id, reference_id) DO UPDATE SET prep_email = excluded.prep_email""",
(payload.job_id, ref_id, email_text),
)
db.commit()
db.close()
return {"prep_email": email_text}
@app.post("/api/references/{ref_id}/rec-letter")
def generate_rec_letter(ref_id: int, payload: RecLetterPayload):
"""Draft a recommendation letter the reference can edit and send on their letterhead."""
db = _get_db()
ref_row = db.execute("SELECT * FROM references_ WHERE id = ?", (ref_id,)).fetchone()
if not ref_row:
db.close()
raise HTTPException(404, "Reference not found")
job_row = db.execute(
"SELECT title, company, description FROM jobs WHERE id = ?", (payload.job_id,)
).fetchone()
if not job_row:
db.close()
raise HTTPException(404, "Job not found")
ref = dict(ref_row)
job = dict(job_row)
db.close()
prompt = f"""Draft a professional recommendation letter that {ref['name']} ({ref['relationship']}) could send on their letterhead for a candidate applying to {job['title']} at {job['company']}.
Key talking points to highlight: {payload.talking_points or 'general professional excellence, collaboration, initiative'}
The letter should:
- Be addressed generically (Dear Hiring Manager)
- Be 3-4 paragraphs
- Sound natural — written from the recommender's voice, not the candidate's
- Highlight specific, credible observations a {ref['relationship']} would have
- Close with strong endorsement and contact offer
Return only the letter body."""
try:
from scripts.llm_router import LLMRouter
router = LLMRouter()
letter_text = router.complete(prompt)
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
db = _get_db()
db.execute(
"""INSERT INTO job_references (job_id, reference_id, rec_letter)
VALUES (?, ?, ?)
ON CONFLICT(job_id, reference_id) DO UPDATE SET rec_letter = excluded.rec_letter""",
(payload.job_id, ref_id, letter_text),
)
db.commit()
db.close()
return {"rec_letter": letter_text}
# ── GET /api/interviews ────────────────────────────────────────────────────────
PIPELINE_STATUSES = {
"applied", "survey",
"phone_screen", "interviewing",
"offer", "hired",
"interview_rejected",
}
SIGNAL_EXCLUDED = ("neutral", "unrelated", "digest", "event_rescheduled")
@app.get("/api/interviews")
def list_interviews():
db = _get_db()
placeholders = ",".join("?" * len(PIPELINE_STATUSES))
rows = db.execute(
f"SELECT id, title, company, url, location, is_remote, salary, "
f"match_score, keyword_gaps, status, "
f"interview_date, rejection_stage, "
f"applied_at, phone_screen_at, interviewing_at, offer_at, hired_at, survey_at, hired_feedback "
f"FROM jobs WHERE status IN ({placeholders}) "
f"ORDER BY match_score DESC NULLS LAST",
list(PIPELINE_STATUSES),
).fetchall()
job_ids = [r["id"] for r in rows]
signals_by_job: dict[int, list] = {r["id"]: [] for r in rows}
if job_ids:
sig_placeholders = ",".join("?" * len(job_ids))
excl_placeholders = ",".join("?" * len(SIGNAL_EXCLUDED))
sig_rows = db.execute(
f"SELECT id, job_id, subject, received_at, stage_signal, body, from_addr "
f"FROM job_contacts "
f"WHERE job_id IN ({sig_placeholders}) "
f" AND suggestion_dismissed = 0 "
f" AND stage_signal NOT IN ({excl_placeholders}) "
f" AND stage_signal IS NOT NULL "
f"ORDER BY received_at DESC",
job_ids + list(SIGNAL_EXCLUDED),
).fetchall()
for sr in sig_rows:
signals_by_job[sr["job_id"]].append({
"id": sr["id"],
"subject": sr["subject"],
"received_at": sr["received_at"],
"stage_signal": sr["stage_signal"],
"body": _strip_html(sr["body"]),
"from_addr": sr["from_addr"],
})
db.close()
return [
{**dict(r), "is_remote": bool(r["is_remote"]), "stage_signals": signals_by_job[r["id"]]}
for r in rows
]
# ── POST /api/email/sync ──────────────────────────────────────────────────
@app.post("/api/email/sync", status_code=202)
def trigger_email_sync():
db = _get_db()
cursor = db.execute(
"INSERT INTO background_tasks (task_type, job_id, status) VALUES ('email_sync', 0, 'queued')"
)
db.commit()
task_id = cursor.lastrowid
db.close()
return {"task_id": task_id}
# ── GET /api/email/sync/status ────────────────────────────────────────────
@app.get("/api/email/sync/status")
def email_sync_status():
db = _get_db()
row = db.execute(
"SELECT status, finished_at AS last_completed_at "
"FROM background_tasks "
"WHERE task_type = 'email_sync' "
"ORDER BY id DESC LIMIT 1"
).fetchone()
db.close()
if row is None:
return {"status": "idle", "last_completed_at": None, "error": None}
# background_tasks may not have an error column in staging — guard with dict access
row_dict = dict(row)
return {
"status": row_dict["status"],
"last_completed_at": row_dict["last_completed_at"],
"error": row_dict.get("error"),
}
# ── Task management routes ─────────────────────────────────────────────────────
def _db_path() -> Path:
"""Return the effective staging.db path (cloud-aware)."""
return Path(_request_db.get() or DB_PATH)
@app.get("/api/tasks")
def list_active_tasks():
from scripts.db import get_active_tasks
return get_active_tasks(_db_path())
@app.get("/api/tasks/active")
def list_active_tasks_envelope():
"""Envelope wrapper for the Vue task indicator poll — returns {count, tasks}."""
from scripts.db import get_active_tasks
tasks = get_active_tasks(_db_path())
return {"count": len(tasks), "tasks": tasks}
@app.delete("/api/tasks/{task_id}")
def cancel_task_by_id(task_id: int):
from scripts.db import cancel_task
ok = cancel_task(_db_path(), task_id)
return {"ok": ok}
@app.post("/api/tasks/kill")
def kill_stuck():
from scripts.db import kill_stuck_tasks
killed = kill_stuck_tasks(_db_path())
return {"killed": killed}
@app.post("/api/tasks/discovery", status_code=202)
def trigger_discovery():
from scripts.task_runner import submit_task
task_id, is_new = submit_task(_db_path(), "discovery", 0)
return {"task_id": task_id, "is_new": is_new}
@app.post("/api/tasks/email-sync", status_code=202)
def trigger_email_sync_task():
from scripts.task_runner import submit_task
task_id, is_new = submit_task(_db_path(), "email_sync", 0)
return {"task_id": task_id, "is_new": is_new}
@app.post("/api/tasks/enrich", status_code=202)
def trigger_enrich_task():
from scripts.task_runner import submit_task
task_id, is_new = submit_task(_db_path(), "enrich_descriptions", 0)
return {"task_id": task_id, "is_new": is_new}
@app.post("/api/tasks/score")
def trigger_score():
try:
result = subprocess.run(
[sys.executable, "scripts/match.py"],
capture_output=True, text=True, cwd=str(PEREGRINE_ROOT),
)
if result.returncode == 0:
return {"ok": True, "output": result.stdout}
raise HTTPException(status_code=500, detail=result.stderr)
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/tasks/sync")
def trigger_notion_sync():
try:
from scripts.sync import sync_to_notion
count = sync_to_notion(_db_path())
return {"ok": True, "count": count}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Bulk job actions ───────────────────────────────────────────────────────────
class BulkArchiveBody(BaseModel):
statuses: List[str]
@app.post("/api/jobs/archive")
def bulk_archive_jobs(body: BulkArchiveBody):
from scripts.db import archive_jobs
n = archive_jobs(_db_path(), statuses=body.statuses)
return {"archived": n}
class BulkPurgeBody(BaseModel):
statuses: Optional[List[str]] = None
target: Optional[str] = None # "email", "non_remote", "rescrape"
@app.post("/api/jobs/purge")
def bulk_purge_jobs(body: BulkPurgeBody):
from scripts.db import purge_jobs, purge_email_data, purge_non_remote
if body.target == "email":
contacts, jobs = purge_email_data(_db_path())
return {"ok": True, "contacts": contacts, "jobs": jobs}
if body.target == "non_remote":
n = purge_non_remote(_db_path())
return {"ok": True, "deleted": n}
if body.target == "rescrape":
purge_jobs(_db_path(), statuses=["pending", "approved", "rejected"])
from scripts.task_runner import submit_task
submit_task(_db_path(), "discovery", 0)
return {"ok": True}
statuses = body.statuses or ["pending", "rejected"]
n = purge_jobs(_db_path(), statuses=statuses)
return {"ok": True, "deleted": n}
class AddJobsBody(BaseModel):
urls: List[str]
@app.post("/api/jobs/add", status_code=202)
def add_jobs_by_url(body: AddJobsBody):
try:
from datetime import datetime as _dt
from scripts.scrape_url import canonicalize_url
from scripts.db import get_existing_urls, insert_job
from scripts.task_runner import submit_task
db_path = _db_path()
existing = get_existing_urls(db_path)
queued = 0
for raw_url in body.urls:
url = canonicalize_url(raw_url.strip())
if not url.startswith("http") or url in existing:
continue
job_id = insert_job(db_path, {
"title": "Importing...", "company": "", "url": url,
"source": "manual", "location": "", "description": "",
"date_found": _dt.now().isoformat()[:10],
})
if job_id:
submit_task(db_path, "scrape_url", job_id)
queued += 1
return {"queued": queued}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/jobs/upload-csv", status_code=202)
async def upload_jobs_csv(file: UploadFile):
try:
import csv as _csv
import io as _io
from datetime import datetime as _dt
from scripts.scrape_url import canonicalize_url
from scripts.db import get_existing_urls, insert_job
from scripts.task_runner import submit_task
content = await file.read()
reader = _csv.DictReader(_io.StringIO(content.decode("utf-8", errors="replace")))
urls: list[str] = []
for row in reader:
for val in row.values():
if val and val.strip().startswith("http"):
urls.append(val.strip())
break
db_path = _db_path()
existing = get_existing_urls(db_path)
queued = 0
for raw_url in urls:
url = canonicalize_url(raw_url)
if not url.startswith("http") or url in existing:
continue
job_id = insert_job(db_path, {
"title": "Importing...", "company": "", "url": url,
"source": "manual", "location": "", "description": "",
"date_found": _dt.now().isoformat()[:10],
})
if job_id:
submit_task(db_path, "scrape_url", job_id)
queued += 1
return {"queued": queued, "total": len(urls)}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Setup banners ──────────────────────────────────────────────────────────────
_SETUP_BANNERS = [
{"key": "connect_cloud", "text": "Connect a cloud service for resume/cover letter storage", "link": "/settings?tab=integrations"},
{"key": "setup_email", "text": "Set up email sync to catch recruiter outreach", "link": "/settings?tab=email"},
{"key": "setup_email_labels", "text": "Set up email label filters for auto-classification", "link": "/settings?tab=email"},
{"key": "tune_mission", "text": "Tune your mission preferences for better cover letters", "link": "/settings?tab=profile"},
{"key": "configure_keywords", "text": "Configure keywords and blocklist for smarter search", "link": "/settings?tab=search"},
{"key": "upload_corpus", "text": "Upload your cover letter corpus for voice fine-tuning", "link": "/settings?tab=fine-tune"},
{"key": "configure_linkedin", "text": "Configure LinkedIn Easy Apply automation", "link": "/settings?tab=integrations"},
{"key": "setup_searxng", "text": "Set up company research with SearXNG", "link": "/settings?tab=system"},
{"key": "target_companies", "text": "Build a target company list for focused outreach", "link": "/settings?tab=search"},
{"key": "setup_notifications", "text": "Set up notifications for stage changes", "link": "/settings?tab=integrations"},
{"key": "tune_model", "text": "Tune a custom cover letter model on your writing", "link": "/settings?tab=fine-tune"},
{"key": "review_training", "text": "Review and curate training data for model tuning", "link": "/settings?tab=fine-tune"},
{"key": "setup_calendar", "text": "Set up calendar sync to track interview dates", "link": "/settings?tab=integrations"},
]
@app.get("/api/config/setup-banners")
def get_setup_banners():
try:
cfg = _load_user_config()
if not cfg.get("wizard_complete"):
return []
dismissed = set(cfg.get("dismissed_banners", []))
return [b for b in _SETUP_BANNERS if b["key"] not in dismissed]
except Exception:
return []
@app.post("/api/config/setup-banners/{key}/dismiss")
def dismiss_setup_banner(key: str):
try:
cfg = _load_user_config()
dismissed = cfg.get("dismissed_banners", [])
if key not in dismissed:
dismissed.append(key)
cfg["dismissed_banners"] = dismissed
_save_user_config(cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── POST /api/stage-signals/{id}/dismiss ─────────────────────────────────
@app.post("/api/stage-signals/{signal_id}/dismiss")
def dismiss_signal(signal_id: int):
db = _get_db()
result = db.execute(
"UPDATE job_contacts SET suggestion_dismissed = 1 WHERE id = ?",
(signal_id,),
)
db.commit()
rowcount = result.rowcount
db.close()
if rowcount == 0:
raise HTTPException(404, "Signal not found")
return {"ok": True}
# ── POST /api/stage-signals/{id}/reclassify ──────────────────────────────
VALID_SIGNAL_LABELS = {
'interview_scheduled', 'offer_received', 'rejected',
'positive_response', 'survey_received', 'neutral',
'event_rescheduled', 'unrelated', 'digest',
}
class ReclassifyBody(BaseModel):
stage_signal: str
@app.post("/api/stage-signals/{signal_id}/reclassify")
def reclassify_signal(signal_id: int, body: ReclassifyBody):
if body.stage_signal not in VALID_SIGNAL_LABELS:
raise HTTPException(400, f"Invalid label: {body.stage_signal}")
db = _get_db()
result = db.execute(
"UPDATE job_contacts SET stage_signal = ? WHERE id = ?",
(body.stage_signal, signal_id),
)
db.commit()
rowcount = result.rowcount
db.close()
if rowcount == 0:
raise HTTPException(404, "Signal not found")
return {"ok": True}
# ── Digest queue models ───────────────────────────────────────────────────
class DigestQueueBody(BaseModel):
job_contact_id: int
# ── GET /api/digest-queue ─────────────────────────────────────────────────
@app.get("/api/digest-queue")
def list_digest_queue():
db = _get_db()
rows = db.execute(
"""SELECT dq.id, dq.job_contact_id, dq.created_at,
jc.subject, jc.from_addr, jc.received_at, jc.body
FROM digest_queue dq
JOIN job_contacts jc ON jc.id = dq.job_contact_id
ORDER BY dq.created_at DESC"""
).fetchall()
db.close()
return [
{
"id": r["id"],
"job_contact_id": r["job_contact_id"],
"created_at": r["created_at"],
"subject": r["subject"],
"from_addr": r["from_addr"],
"received_at": r["received_at"],
"body": _strip_html(r["body"]),
}
for r in rows
]
# ── POST /api/digest-queue ────────────────────────────────────────────────
@app.post("/api/digest-queue")
def add_to_digest_queue(body: DigestQueueBody):
db = _get_db()
try:
exists = db.execute(
"SELECT 1 FROM job_contacts WHERE id = ?", (body.job_contact_id,)
).fetchone()
if not exists:
raise HTTPException(404, "job_contact_id not found")
result = db.execute(
"INSERT OR IGNORE INTO digest_queue (job_contact_id) VALUES (?)",
(body.job_contact_id,),
)
db.commit()
created = result.rowcount > 0
finally:
db.close()
return {"ok": True, "created": created}
# ── POST /api/digest-queue/{id}/extract-links ─────────────────────────────
@app.post("/api/digest-queue/{digest_id}/extract-links")
def extract_digest_links(digest_id: int):
db = _get_db()
try:
row = db.execute(
"""SELECT jc.body
FROM digest_queue dq
JOIN job_contacts jc ON jc.id = dq.job_contact_id
WHERE dq.id = ?""",
(digest_id,),
).fetchone()
finally:
db.close()
if not row:
raise HTTPException(404, "Digest entry not found")
return {"links": _extract_links(row["body"] or "")}
# ── POST /api/digest-queue/{id}/queue-jobs ────────────────────────────────
class QueueJobsBody(BaseModel):
urls: list[str]
@app.post("/api/digest-queue/{digest_id}/queue-jobs")
def queue_digest_jobs(digest_id: int, body: QueueJobsBody):
if not body.urls:
raise HTTPException(400, "urls must not be empty")
db = _get_db()
try:
exists = db.execute(
"SELECT 1 FROM digest_queue WHERE id = ?", (digest_id,)
).fetchone()
finally:
db.close()
if not exists:
raise HTTPException(404, "Digest entry not found")
try:
from scripts.db import insert_job
except ImportError:
raise HTTPException(500, "scripts.db not available")
queued = 0
skipped = 0
for url in body.urls:
if not url or not url.startswith(('http://', 'https://')):
skipped += 1
continue
result = insert_job(Path(DB_PATH), {
'url': url,
'title': '',
'company': '',
'source': 'digest',
'date_found': datetime.utcnow().isoformat(),
})
if result:
queued += 1
else:
skipped += 1
return {"ok": True, "queued": queued, "skipped": skipped}
# ── DELETE /api/digest-queue/{id} ────────────────────────────────────────
@app.delete("/api/digest-queue/{digest_id}")
def delete_digest_entry(digest_id: int):
db = _get_db()
try:
result = db.execute("DELETE FROM digest_queue WHERE id = ?", (digest_id,))
db.commit()
rowcount = result.rowcount
finally:
db.close()
if rowcount == 0:
raise HTTPException(404, "Digest entry not found")
return {"ok": True}
# ── POST /api/jobs/{id}/move ───────────────────────────────────────────────────
STATUS_TIMESTAMP_COL = {
"applied": "applied_at",
"survey": "survey_at",
"phone_screen": "phone_screen_at",
"interviewing": "interviewing_at",
"offer": "offer_at",
"hired": "hired_at",
"interview_rejected": None, # uses rejection_stage instead
}
class MoveBody(BaseModel):
status: str
interview_date: str | None = None
rejection_stage: str | None = None
@app.post("/api/jobs/{job_id}/move")
def move_job(job_id: int, body: MoveBody):
if body.status not in STATUS_TIMESTAMP_COL:
raise HTTPException(400, f"Invalid pipeline status: {body.status}")
db = _get_db()
ts_col = STATUS_TIMESTAMP_COL[body.status]
if ts_col:
db.execute(
f"UPDATE jobs SET status = ?, {ts_col} = datetime('now') WHERE id = ?",
(body.status, job_id),
)
else:
db.execute(
"UPDATE jobs SET status = ?, rejection_stage = ? WHERE id = ?",
(body.status, body.rejection_stage, job_id),
)
if body.interview_date is not None:
db.execute(
"UPDATE jobs SET interview_date = ? WHERE id = ?",
(body.interview_date, job_id),
)
db.commit()
db.close()
return {"ok": True}
_HEIMDALL_URL = os.environ.get("HEIMDALL_URL", "https://license.circuitforge.tech")
_HEIMDALL_ADMIN_TOKEN = os.environ.get("HEIMDALL_ADMIN_TOKEN", "")
def _resolve_cloud_tier() -> str:
"""Resolve the current user's tier from Heimdall for cloud API responses.
Extracts the user_id from the per-request DB path set by cloud_session_middleware
(format: //peregrine/staging.db), then calls Heimdall
/admin/cloud/resolve. Returns "free" on any error so the app degrades gracefully.
"""
if not _HEIMDALL_ADMIN_TOKEN:
_log.warning("HEIMDALL_ADMIN_TOKEN not set — defaulting API tier to free")
return "free"
db_path = _request_db.get()
if not db_path:
return "free"
# Extract user_id: .../menagerie-data//peregrine/staging.db
try:
user_id = Path(db_path).parts[-3]
except IndexError:
_log.warning("_resolve_cloud_tier: unexpected db_path format: %s", db_path)
return "free"
try:
resp = requests.post(
f"{_HEIMDALL_URL}/admin/cloud/resolve",
json={"user_id": user_id, "product": "peregrine"},
headers={"Authorization": f"Bearer {_HEIMDALL_ADMIN_TOKEN}"},
timeout=5,
)
if resp.status_code == 200:
return resp.json().get("tier", "free")
if resp.status_code == 404:
return "free"
_log.warning("Heimdall resolve returned %s for user %s", resp.status_code, user_id)
except Exception as exc:
_log.warning("Heimdall tier resolve failed for user %s: %s", user_id, exc)
return "free"
# ── GET /api/config/app ───────────────────────────────────────────────────────
@app.get("/api/config/app")
def get_app_config():
import os
profile = os.environ.get("INFERENCE_PROFILE", "cpu")
valid_profiles = {"remote", "cpu", "single-gpu", "dual-gpu"}
valid_tiers = {"free", "paid", "premium", "ultra"}
# Cloud: resolve tier from Heimdall (APP_TIER env is single-tenant only).
is_cloud = os.environ.get("CLOUD_MODE", "").lower() in ("1", "true")
if is_cloud:
raw_tier = _resolve_cloud_tier()
else:
raw_tier = os.environ.get("APP_TIER", "free")
if is_cloud:
wizard_complete = True
else:
try:
cfg = load_user_profile(_user_yaml_path())
wizard_complete = bool(cfg.get("wizard_complete", False))
except Exception:
wizard_complete = False
return {
"isCloud": os.environ.get("CLOUD_MODE", "").lower() in ("1", "true"),
"isDemo": os.environ.get("DEMO_MODE", "").lower() in ("1", "true", "yes"),
"isDevMode": os.environ.get("DEV_MODE", "").lower() in ("1", "true"),
"tier": raw_tier if raw_tier in valid_tiers else "free",
"contractedClient": os.environ.get("CONTRACTED_CLIENT", "").lower() in ("1", "true"),
"inferenceProfile": profile if profile in valid_profiles else "cpu",
"wizardComplete": wizard_complete,
}
# ── GET /api/config/user ──────────────────────────────────────────────────────
@app.get("/api/config/user")
def config_user():
# Try to read name from user.yaml if present
try:
import yaml
cfg_path = _user_yaml_path()
with open(cfg_path) as f:
cfg = yaml.safe_load(f)
return {"name": cfg.get("name", "")}
except Exception:
return {"name": ""}
# ── Settings: My Profile endpoints ───────────────────────────────────────────
from scripts.user_profile import load_user_profile, save_user_profile
def _user_yaml_path() -> str:
"""Resolve user.yaml path relative to the active staging.db.
In cloud mode the ContextVar holds the per-user db path; elsewhere
falls back to STAGING_DB env var. Never crosses user boundaries.
"""
db = _request_db.get() or os.environ.get("STAGING_DB", "/devl/peregrine/staging.db")
return os.path.join(os.path.dirname(db), "config", "user.yaml")
def _mission_dict_to_list(prefs: object) -> list:
"""Convert {industry: note} dict to [{industry, note}] list for the SPA."""
if isinstance(prefs, list):
return prefs
if isinstance(prefs, dict):
return [{"industry": k, "note": v or ""} for k, v in prefs.items()]
return []
def _mission_list_to_dict(prefs: list) -> dict:
"""Convert [{industry, note}] list from the SPA back to {industry: note} dict."""
result = {}
for item in prefs:
if isinstance(item, dict):
result[item.get("industry", "")] = item.get("note", "")
return result
@app.get("/api/settings/profile")
def get_profile():
try:
cfg = load_user_profile(_user_yaml_path())
return {
"name": cfg.get("name", ""),
"email": cfg.get("email", ""),
"phone": cfg.get("phone", ""),
"linkedin_url": cfg.get("linkedin", ""),
"career_summary": cfg.get("career_summary", ""),
"candidate_voice": cfg.get("candidate_voice", ""),
"inference_profile": cfg.get("inference_profile", "cpu"),
"mission_preferences": _mission_dict_to_list(cfg.get("mission_preferences", {})),
"nda_companies": cfg.get("nda_companies", []),
"accessibility_focus": cfg.get("candidate_accessibility_focus", False),
"lgbtq_focus": cfg.get("candidate_lgbtq_focus", False),
}
except Exception as e:
raise HTTPException(500, f"Could not read profile: {e}")
class MissionPrefModel(BaseModel):
industry: str
note: str = ""
class UserProfilePayload(BaseModel):
name: str = ""
email: str = ""
phone: str = ""
linkedin_url: str = ""
career_summary: str = ""
candidate_voice: str = ""
inference_profile: str = "cpu"
mission_preferences: List[MissionPrefModel] = []
nda_companies: List[str] = []
accessibility_focus: bool = False
lgbtq_focus: bool = False
class IdentitySyncPayload(BaseModel):
name: str = ""
email: str = ""
phone: str = ""
linkedin_url: str = ""
_VALID_THEMES = frozenset({"auto", "light", "dark", "solarized-dark", "solarized-light", "colorblind"})
class ThemePayload(BaseModel):
theme: str
@app.post("/api/settings/theme")
def set_theme(payload: ThemePayload):
"""Persist the user's chosen theme to user.yaml."""
if payload.theme not in _VALID_THEMES:
raise HTTPException(status_code=400, detail=f"Invalid theme: {payload.theme}")
try:
data = load_user_profile(_user_yaml_path())
data["theme"] = payload.theme
save_user_profile(_user_yaml_path(), data)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
class UIPrefPayload(BaseModel):
preference: str # "streamlit" | "vue"
@app.post("/api/settings/ui-preference")
def set_ui_preference(payload: UIPrefPayload):
"""Persist UI preference to user.yaml so Streamlit doesn't re-set the cookie."""
if payload.preference not in ("streamlit", "vue"):
raise HTTPException(status_code=400, detail="preference must be 'streamlit' or 'vue'")
try:
data = load_user_profile(_user_yaml_path())
data["ui_preference"] = payload.preference
save_user_profile(_user_yaml_path(), data)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/resume/sync-identity")
def sync_identity(payload: IdentitySyncPayload):
"""Sync identity fields from profile store back to user.yaml."""
try:
data = load_user_profile(_user_yaml_path())
data["name"] = payload.name
data["email"] = payload.email
data["phone"] = payload.phone
data["linkedin"] = payload.linkedin_url # yaml key is 'linkedin', not 'linkedin_url'
save_user_profile(_user_yaml_path(), data)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/profile")
def save_profile(payload: UserProfilePayload):
try:
yaml_path = _user_yaml_path()
cfg = load_user_profile(yaml_path)
cfg["name"] = payload.name
cfg["email"] = payload.email
cfg["phone"] = payload.phone
cfg["linkedin"] = payload.linkedin_url
cfg["career_summary"] = payload.career_summary
cfg["candidate_voice"] = payload.candidate_voice
cfg["inference_profile"] = payload.inference_profile
cfg["mission_preferences"] = _mission_list_to_dict(
[m.model_dump() for m in payload.mission_preferences]
)
cfg["nda_companies"] = payload.nda_companies
cfg["candidate_accessibility_focus"] = payload.accessibility_focus
cfg["candidate_lgbtq_focus"] = payload.lgbtq_focus
save_user_profile(yaml_path, cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(500, f"Could not save profile: {e}")
# ── Settings: My Profile — LLM generation endpoints ─────────────────────────
def _resume_context_snippet() -> str:
"""Load a concise resume snippet for use as LLM generation context."""
try:
rp = _resume_path()
if not rp.exists():
return ""
with open(rp) as f:
resume_data = yaml.safe_load(f) or {}
parts: list[str] = []
if resume_data.get("name"):
parts.append(f"Candidate: {resume_data['name']}")
if resume_data.get("skills"):
parts.append(f"Skills: {', '.join(resume_data['skills'][:20])}")
if resume_data.get("experience"):
exp = resume_data["experience"]
if isinstance(exp, list) and exp:
titles = [e.get("title", "") for e in exp[:3] if e.get("title")]
if titles:
parts.append(f"Recent roles: {', '.join(titles)}")
return "\n".join(parts)
except Exception:
return ""
@app.post("/api/settings/profile/generate-summary")
def generate_career_summary():
"""LLM-generate a career summary from the candidate's resume profile."""
context = _resume_context_snippet()
if not context:
raise HTTPException(400, "Resume profile is empty — add experience and skills first")
prompt = (
"You are a professional resume writer.\n\n"
f"Candidate background:\n{context}\n\n"
"Write a 2–3 sentence professional career summary in first person. "
"Be specific, highlight key strengths, and avoid hollow filler phrases like "
"'results-driven' or 'passionate self-starter'."
)
try:
from scripts.llm_router import LLMRouter
summary = LLMRouter().complete(prompt)
return {"summary": summary.strip()}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
@app.post("/api/settings/profile/generate-missions")
def generate_mission_preferences():
"""LLM-generate 3 mission/industry preferences from the candidate's resume."""
context = _resume_context_snippet()
prompt = (
"You are helping a job seeker identify mission-aligned industries they would enjoy working in.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ "Suggest 3 mission-aligned industries or causes the candidate might care about "
"(e.g. animal welfare, education, accessibility, climate tech, healthcare). "
"Return a JSON array with exactly 3 objects, each with 'tag' (slug, no spaces), "
"'label' (human-readable name), and 'note' (one sentence on why it fits). "
"Only output the JSON array, no other text."
)
try:
from scripts.llm_router import LLMRouter
import json as _json
raw = LLMRouter().complete(prompt)
# Extract JSON array from the response
start = raw.find("[")
end = raw.rfind("]") + 1
if start == -1 or end == 0:
raise ValueError("LLM did not return a JSON array")
items = _json.loads(raw[start:end])
# Normalise to {industry, note} — LLM may return {tag, label, note}
missions = [
{"industry": m.get("label") or m.get("tag") or str(m), "note": m.get("note", "")}
for m in items if isinstance(m, dict)
]
return {"mission_preferences": missions}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
@app.post("/api/settings/profile/generate-voice")
def generate_candidate_voice():
"""LLM-generate a candidate voice/writing-style note from the resume profile."""
context = _resume_context_snippet()
if not context:
raise HTTPException(400, "Resume profile is empty — add experience and skills first")
prompt = (
"You are a professional writing coach helping a job seeker articulate their communication style.\n\n"
f"Candidate background:\n{context}\n\n"
"Write a 1–2 sentence note describing the candidate's professional voice and writing style "
"for use in cover letter generation. This should capture tone (e.g. direct, warm, precise), "
"values that come through in their writing, and any standout personality. "
"Write it in third person as a style directive (e.g. 'Writes in a clear, direct tone...')."
)
try:
from scripts.llm_router import LLMRouter
voice = LLMRouter().complete(prompt)
return {"voice": voice.strip()}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
# ── Settings: Resume Profile endpoints ───────────────────────────────────────
class WorkEntry(BaseModel):
title: str = ""; company: str = ""; period: str = ""; location: str = ""
industry: str = ""; responsibilities: str = ""; skills: List[str] = []
class EducationEntry(BaseModel):
institution: str = ""; degree: str = ""; field: str = ""
start_date: str = ""; end_date: str = ""
class ResumePayload(BaseModel):
name: str = ""; email: str = ""; phone: str = ""; linkedin_url: str = ""
surname: str = ""; address: str = ""; city: str = ""; zip_code: str = ""; date_of_birth: str = ""
career_summary: str = ""
experience: List[WorkEntry] = []
education: List[EducationEntry] = []
achievements: List[str] = []
salary_min: int = 0; salary_max: int = 0; notice_period: str = ""
remote: bool = False; relocation: bool = False
assessment: bool = False; background_check: bool = False
gender: str = ""; pronouns: str = ""; ethnicity: str = ""
veteran_status: str = ""; disability: str = ""
skills: List[str] = []; domains: List[str] = []; keywords: List[str] = []
def _config_dir() -> Path:
"""Resolve per-user config directory. Always co-located with user.yaml."""
return Path(_user_yaml_path()).parent
def _resume_path() -> Path:
"""Resolve plain_text_resume.yaml co-located with user.yaml (user-isolated)."""
return _config_dir() / "plain_text_resume.yaml"
def _search_prefs_path() -> Path:
return _config_dir() / "search_profiles.yaml"
def _license_path() -> Path:
return _config_dir() / "license.yaml"
def _tokens_path() -> Path:
return _config_dir() / "tokens.yaml"
def _normalize_experience(raw: list) -> list:
"""Normalize AIHawk-style experience entries to the Vue WorkEntry schema.
AIHawk stores: key_responsibilities (numbered dicts), employment_period, skills_acquired
Vue WorkEntry: responsibilities (str), period (str), skills (list)
If already in Vue format (has 'period' key or 'responsibilities' key), pass through unchanged.
"""
out = []
for e in raw:
if not isinstance(e, dict):
continue
# Already in Vue WorkEntry format — pass through
if "period" in e or "responsibilities" in e:
out.append({
"title": e.get("title", ""),
"company": e.get("company", ""),
"period": e.get("period", ""),
"location": e.get("location", ""),
"industry": e.get("industry", ""),
"responsibilities": e.get("responsibilities", ""),
"skills": e.get("skills") or [],
})
continue
# AIHawk format
resps = e.get("key_responsibilities", {})
if isinstance(resps, dict):
resp_text = "\n".join(v for v in resps.values() if isinstance(v, str))
elif isinstance(resps, list):
resp_text = "\n".join(str(r) for r in resps)
else:
resp_text = str(resps)
period = e.get("employment_period", "")
skills_raw = e.get("skills_acquired", [])
skills = skills_raw if isinstance(skills_raw, list) else []
out.append({
"title": e.get("position", ""),
"company": e.get("company", ""),
"period": period,
"location": e.get("location", ""),
"industry": e.get("industry", ""),
"responsibilities": resp_text,
"skills": skills,
})
return out
@app.get("/api/settings/resume")
def get_resume():
try:
resume_path = _resume_path()
if not resume_path.exists():
# Backward compat: check user.yaml for career_summary
_uy = Path(_user_yaml_path())
if _uy.exists():
uy = yaml.safe_load(_uy.read_text(encoding="utf-8")) or {}
if uy.get("career_summary"):
return {"exists": False, "legacy_career_summary": uy["career_summary"]}
return {"exists": False}
with open(resume_path, encoding="utf-8") as f:
data = yaml.safe_load(f) or {}
data["exists"] = True
if "experience" in data and isinstance(data["experience"], list):
data["experience"] = _normalize_experience(data["experience"])
# Backward compat: if career_summary missing from YAML, try user.yaml
if not data.get("career_summary"):
_uy = Path(_user_yaml_path())
if _uy.exists():
uy = yaml.safe_load(_uy.read_text(encoding="utf-8")) or {}
data["career_summary"] = uy.get("career_summary", "")
return data
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/resume")
def save_resume(payload: ResumePayload):
"""Save resume profile. If a default library entry exists, sync content back to it."""
import json as _json
from scripts.db import (
get_resume as _get_resume,
update_resume_content as _update_content,
)
from scripts.resume_sync import profile_to_library
try:
resume_path = _resume_path()
resume_path.parent.mkdir(parents=True, exist_ok=True)
with open(resume_path, "w", encoding="utf-8") as f:
yaml.dump(payload.model_dump(), f, allow_unicode=True, default_flow_style=False)
# Profile→library sync: if a default resume exists, update it
synced_id: int | None = None
db_path = Path(_request_db.get() or DB_PATH)
_uy = Path(_user_yaml_path())
if _uy.exists():
profile_meta = yaml.safe_load(_uy.read_text(encoding="utf-8")) or {}
default_id = profile_meta.get("default_resume_id")
if default_id:
entry = _get_resume(db_path, int(default_id))
if entry:
text, struct = profile_to_library(payload.model_dump())
_update_content(db_path, int(default_id), text=text, struct_json=_json.dumps(struct))
synced_id = int(default_id)
return {"ok": True, "synced_library_entry_id": synced_id}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/resume/blank")
def create_blank_resume():
try:
resume_path = _resume_path()
resume_path.parent.mkdir(parents=True, exist_ok=True)
if not resume_path.exists():
with open(resume_path, "w") as f:
yaml.dump({}, f)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/resume/upload")
async def upload_resume(file: UploadFile):
try:
from scripts.resume_parser import (
extract_text_from_pdf,
extract_text_from_docx,
extract_text_from_odt,
structure_resume,
)
suffix = Path(file.filename).suffix.lower()
file_bytes = await file.read()
if suffix == ".pdf":
raw_text = extract_text_from_pdf(file_bytes)
elif suffix == ".odt":
raw_text = extract_text_from_odt(file_bytes)
else:
raw_text = extract_text_from_docx(file_bytes)
result, err = structure_resume(raw_text)
if err and not result:
return {"ok": False, "error": err}
# Persist parsed data so store.load() reads the updated file
resume_path = _resume_path()
resume_path.parent.mkdir(parents=True, exist_ok=True)
with open(resume_path, "w") as f:
yaml.dump(result, f, allow_unicode=True, default_flow_style=False)
result["exists"] = True
return {"ok": True, "data": result}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: Search Preferences endpoints ────────────────────────────────────
class SearchPrefsPayload(BaseModel):
remote_preference: str = "both"
job_titles: List[str] = []
locations: List[str] = []
exclude_keywords: List[str] = []
job_boards: List[dict] = []
custom_board_urls: List[str] = []
blocklist_companies: List[str] = []
blocklist_industries: List[str] = []
blocklist_locations: List[str] = []
def _get_valid_jobspy_boards() -> set[str]:
"""Return the set of board names supported by the installed JobSpy version."""
try:
from jobspy import Site
return {s.value for s in Site}
except Exception:
return {"linkedin", "indeed", "zip_recruiter", "glassdoor", "google"}
@app.get("/api/settings/search")
def get_search_prefs():
try:
p = _search_prefs_path()
if not p.exists():
return {}
with open(p) as f:
data = yaml.safe_load(f) or {}
# Handle both old `default: {...}` format and new `profiles: [...]` format.
from scripts.discover import _normalize_profiles
normalized = _normalize_profiles(data)
profiles = normalized.get("profiles", [])
profile = next((pr for pr in profiles if pr.get("name") == "default"), None)
if profile is None:
# Fall back to reading the raw default key (covers edge cases)
profile = data.get("default", {})
# Annotate job_boards with a `supported` flag so the UI can distinguish
# boards that produce real results from ones that are not yet implemented.
valid = _get_valid_jobspy_boards()
job_boards = profile.get("job_boards", [])
if job_boards:
profile["job_boards"] = [
{**b, "supported": b.get("name", "") in valid}
for b in job_boards
]
# Also expose boards list (canonical format) with the same annotation
boards = profile.get("boards", [])
if boards and not job_boards:
profile["job_boards"] = [
{"name": b, "enabled": True, "supported": b in valid}
for b in boards
]
return profile
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/search")
def save_search_prefs(payload: SearchPrefsPayload):
try:
p = _search_prefs_path()
data = {}
if p.exists():
with open(p) as f:
data = yaml.safe_load(f) or {}
data["default"] = payload.model_dump()
p.parent.mkdir(parents=True, exist_ok=True)
with open(p, "w") as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
class SearchSuggestPayload(BaseModel):
type: str # "titles" | "locations" | "exclude_keywords"
current: List[str] = []
class ResumeTagSuggestPayload(BaseModel):
type: str # "skills" | "domains" | "keywords"
current: List[str] = []
@app.post("/api/settings/resume/suggest-tags")
def suggest_resume_tags(payload: ResumeTagSuggestPayload):
"""LLM-generate suggestions for skills, domains, or keywords based on the resume profile."""
context = _resume_context_snippet()
current_str = ", ".join(payload.current) if payload.current else "none"
if payload.type == "skills":
prompt = (
"You are a career advisor helping a job seeker build their skills list.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Skills they already have listed: {current_str}\n\n"
"Suggest 8 additional skills, tools, or technologies they likely have based on their "
"background but haven't listed yet. Focus on concrete, ATS-friendly terms. "
"Return only a JSON array of strings, no other text. "
"Example: [\"HubSpot\", \"Tableau\", \"SQL\"]"
)
elif payload.type == "domains":
prompt = (
"You are a career advisor helping a job seeker define the industry domains they work in.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Domains they already have listed: {current_str}\n\n"
"Suggest 6 additional industry domains, verticals, or market segments relevant to their "
"background that they haven't listed. Think: 'B2B SaaS', 'enterprise software', "
"'financial services', etc. "
"Return only a JSON array of strings, no other text."
)
elif payload.type == "keywords":
prompt = (
"You are a resume ATS (applicant tracking system) specialist helping a job seeker "
"identify important keywords recruiters search for.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Keywords they already have listed: {current_str}\n\n"
"Suggest 10 additional ATS keywords, phrases, or buzzwords that recruiters in their "
"field commonly search for — metrics, methodologies, frameworks, or role-specific "
"terminology they may have missed. "
"Return only a JSON array of strings, no other text."
)
else:
raise HTTPException(400, f"Unknown suggestion type: {payload.type}")
try:
import json as _json
from scripts.llm_router import LLMRouter
raw = LLMRouter().complete(prompt)
start = raw.find("[")
end = raw.rfind("]") + 1
if start == -1 or end == 0:
return {"suggestions": []}
suggestions = _json.loads(raw[start:end])
return {"suggestions": [str(s) for s in suggestions if s]}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
@app.post("/api/settings/search/suggest")
def suggest_search(payload: SearchSuggestPayload):
"""LLM-generate suggestions for job titles, locations, or exclude keywords."""
context = _resume_context_snippet()
current_str = ", ".join(payload.current) if payload.current else "none"
if payload.type == "titles":
prompt = (
"You are a career advisor helping a job seeker identify relevant job titles.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Current job titles they're searching for: {current_str}\n\n"
"Suggest 5 additional relevant job titles they may have missed. "
"Return only a JSON array of strings, no other text. "
"Example: [\"Senior Software Engineer\", \"Staff Engineer\"]"
)
elif payload.type == "locations":
prompt = (
"You are a career advisor helping a job seeker identify relevant job markets.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Current locations they're searching in: {current_str}\n\n"
"Suggest 5 relevant locations or remote options they may have missed. "
"Include 'Remote' if not already listed. "
"Return only a JSON array of strings, no other text."
)
elif payload.type == "exclude_keywords":
prompt = (
"You are a job search assistant helping a job seeker filter out irrelevant listings.\n\n"
+ (f"Candidate background:\n{context}\n\n" if context else "")
+ f"Keywords they already exclude: {current_str}\n\n"
"Suggest 5–8 keywords or phrases they should add to their exclude list to avoid "
"irrelevant postings (e.g. management roles they don't want, clearance requirements, "
"technologies they don't work with). "
"Return only a JSON array of strings, no other text."
)
else:
raise HTTPException(400, f"Unknown suggestion type: {payload.type}")
try:
import json as _json
from scripts.llm_router import LLMRouter
raw = LLMRouter().complete(prompt)
start = raw.find("[")
end = raw.rfind("]") + 1
if start == -1 or end == 0:
return {"suggestions": []}
suggestions = _json.loads(raw[start:end])
return {"suggestions": [str(s) for s in suggestions if s]}
except Exception as e:
raise HTTPException(500, f"LLM generation failed: {e}")
# ── Settings: System — LLM Backends + BYOK endpoints ─────────────────────────
class ByokAckPayload(BaseModel):
backends: List[str] = []
class LlmConfigPayload(BaseModel):
backends: List[dict] = []
LLM_CONFIG_PATH = Path("config/llm.yaml")
@app.get("/api/settings/system/llm")
def get_llm_config():
try:
user = load_user_profile(_user_yaml_path())
backends = []
if LLM_CONFIG_PATH.exists():
with open(LLM_CONFIG_PATH) as f:
data = yaml.safe_load(f) or {}
backends = data.get("backends", [])
return {"backends": backends, "byok_acknowledged": user.get("byok_acknowledged_backends", [])}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/system/llm")
def save_llm_config(payload: LlmConfigPayload):
try:
data = {}
if LLM_CONFIG_PATH.exists():
with open(LLM_CONFIG_PATH) as f:
data = yaml.safe_load(f) or {}
data["backends"] = payload.backends
LLM_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
with open(LLM_CONFIG_PATH, "w") as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/llm/byok-ack")
def byok_ack(payload: ByokAckPayload):
try:
user = load_user_profile(_user_yaml_path())
existing = user.get("byok_acknowledged_backends", [])
user["byok_acknowledged_backends"] = list(set(existing + payload.backends))
save_user_profile(_user_yaml_path(), user)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: per-user cover-letter model ────────────────────────────────────
@app.get("/api/settings/llm/cover-letter-model")
def get_cover_letter_model():
"""Return the user's custom cover letter model (from per-user llm.yaml if set)."""
cfg_path = _config_dir() / "llm.yaml"
if cfg_path.exists():
with open(cfg_path) as f:
data = yaml.safe_load(f) or {}
# Convention: the first backend in fallback_order that targets cover letters
# is stored under backends.cover_letter.model
model = (data.get("backends", {}).get("cover_letter") or {}).get("model", "")
return {"model": model}
return {"model": ""}
class CoverLetterModelPayload(BaseModel):
model: str
@app.put("/api/settings/llm/cover-letter-model")
def set_cover_letter_model(payload: CoverLetterModelPayload):
"""Write the custom cover letter model into the per-user llm.yaml."""
cfg_path = _config_dir() / "llm.yaml"
cfg_path.parent.mkdir(parents=True, exist_ok=True)
data: dict = {}
if cfg_path.exists():
with open(cfg_path) as f:
data = yaml.safe_load(f) or {}
backends = data.setdefault("backends", {})
if payload.model:
backends["cover_letter"] = {
"type": "openai_compat",
"enabled": True,
"base_url": "http://localhost:11434/v1",
"model": payload.model,
"api_key": "any",
"supports_images": False,
}
order = data.setdefault("fallback_order", [])
if "cover_letter" not in order:
order.insert(0, "cover_letter")
else:
# Clear custom model — remove the backend and drop from fallback order
backends.pop("cover_letter", None)
data["fallback_order"] = [b for b in data.get("fallback_order", []) if b != "cover_letter"]
with open(cfg_path, "w") as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
return {"ok": True}
@app.get("/api/settings/llm/ollama-models")
def get_ollama_models():
"""Return available Ollama models by querying the local Ollama API."""
try:
ollama_host = os.environ.get("OLLAMA_HOST", "http://localhost:11434")
if not ollama_host.startswith("http"):
ollama_host = f"http://{ollama_host}"
resp = requests.get(f"{ollama_host.rstrip('/')}/api/tags", timeout=3)
if resp.status_code == 200:
models = [m["name"] for m in resp.json().get("models", [])]
return {"models": models}
except Exception:
pass
return {"models": []}
# ── Settings: System — Services ───────────────────────────────────────────────
SERVICES_REGISTRY = [
{"name": "ollama", "port": 11434, "compose_service": "ollama", "note": "LLM inference", "profiles": ["cpu","single-gpu","dual-gpu"]},
{"name": "vllm", "port": 8000, "compose_service": "vllm", "note": "vLLM server", "profiles": ["single-gpu","dual-gpu"]},
{"name": "vision", "port": 8002, "compose_service": "vision", "note": "Moondream2 vision", "profiles": ["single-gpu","dual-gpu"]},
{"name": "searxng", "port": 8888, "compose_service": "searxng", "note": "Search engine", "profiles": ["cpu","remote","single-gpu","dual-gpu"]},
]
def _port_open(port: int) -> bool:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(0.5)
return s.connect_ex(("127.0.0.1", port)) == 0
@app.get("/api/settings/system/services")
def get_services():
try:
profile = os.environ.get("INFERENCE_PROFILE", "cpu")
result = []
for svc in SERVICES_REGISTRY:
if profile not in svc["profiles"]:
continue
result.append({"name": svc["name"], "port": svc["port"],
"running": _port_open(svc["port"]), "note": svc["note"]})
return result
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/services/{name}/start")
def start_service(name: str):
try:
svc = next((s for s in SERVICES_REGISTRY if s["name"] == name), None)
if not svc:
raise HTTPException(404, "Unknown service")
r = subprocess.run(["docker", "compose", "up", "-d", svc["compose_service"]],
capture_output=True, text=True)
return {"ok": r.returncode == 0, "output": r.stdout + r.stderr}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/services/{name}/stop")
def stop_service(name: str):
try:
svc = next((s for s in SERVICES_REGISTRY if s["name"] == name), None)
if not svc:
raise HTTPException(404, "Unknown service")
r = subprocess.run(["docker", "compose", "stop", svc["compose_service"]],
capture_output=True, text=True)
return {"ok": r.returncode == 0, "output": r.stdout + r.stderr}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: System — Email ──────────────────────────────────────────────────
# EMAIL_PATH is resolved per-request via _config_dir()
EMAIL_CRED_SERVICE = "peregrine"
EMAIL_CRED_KEY = "imap_password"
# Non-secret fields stored in yaml
EMAIL_YAML_FIELDS = ("host", "port", "ssl", "username", "sent_folder", "lookback_days")
@app.get("/api/settings/system/email")
def get_email_config():
try:
config = {}
ep = _config_dir() / "email.yaml"
if ep.exists():
with open(ep) as f:
config = yaml.safe_load(f) or {}
# Never return the password — only indicate whether it's set
password = get_credential(EMAIL_CRED_SERVICE, EMAIL_CRED_KEY)
config["password_set"] = bool(password)
config.pop("password", None) # strip if somehow in yaml
return config
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/system/email")
def save_email_config(payload: dict):
try:
ep = _config_dir() / "email.yaml"
ep.parent.mkdir(parents=True, exist_ok=True)
# Extract password before writing yaml; discard the sentinel boolean regardless
password = payload.pop("password", None)
payload.pop("password_set", None) # always discard — boolean sentinel, not a secret
if password and isinstance(password, str):
set_credential(EMAIL_CRED_SERVICE, EMAIL_CRED_KEY, password)
# Write non-secret fields to yaml (chmod 600 still, contains username)
safe_config = {k: v for k, v in payload.items() if k in EMAIL_YAML_FIELDS}
fd = os.open(str(ep), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as f:
yaml.dump(safe_config, f, allow_unicode=True, default_flow_style=False)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/email/test")
def test_email(payload: dict):
try:
# Always use the stored credential — never accept a password in the test request body
password = get_credential(EMAIL_CRED_SERVICE, EMAIL_CRED_KEY)
host = payload.get("host", "")
port = int(payload.get("port", 993))
use_ssl = payload.get("ssl", True)
username = payload.get("username", "")
if not all([host, username, password]):
return {"ok": False, "error": "Missing host, username, or password"}
if use_ssl:
ctx = ssl_mod.create_default_context()
conn = imaplib.IMAP4_SSL(host, port, ssl_context=ctx)
else:
conn = imaplib.IMAP4(host, port)
conn.login(username, password)
conn.logout()
return {"ok": True}
except Exception as e:
return {"ok": False, "error": str(e)}
# ── Settings: System — Integrations ──────────────────────────────────────────
@app.get("/api/settings/system/integrations")
def get_integrations():
try:
from scripts.integrations import REGISTRY
result = []
for integration in REGISTRY:
result.append({
"id": integration.id,
"name": integration.name,
"connected": integration.is_connected(),
"tier_required": getattr(integration, "tier_required", "free"),
"fields": [{"key": f["key"], "label": f["label"], "type": f.get("type", "text")}
for f in integration.fields()],
})
return result
except ImportError:
return [] # integrations module not yet implemented
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/integrations/{integration_id}/test")
def test_integration(integration_id: str, payload: dict):
try:
from scripts.integrations import REGISTRY
integration = next((i for i in REGISTRY if i.id == integration_id), None)
if not integration:
raise HTTPException(404, "Unknown integration")
ok, error = integration.test(payload)
return {"ok": ok, "error": error}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/integrations/{integration_id}/connect")
def connect_integration(integration_id: str, payload: dict):
try:
from scripts.integrations import REGISTRY
integration = next((i for i in REGISTRY if i.id == integration_id), None)
if not integration:
raise HTTPException(404, "Unknown integration")
ok, error = integration.test(payload)
if not ok:
return {"ok": False, "error": error}
integration.save_credentials(payload)
return {"ok": True}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/system/integrations/{integration_id}/disconnect")
def disconnect_integration(integration_id: str):
try:
from scripts.integrations import REGISTRY
integration = next((i for i in REGISTRY if i.id == integration_id), None)
if not integration:
raise HTTPException(404, "Unknown integration")
integration.remove_credentials()
return {"ok": True}
except HTTPException:
raise
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: System — File Paths ─────────────────────────────────────────────
@app.get("/api/settings/system/paths")
def get_file_paths():
try:
user = load_user_profile(_user_yaml_path())
return {
"docs_dir": user.get("docs_dir", ""),
"data_dir": user.get("data_dir", ""),
"model_dir": user.get("model_dir", ""),
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/system/paths")
def save_file_paths(payload: dict):
try:
user = load_user_profile(_user_yaml_path())
for key in ("docs_dir", "data_dir", "model_dir"):
if key in payload:
user[key] = payload[key]
save_user_profile(_user_yaml_path(), user)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: System — Deployment Config ─────────────────────────────────────
@app.get("/api/settings/system/deploy")
def get_deploy_config():
try:
return {
"base_url_path": os.environ.get("STREAMLIT_SERVER_BASE_URL_PATH", ""),
"server_host": os.environ.get("STREAMLIT_SERVER_ADDRESS", "0.0.0.0"),
"server_port": int(os.environ.get("STREAMLIT_SERVER_PORT", "8502")),
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/system/deploy")
def save_deploy_config(payload: dict):
# Deployment config changes require restart; just acknowledge
return {"ok": True, "note": "Restart required to apply changes"}
# ── Settings: Fine-Tune ───────────────────────────────────────────────────────
_TRAINING_JSONL = Path("/Library/Documents/JobSearch/training_data/cover_letters.jsonl")
def _load_training_pairs() -> list[dict]:
"""Load training pairs from the JSONL file. Returns empty list if missing."""
if not _TRAINING_JSONL.exists():
return []
pairs = []
with open(_TRAINING_JSONL, encoding="utf-8") as f:
for line in f:
line = line.strip()
if line:
try:
pairs.append(json.loads(line))
except json.JSONDecodeError:
pass
return pairs
def _save_training_pairs(pairs: list[dict]) -> None:
_TRAINING_JSONL.parent.mkdir(parents=True, exist_ok=True)
with open(_TRAINING_JSONL, "w", encoding="utf-8") as f:
for p in pairs:
f.write(json.dumps(p, ensure_ascii=False) + "\n")
@app.get("/api/settings/fine-tune/status")
def finetune_status():
try:
pairs_count = len(_load_training_pairs())
from scripts.task_runner import get_task_status
task = get_task_status("finetune_extract")
if task:
# Prefer the DB task count if available and larger (recent extraction)
db_count = task.get("result_count", 0) or 0
pairs_count = max(pairs_count, db_count)
status = task.get("status", "idle") if task else "idle"
# Stub quota for self-hosted; cloud overrides via its own middleware
return {"status": status, "pairs_count": pairs_count, "quota_remaining": None}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/settings/fine-tune/pairs")
def list_training_pairs():
"""Return training pairs with index for display and removal."""
pairs = _load_training_pairs()
return {
"pairs": [
{"index": i, "instruction": p.get("instruction", ""), "source_file": p.get("source_file", "")}
for i, p in enumerate(pairs)
],
"total": len(pairs),
}
@app.delete("/api/settings/fine-tune/pairs/{index}")
def delete_training_pair(index: int):
"""Remove a training pair by index."""
pairs = _load_training_pairs()
if index < 0 or index >= len(pairs):
raise HTTPException(404, "Pair index out of range")
pairs.pop(index)
_save_training_pairs(pairs)
return {"ok": True, "remaining": len(pairs)}
@app.post("/api/settings/fine-tune/extract")
def finetune_extract():
try:
from scripts.task_runner import submit_task
task_id = submit_task(DB_PATH, "finetune_extract", None)
return {"task_id": str(task_id)}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/fine-tune/upload")
async def finetune_upload(files: list[UploadFile]):
try:
upload_dir = Path("data/finetune_uploads")
upload_dir.mkdir(parents=True, exist_ok=True)
saved = []
for f in files:
dest = upload_dir / (f.filename or "upload.bin")
content = await f.read()
fd = os.open(str(dest), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "wb") as out:
out.write(content)
saved.append(str(dest))
return {"file_count": len(saved), "paths": saved}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/fine-tune/submit")
def finetune_submit():
"""Trigger prepare_training_data extraction and queue fine-tune background task."""
try:
from scripts.task_runner import submit_task
task_id, is_new = submit_task(Path(DB_PATH), "prepare_training", None)
return {"job_id": str(task_id), "is_new": is_new}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/settings/fine-tune/local-status")
def finetune_local_status():
try:
import subprocess
result = subprocess.run(
["ollama", "list"], capture_output=True, text=True, timeout=5
)
model_ready = "alex-cover-writer" in (result.stdout or "")
return {"model_ready": model_ready}
except Exception:
return {"model_ready": False}
# ── Settings: License ─────────────────────────────────────────────────────────
# _config_dir() / _license_path() / _tokens_path() are per-request (see helpers above)
def _load_user_config() -> dict:
"""Load user.yaml using the same path logic as _user_yaml_path()."""
return load_user_profile(_user_yaml_path())
def _save_user_config(cfg: dict) -> None:
"""Save user.yaml using the same path logic as _user_yaml_path()."""
save_user_profile(_user_yaml_path(), cfg)
@app.get("/api/settings/license")
def get_license():
try:
lp = _license_path()
if lp.exists():
with open(lp) as f:
data = yaml.safe_load(f) or {}
else:
data = {}
return {
"tier": data.get("tier", "free"),
"key": data.get("key"),
"active": bool(data.get("active", False)),
"grace_period_ends": data.get("grace_period_ends"),
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
class LicenseActivatePayload(BaseModel):
key: str
@app.post("/api/settings/license/activate")
def activate_license(payload: LicenseActivatePayload):
try:
# In dev: accept any key matching our format, grant paid tier
key = payload.key.strip()
if not re.match(r'^CFG-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$', key):
return {"ok": False, "error": "Invalid key format"}
lp = _license_path()
data = {"tier": "paid", "key": key, "active": True}
lp.parent.mkdir(parents=True, exist_ok=True)
fd = os.open(str(lp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
return {"ok": True, "tier": "paid"}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/license/deactivate")
def deactivate_license():
try:
lp = _license_path()
if lp.exists():
with open(lp) as f:
data = yaml.safe_load(f) or {}
data["active"] = False
fd = os.open(str(lp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: Data ────────────────────────────────────────────────────────────
class BackupCreatePayload(BaseModel):
include_db: bool = False
@app.post("/api/settings/data/backup/create")
def create_backup(payload: BackupCreatePayload):
try:
import zipfile
import datetime
cfg_dir = _config_dir()
backup_dir = cfg_dir.parent / "backups"
backup_dir.mkdir(parents=True, exist_ok=True)
ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
dest = backup_dir / f"peregrine_backup_{ts}.zip"
file_count = 0
with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zf:
for cfg_file in cfg_dir.glob("*.yaml"):
if cfg_file.name not in ("tokens.yaml",):
zf.write(cfg_file, f"config/{cfg_file.name}")
file_count += 1
if payload.include_db:
db_path = Path(_request_db.get() or DB_PATH)
if db_path.exists():
zf.write(db_path, "data/staging.db")
file_count += 1
size_bytes = dest.stat().st_size
return {"path": str(dest), "file_count": file_count, "size_bytes": size_bytes}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: Privacy ─────────────────────────────────────────────────────────
PRIVACY_YAML_FIELDS = {"telemetry_opt_in", "byok_info_dismissed", "master_off", "usage_events", "content_sharing"}
@app.get("/api/settings/privacy")
def get_privacy():
try:
cfg = _load_user_config()
return {
"telemetry_opt_in": bool(cfg.get("telemetry_opt_in", False)),
"byok_info_dismissed": bool(cfg.get("byok_info_dismissed", False)),
"master_off": bool(cfg.get("master_off", False)),
"usage_events": cfg.get("usage_events", True),
"content_sharing": bool(cfg.get("content_sharing", False)),
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.put("/api/settings/privacy")
def save_privacy(payload: dict):
try:
cfg = _load_user_config()
for k, v in payload.items():
if k in PRIVACY_YAML_FIELDS:
cfg[k] = v
_save_user_config(cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Settings: Developer ───────────────────────────────────────────────────────
@app.get("/api/settings/developer")
def get_developer():
try:
cfg = _load_user_config()
tokens = {}
tp = _tokens_path()
if tp.exists():
with open(tp) as f:
tokens = yaml.safe_load(f) or {}
return {
"dev_tier_override": cfg.get("dev_tier_override"),
"hf_token_set": bool(tokens.get("huggingface_token")),
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
class DevTierPayload(BaseModel):
tier: Optional[str]
@app.put("/api/settings/developer/tier")
def set_dev_tier(payload: DevTierPayload):
try:
cfg = _load_user_config()
cfg["dev_tier_override"] = payload.tier
_save_user_config(cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
class HfTokenPayload(BaseModel):
token: str
@app.put("/api/settings/developer/hf-token")
def save_hf_token(payload: HfTokenPayload):
try:
set_credential("peregrine_tokens", "huggingface_token", payload.token)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/developer/hf-token/test")
def test_hf_token():
try:
token = get_credential("peregrine_tokens", "huggingface_token")
if not token:
return {"ok": False, "error": "No token stored"}
from huggingface_hub import whoami
info = whoami(token=token)
return {"ok": True, "username": info.get("name")}
except Exception as e:
return {"ok": False, "error": str(e)}
@app.post("/api/settings/developer/wizard-reset")
def wizard_reset():
try:
cfg = _load_user_config()
cfg["wizard_complete"] = False
_save_user_config(cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/settings/developer/export-classifier")
def export_classifier():
try:
import json as _json
from scripts.db import get_labeled_emails
emails = get_labeled_emails(DB_PATH)
export_path = Path("data/email_score.jsonl")
export_path.parent.mkdir(parents=True, exist_ok=True)
with open(export_path, "w") as f:
for e in emails:
f.write(_json.dumps(e) + "\n")
return {"ok": True, "count": len(emails), "path": str(export_path)}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
# ── Wizard API ────────────────────────────────────────────────────────────────
#
# These endpoints back the Vue SPA first-run onboarding wizard.
# State is persisted to user.yaml on every step so the wizard can resume
# after a browser refresh or crash (mirrors the Streamlit wizard behaviour).
_WIZARD_PROFILES = ("remote", "cpu", "single-gpu", "dual-gpu", "cf-orch")
_WIZARD_TIERS = ("free", "paid", "premium")
def _wizard_yaml_path() -> str:
"""Same resolution logic as _user_yaml_path() — single source of truth."""
return _user_yaml_path()
def _load_wizard_yaml() -> dict:
try:
return load_user_profile(_wizard_yaml_path()) or {}
except Exception:
return {}
def _save_wizard_yaml(updates: dict) -> None:
path = _wizard_yaml_path()
existing = _load_wizard_yaml()
existing.update(updates)
save_user_profile(path, existing)
def _detect_gpus() -> list[str]:
"""Detect GPUs. Prefers PEREGRINE_GPU_NAMES env var (set by preflight)."""
env_names = os.environ.get("PEREGRINE_GPU_NAMES", "").strip()
if env_names:
return [n.strip() for n in env_names.split(",") if n.strip()]
try:
out = subprocess.check_output(
["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
text=True, timeout=5,
)
return [line.strip() for line in out.strip().splitlines() if line.strip()]
except Exception:
return []
def _suggest_profile(gpus: list[str]) -> str:
recommended = os.environ.get("RECOMMENDED_PROFILE", "").strip()
if recommended and recommended in _WIZARD_PROFILES:
return recommended
if len(gpus) >= 2:
return "dual-gpu"
if len(gpus) == 1:
return "single-gpu"
return "remote"
@app.get("/api/wizard/status")
def wizard_status():
"""Return current wizard state for resume-after-refresh.
wizard_complete=True means the wizard has been finished and the app
should not redirect to /setup. wizard_step is the last completed step
(0 = not started); the SPA advances to step+1 on load.
"""
cfg = _load_wizard_yaml()
return {
"wizard_complete": bool(cfg.get("wizard_complete", False)),
"wizard_step": int(cfg.get("wizard_step", 0)),
"saved_data": {
"inference_profile": cfg.get("inference_profile", ""),
"tier": cfg.get("tier", "free"),
"name": cfg.get("name", ""),
"email": cfg.get("email", ""),
"phone": cfg.get("phone", ""),
"linkedin": cfg.get("linkedin", ""),
"career_summary": cfg.get("career_summary", ""),
"services": cfg.get("services", {}),
},
}
class WizardStepPayload(BaseModel):
step: int
data: dict = {}
@app.post("/api/wizard/step")
def wizard_save_step(payload: WizardStepPayload):
"""Persist a single wizard step and advance the step counter.
Side effects by step number:
- Step 3 (Resume): writes config/plain_text_resume.yaml
- Step 5 (Inference): writes API keys into .env
- Step 6 (Search): writes config/search_profiles.yaml
"""
step = payload.step
data = payload.data
if step < 1 or step > 7:
raise HTTPException(status_code=400, detail="step must be 1–7")
updates: dict = {"wizard_step": step}
# ── Step-specific field extraction ────────────────────────────────────────
if step == 1:
profile = data.get("inference_profile", "remote")
if profile not in _WIZARD_PROFILES:
raise HTTPException(status_code=400, detail=f"Unknown profile: {profile}")
updates["inference_profile"] = profile
elif step == 2:
tier = data.get("tier", "free")
if tier not in _WIZARD_TIERS:
raise HTTPException(status_code=400, detail=f"Unknown tier: {tier}")
updates["tier"] = tier
elif step == 3:
# Resume data: persist to plain_text_resume.yaml
resume = data.get("resume", {})
if resume:
resume_path = Path(_wizard_yaml_path()).parent / "plain_text_resume.yaml"
resume_path.parent.mkdir(parents=True, exist_ok=True)
with open(resume_path, "w") as f:
yaml.dump(resume, f, allow_unicode=True, default_flow_style=False)
elif step == 4:
for field in ("name", "email", "phone", "linkedin", "career_summary"):
if field in data:
updates[field] = data[field]
elif step == 5:
# Write API keys to .env (never store in user.yaml)
env_path = Path(_wizard_yaml_path()).parent.parent / ".env"
env_lines = env_path.read_text().splitlines() if env_path.exists() else []
def _set_env_key(lines: list[str], key: str, val: str) -> list[str]:
for i, line in enumerate(lines):
if line.startswith(f"{key}="):
lines[i] = f"{key}={val}"
return lines
lines.append(f"{key}={val}")
return lines
if data.get("anthropic_key"):
env_lines = _set_env_key(env_lines, "ANTHROPIC_API_KEY", data["anthropic_key"])
if data.get("openai_url"):
env_lines = _set_env_key(env_lines, "OPENAI_COMPAT_URL", data["openai_url"])
if data.get("openai_key"):
env_lines = _set_env_key(env_lines, "OPENAI_COMPAT_KEY", data["openai_key"])
if any(data.get(k) for k in ("anthropic_key", "openai_url", "openai_key")):
env_path.parent.mkdir(parents=True, exist_ok=True)
env_path.write_text("\n".join(env_lines) + "\n")
if "services" in data:
updates["services"] = data["services"]
elif step == 6:
# Persist search preferences to search_profiles.yaml in canonical format:
# profiles: [{name, titles, locations, boards, ...}]
titles = data.get("titles", [])
locations = data.get("locations", [])
search_path = _search_prefs_path()
existing_search: dict = {}
if search_path.exists():
with open(search_path) as f:
existing_search = yaml.safe_load(f) or {}
# Normalize legacy wizard format on read so we can update in place
from scripts.discover import _normalize_profiles as _norm
existing_search = _norm(existing_search)
# Find or create the "default" profile entry
profiles_list = existing_search.get("profiles", [])
default_profile = next((p for p in profiles_list if p.get("name") == "default"), None)
if default_profile is None:
default_profile = {"name": "default"}
profiles_list.append(default_profile)
default_profile["titles"] = titles
default_profile["locations"] = locations
existing_search["profiles"] = profiles_list
search_path.parent.mkdir(parents=True, exist_ok=True)
with open(search_path, "w") as f:
yaml.dump(existing_search, f, allow_unicode=True, default_flow_style=False)
# Step 7 (integrations) has no extra side effects here — connections are
# handled by the existing /api/settings/system/integrations/{id}/connect.
try:
_save_wizard_yaml(updates)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
return {"ok": True, "step": step}
def _fetch_cforch_nodes() -> list[dict]:
"""Query cf-orch coordinator for live node + GPU data. Returns [] on any error."""
url = os.environ.get("CF_ORCH_URL", "").rstrip("/")
if not url:
return []
try:
import urllib.request, json as _json
req = urllib.request.Request(f"{url}/api/nodes", headers={"Accept": "application/json"})
with urllib.request.urlopen(req, timeout=3) as resp:
data = _json.loads(resp.read())
return data.get("nodes", [])
except Exception:
return []
@app.get("/api/wizard/hardware")
def wizard_hardware():
"""Detect local GPUs, suggest an inference profile, and report cf-orch nodes."""
gpus = _detect_gpus()
suggested = _suggest_profile(gpus)
# Enrich with cf-orch cluster data when coordinator URL is configured
orch_nodes = _fetch_cforch_nodes()
orch_summary = []
for node in orch_nodes:
for gpu in node.get("gpus", []):
orch_summary.append({
"node": node["node_id"],
"name": gpu["name"],
"vram_total_mb": gpu["vram_total_mb"],
"vram_free_mb": gpu["vram_free_mb"],
})
return {
"gpus": gpus,
"suggested_profile": suggested,
"profiles": list(_WIZARD_PROFILES),
"cf_orch_available": len(orch_nodes) > 0,
"cf_orch_gpus": orch_summary,
}
class WizardInferenceTestPayload(BaseModel):
profile: str = "remote"
anthropic_key: str = ""
openai_url: str = ""
openai_key: str = ""
ollama_host: str = "localhost"
ollama_port: int = 11434
@app.post("/api/wizard/inference/test")
def wizard_test_inference(payload: WizardInferenceTestPayload):
"""Test LLM or Ollama connectivity.
Always returns {ok, message} — a connection failure is reported as a
soft warning (message), not an HTTP error, so the wizard can let the
user continue past a temporarily-down Ollama instance.
"""
if payload.profile == "remote":
try:
# Temporarily inject key if provided (don't persist yet)
env_override = {}
if payload.anthropic_key:
env_override["ANTHROPIC_API_KEY"] = payload.anthropic_key
if payload.openai_url:
env_override["OPENAI_COMPAT_URL"] = payload.openai_url
if payload.openai_key:
env_override["OPENAI_COMPAT_KEY"] = payload.openai_key
old_env = {k: os.environ.get(k) for k in env_override}
os.environ.update(env_override)
try:
from scripts.llm_router import LLMRouter
result = LLMRouter().complete("Reply with only the word: OK")
ok = bool(result and result.strip())
message = "LLM responding." if ok else "LLM returned an empty response."
finally:
for k, v in old_env.items():
if v is None:
os.environ.pop(k, None)
else:
os.environ[k] = v
except Exception as exc:
return {"ok": False, "message": f"LLM test failed: {exc}"}
else:
# Local profile — ping Ollama
ollama_url = f"http://{payload.ollama_host}:{payload.ollama_port}"
try:
resp = requests.get(f"{ollama_url}/api/tags", timeout=5)
ok = resp.status_code == 200
message = "Ollama is running." if ok else f"Ollama returned HTTP {resp.status_code}."
except Exception:
# Soft-fail: user can skip and configure later
return {
"ok": False,
"message": (
"Ollama not responding — you can continue and configure it later "
"in Settings → System."
),
}
return {"ok": ok, "message": message}
@app.post("/api/wizard/complete")
def wizard_complete():
"""Finalise the wizard: set wizard_complete=true, apply service URLs."""
try:
from scripts.user_profile import UserProfile
from scripts.generate_llm_config import apply_service_urls
yaml_path = _wizard_yaml_path()
llm_yaml = Path(yaml_path).parent / "llm.yaml"
try:
profile_obj = UserProfile(yaml_path)
if llm_yaml.exists():
apply_service_urls(profile_obj, llm_yaml)
except Exception:
pass # don't block completion on llm.yaml errors
cfg = _load_wizard_yaml()
cfg["wizard_complete"] = True
cfg.pop("wizard_step", None)
save_user_profile(yaml_path, cfg)
return {"ok": True}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))