@sindhujaks/career-mcp 1.0.0 → 1.1.0

package/.env.example

@@ -9,6 +9,13 @@
 # Defaults to ~/.career-mcp
 CAREER_MCP_DATA_DIR=
 
+# ─── Optional — PDF export (both the MCP server and the CLI) ──────────────────
+# Default theme and page size; each export can still override them.
+# CAREER_MCP_PDF_THEME=navy        # navy | minimal | classic
+# CAREER_MCP_PAGE_SIZE=letter      # letter | a4
+# Only needed if your Chrome/Edge/Chromium/Brave isn't in a standard location.
+# CAREER_MCP_CHROME_PATH=
+
 # ─── Required for the standalone CLI only ─────────────────────────────────────
 # Bring your own key — career-mcp never calls a shared/hosted key, so there's
 # no cost or liability on anyone but you.

package/README.md

@@ -1,6 +1,6 @@
 # career-mcp
 
-An MCP server for the job-search loop: store a resume, drop in a job description, get a real match analysis, a tailored resume, a cover letter, a LinkedIn About section — plus a structured interview that captures your career stories so they're ready to reuse.
+An MCP server for the job-search loop: store a resume, drop in a job description, get a real match analysis, a tailored resume and cover letter (exported to PDF), a LinkedIn About section — plus a structured interview that captures your career stories so they're ready to reuse.
 
 Local-first. Your resume and stories live in a folder on your machine (`~/.career-mcp` by default) — nothing is uploaded anywhere.
 
@@ -42,9 +42,38 @@ Then, in conversation: save your resume, save a JD, and ask your client to run a
 | `get_active_application` | Bundles resume + JD + voice profile + relevant stories as context |
 | `list_applications` | List all stored applications |
 | `save_output` | Persist a generated match analysis / resume / cover letter / About section |
+| `export_pdf` | Render a tailored resume, cover letter, or base resume to PDF (themes: `navy`, `minimal`, `classic`; page size: `letter` or `a4`) |
 | `save_story` / `query_stories` | Save/retrieve career stories, filterable by tag |
 | `start_story_interview` / `answer_story_question` | Guided, protocol-driven interview to capture one new story |
 
+## PDF export
+
+`export_pdf` turns a saved markdown resume or cover letter into a PDF that ATS systems can read (real, selectable text — not an image).
+
+- **Uses the browser you already have.** It drives your installed Chrome, Edge, Chromium, or Brave in the background — nothing extra is downloaded. If yours lives somewhere unusual, set `CAREER_MCP_CHROME_PATH`. If no browser is found, you get an `.html` file instead: open it and use Print → Save as PDF.
+- **Works offline.** Fonts are bundled with the package.
+- **Three themes:** `navy` (default — modern sans-serif, navy accents), `minimal` (monochrome, compact), `classic` (serif, centered header).
+- **Letter or A4.** Defaults to Letter; set `CAREER_MCP_PAGE_SIZE=a4` to change the default.
+- **Cover letters only on request** — the default document is the tailored resume.
+
+The PDF is written next to the markdown (e.g. `outputs/tailored_resume.pdf`). The markdown stays the source of truth: edit it, then export again.
+
+Resumes render best in this shape (the MCP client is told this automatically):
+
+```markdown
+# Full Name
+Target title · positioning
+City · email · phone · linkedin.com/in/you
+
+## Summary
+...
+
+## Experience
+### Job Title — Company
+*2021 – Present | City*
+- Achievement bullet
+```
+
 ## Use standalone (no MCP client)
 
 ```bash
@@ -53,8 +82,9 @@ cp .env.example .env   # fill in CAREER_MCP_API_KEY (free Groq or Gemini key)
 career-mcp-cli set-resume --file resume.txt
 career-mcp-cli set-jd --company Acme --role "Senior Engineer" --file jd.txt
 career-mcp-cli analyze
-career-mcp-cli resume
-career-mcp-cli cover-letter
+career-mcp-cli resume                         # also writes the PDF
+career-mcp-cli cover-letter --pdf             # --pdf is optional
+career-mcp-cli pdf --theme classic --page-size a4
 career-mcp-cli about
 career-mcp-cli interview   # guided story capture
 ```
@@ -69,6 +99,7 @@ career-mcp-cli interview   # guided story capture
 └── applications/<company-role>/
     ├── jd.json
     └── outputs/{match_analysis,tailored_resume,cover_letter,linkedin_about}.md
+        (+ tailored_resume.pdf / cover_letter.pdf once exported)
 ```
 
 Override the location with `CAREER_MCP_DATA_DIR`.

package/dist/cli.js

@@ -5,6 +5,8 @@ import "dotenv/config";
 import * as storage from "./storage.js";
 import { startStoryInterview, answerStoryQuestion } from "./interview.js";
 import { callLLM } from "./llm-fallback.js";
+import { exportPdf, describeResult } from "./export.js";
+import { RESUME_MARKDOWN_GUIDE } from "./render/markdown.js";
 const SYSTEM_PROMPT = "You are a career writing assistant. Write in a clear, direct, honest voice — " +
     "no buzzwords, no AI-sounding phrases ('in today's fast-paced world', 'as we navigate'), " +
     "no fake inspiration. Prefer specific, grounded claims over impressive-sounding generalities. " +
@@ -72,6 +74,15 @@ async function cmdGenerate(outputType, instruction) {
     await storage.saveOutput(ctx.application.slug, outputType, result);
     console.log(`\n(saved to ~/.career-mcp/applications/${ctx.application.slug}/outputs/${outputType}.md)`);
 }
+async function cmdPdf(flags, document) {
+    const result = await exportPdf({
+        document: document ?? flags.document,
+        applicationSlug: flags.application,
+        theme: flags.theme,
+        pageSize: flags["page-size"],
+    });
+    console.log(describeResult(result));
+}
 async function cmdInterview() {
     const rl = readline.createInterface({ input: stdin, output: stdout });
     let step = startStoryInterview();
@@ -97,9 +108,15 @@ async function main() {
         case "analyze":
             return cmdGenerate("match_analysis", "Analyze how well this resume matches this job description. Call out genuine overlaps and honest gaps — no keyword stuffing.");
         case "resume":
-            return cmdGenerate("tailored_resume", "Produce a tailored version of this resume for this job description, reordering and reframing existing content for relevance. Do not invent experience.");
+            await cmdGenerate("tailored_resume", `Produce a tailored version of this resume for this job description, reordering and reframing existing content for relevance. Do not invent experience.\n\n${RESUME_MARKDOWN_GUIDE}`);
+            return cmdPdf(flags, "tailored_resume");
         case "cover-letter":
-            return cmdGenerate("cover_letter", "Write a cover letter for this job description, in the voice profile's tone. A real letter: date, Dear Hiring Team, body, Sincerely + name.");
+            await cmdGenerate("cover_letter", "Write a cover letter for this job description, in the voice profile's tone. A real letter: date, Dear Hiring Team, body, Sincerely + name. Output only the letter, as markdown.");
+            if (flags.pdf)
+                return cmdPdf(flags, "cover_letter");
+            return;
+        case "pdf":
+            return cmdPdf(flags);
         case "about":
             return cmdGenerate("linkedin_about", "Write a LinkedIn About section based on this resume and these stories, in the voice profile's tone.");
         default:
@@ -112,9 +129,13 @@ async function main() {
                 "  set-jd --company <name> --role <title> --file <path>",
                 "  interview",
                 "  analyze",
-                "  resume",
-                "  cover-letter",
+                "  resume                 (also writes a PDF)",
+                "  cover-letter [--pdf]",
                 "  about",
+                "  pdf [--document tailored_resume|cover_letter|base_resume] [--theme navy|minimal|classic]",
+                "      [--page-size letter|a4] [--application <slug>]",
+                "",
+                "  resume and cover-letter --pdf also accept --theme and --page-size.",
             ].join("\n"));
     }
 }

package/dist/export.js

@@ -0,0 +1,55 @@
+import * as storage from "./storage.js";
+import { renderMarkdownToPdf } from "./render/pdf.js";
+import { PAGE_SIZES } from "./render/markdown.js";
+import { THEME_NAMES } from "./render/themes.js";
+export const EXPORT_DOCUMENTS = ["tailored_resume", "cover_letter", "base_resume"];
+function resolveTheme(theme) {
+    const value = (theme || process.env.CAREER_MCP_PDF_THEME || "navy").toLowerCase();
+    if (!THEME_NAMES.includes(value)) {
+        throw new Error(`Unknown theme "${value}". Choose one of: ${THEME_NAMES.join(", ")}.`);
+    }
+    return value;
+}
+function resolvePageSize(pageSize) {
+    const value = (pageSize || process.env.CAREER_MCP_PAGE_SIZE || "letter").toLowerCase();
+    if (!PAGE_SIZES.includes(value)) {
+        throw new Error(`Unknown page size "${value}". Choose one of: ${PAGE_SIZES.join(", ")}.`);
+    }
+    return value;
+}
+export async function exportPdf(options = {}) {
+    const document = options.document ?? "tailored_resume";
+    if (!EXPORT_DOCUMENTS.includes(document)) {
+        throw new Error(`Unknown document "${document}". Choose one of: ${EXPORT_DOCUMENTS.join(", ")}.`);
+    }
+    const renderOptions = { theme: resolveTheme(options.theme), pageSize: resolvePageSize(options.pageSize) };
+    if (document === "base_resume") {
+        const resume = await storage.getResume();
+        if (!resume?.rawText)
+            throw new Error("No resume stored yet. Use save_resume first.");
+        return renderMarkdownToPdf(resume.rawText, storage.baseResumeOutputBasePath(), { ...renderOptions, title: "Resume", kind: "resume" });
+    }
+    let slug = options.applicationSlug;
+    if (!slug) {
+        const active = await storage.getActiveApplication();
+        if (!active)
+            throw new Error("No active application and no application_slug provided.");
+        slug = active.slug;
+    }
+    const application = await storage.getApplication(slug);
+    if (!application)
+        throw new Error(`No application found with slug "${slug}".`);
+    const markdown = await storage.getOutput(slug, document);
+    if (!markdown) {
+        throw new Error(`No ${document} saved for ${application.company} — ${application.role} yet. Generate it and save it with save_output first.`);
+    }
+    const isLetter = document === "cover_letter";
+    return renderMarkdownToPdf(markdown, storage.outputBasePath(slug, document), {
+        ...renderOptions,
+        title: `${isLetter ? "Cover Letter" : "Resume"} — ${application.company}`,
+        kind: isLetter ? "letter" : "resume",
+    });
+}
+export function describeResult(result) {
+    return result.ok ? `PDF saved to ${result.pdfPath}` : `Could not create the PDF. ${result.reason}`;
+}

package/dist/index.js

@@ -4,6 +4,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import * as storage from "./storage.js";
 import { startStoryInterview, answerStoryQuestion } from "./interview.js";
+import { exportPdf, describeResult, EXPORT_DOCUMENTS } from "./export.js";
+import { RESUME_MARKDOWN_GUIDE, PAGE_SIZES } from "./render/markdown.js";
+import { THEME_NAMES } from "./render/themes.js";
 const server = new Server({ name: "career-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -55,7 +58,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "get_active_application",
-            description: "Returns the stored resume, voice profile, and the active job description together, as context for match analysis or content generation. Use this to: (1) run match analysis — identify genuine overlaps and honest gaps between the resume and JD, not keyword stuffing; (2) draft a tailored resume by reordering/reframing existing resume content for relevance, never fabricating experience; (3) draft a cover letter; (4) draft a LinkedIn About section. Match the voice profile's tone if one is set. Save any generated output with save_output.",
+            description: `Returns the stored resume, voice profile, and the active job description together, as context for match analysis or content generation. Use this to: (1) run match analysis — identify genuine overlaps and honest gaps between the resume and JD, not keyword stuffing; (2) draft a tailored resume by reordering/reframing existing resume content for relevance, never fabricating experience; (3) draft a cover letter; (4) draft a LinkedIn About section. Match the voice profile's tone if one is set. Save any generated output with save_output.\n\n${RESUME_MARKDOWN_GUIDE}`,
             inputSchema: { type: "object", properties: {} },
         },
         {
@@ -65,7 +68,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "save_output",
-            description: "Persist generated content (match analysis, tailored resume, cover letter, or LinkedIn About draft) for an application. Defaults to the active application if application_slug is omitted.",
+            description: "Persist generated content (match analysis, tailored resume, cover letter, or LinkedIn About draft) for an application. Defaults to the active application if application_slug is omitted. After saving a tailored resume, offer to export it with export_pdf.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -79,6 +82,23 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["output_type", "content"],
             },
         },
+        {
+            name: "export_pdf",
+            description: "Render a saved markdown document to a PDF that ATS systems can read, using the user's installed Chrome/Edge/Chromium/Brave. Defaults to the active application's tailored resume. Only export a cover letter when the user asks for one. If no browser is found, an HTML file is written instead and the reason is returned — relay it to the user.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    document: {
+                        type: "string",
+                        enum: EXPORT_DOCUMENTS,
+                        description: "tailored_resume (default), cover_letter, or base_resume (the stored base resume)",
+                    },
+                    application_slug: { type: "string", description: "Optional — defaults to the active application. Ignored for base_resume." },
+                    theme: { type: "string", enum: THEME_NAMES, description: "navy (default: modern sans, navy accents), minimal (monochrome, compact), classic (serif, centered header)" },
+                    page_size: { type: "string", enum: PAGE_SIZES, description: "letter (default) or a4" },
+                },
+            },
+        },
         {
             name: "save_story",
             description: "Save a career story directly (title, tags, content) without running the interview flow. Prefer start_story_interview for a guided capture.",
@@ -199,6 +219,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const filePath = await storage.saveOutput(slug, output_type, content);
                 return textResult(`Saved ${output_type} to ${filePath}`);
             }
+            case "export_pdf": {
+                const { document, application_slug, theme, page_size } = args;
+                const result = await exportPdf({ document, applicationSlug: application_slug, theme, pageSize: page_size });
+                return result.ok ? textResult(describeResult(result)) : { ...textResult(describeResult(result)), isError: true };
+            }
             case "save_story": {
                 const { title, tags, content } = args;
                 const story = await storage.saveStory(title, tags, content);

package/dist/render/fonts.js

@@ -0,0 +1,24 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+// Fonts ship as npm dependencies (@fontsource/*, all SIL OFL) and are inlined
+// into the HTML as data URIs, so rendering never needs a network connection.
+const require = createRequire(import.meta.url);
+async function faceCss(face, weight, style) {
+    const pkgDir = path.dirname(require.resolve(`${face.pkg}/package.json`));
+    const file = path.join(pkgDir, "files", `${face.filePrefix}-latin-${weight}-${style}.woff2`);
+    const data = (await readFile(file)).toString("base64");
+    return `@font-face {
+  font-family: '${face.family}';
+  font-style: ${style};
+  font-weight: ${weight};
+  src: url(data:font/woff2;base64,${data}) format('woff2');
+}`;
+}
+export async function fontFaceCss(face) {
+    const rules = await Promise.all([
+        ...face.weights.map((w) => faceCss(face, w, "normal")),
+        ...face.italicWeights.map((w) => faceCss(face, w, "italic")),
+    ]);
+    return rules.join("\n");
+}

package/dist/render/markdown.js

@@ -0,0 +1,87 @@
+import { marked } from "marked";
+import { THEMES, SHARED_CSS } from "./themes.js";
+import { fontFaceCss } from "./fonts.js";
+export const PAGE_SIZES = ["letter", "a4"];
+// Handed to the MCP client (and the CLI's LLM) so generated resumes match what the themes style.
+export const RESUME_MARKDOWN_GUIDE = [
+    "Write the tailored resume as markdown in this exact shape so it renders cleanly to PDF:",
+    "  # Full Name",
+    "  One-line tagline (target title / positioning)",
+    "  Contact line: City · email · phone · linkedin.com/in/... (one paragraph)",
+    "  ## Summary  (then a short paragraph)",
+    "  ## Experience",
+    "  ### Job Title — Company",
+    "  *Start – End | Location*",
+    "  - achievement bullets",
+    "  ## Skills  (bullets, or a two-column table: | Area | Skills |)",
+    "  ## Education",
+    "Output only the resume itself — no commentary before or after it.",
+].join("\n");
+// LLM output often arrives fenced (```markdown ... ```) or with a chatty preamble,
+// and resume files may carry private notes. Strip all of that before rendering.
+export function cleanMarkdown(markdown) {
+    let text = markdown.trim();
+    const fenced = text.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/i);
+    if (fenced)
+        text = fenced[1].trim();
+    const lines = text.split("\n");
+    const firstH1 = lines.findIndex((line) => /^# /.test(line));
+    const start = firstH1 === -1 ? 0 : firstH1;
+    const notes = lines.findIndex((line, i) => i > start && /^## Notes for Customization/i.test(line));
+    const end = notes === -1 ? lines.length : notes;
+    return separateStructuralLines(lines.slice(start, end)).join("\n").trim();
+}
+// The themes style lines by position (h1 + p + p is the contact line, h3 + p the dates),
+// but markdown folds consecutive lines into one paragraph. Give each plain line its own
+// paragraph in the header block (between # Name and the first ##) and right after a ###/####.
+function separateStructuralLines(lines) {
+    const isPlain = (line) => line.trim() !== "" && !/^\s*([-+]\s|\*\s|\d+\.\s|[|>#]|```)/.test(line);
+    const out = [];
+    let inHeaderBlock = false;
+    let afterSubheading = false;
+    for (const line of lines) {
+        if (/^# /.test(line))
+            inHeaderBlock = true;
+        else if (/^## /.test(line))
+            inHeaderBlock = false;
+        // A ###/#### opens a run of plain lines (dates, role description); bullets, tables, etc. end it.
+        if (/^#{3,4} /.test(line))
+            afterSubheading = true;
+        else if (line.trim() !== "" && !isPlain(line))
+            afterSubheading = false;
+        out.push(line);
+        if ((inHeaderBlock || afterSubheading) && isPlain(line))
+            out.push("");
+    }
+    return out;
+}
+export async function markdownToHtml(markdown, options) {
+    const theme = THEMES[options.theme];
+    // Letters keep single line breaks ("Sincerely,\nName"); resumes use standard markdown paragraphs.
+    const body = await marked.parse(cleanMarkdown(markdown), { breaks: options.kind === "letter" });
+    const fonts = await fontFaceCss(theme.font);
+    const pageSize = options.pageSize === "a4" ? "A4" : "letter";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>${escapeHtml(options.title)}</title>
+  <style>
+${fonts}
+@page {
+  size: ${pageSize};
+  margin: 0.6in 0.75in;
+}
+${SHARED_CSS}
+${theme.css}
+  </style>
+</head>
+<body class="${options.kind}">
+${body}
+</body>
+</html>
+`;
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}

package/dist/render/pdf.js

@@ -0,0 +1,93 @@
+import { access, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import puppeteer from "puppeteer-core";
+import { markdownToHtml } from "./markdown.js";
+// puppeteer-core drives a browser the user already has installed — it never
+// downloads one. Set CAREER_MCP_CHROME_PATH to point at a browser we don't find.
+function candidateBrowserPaths() {
+    const home = os.homedir();
+    switch (process.platform) {
+        case "darwin":
+            return [
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+                "/Applications/Chromium.app/Contents/MacOS/Chromium",
+                "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+                path.join(home, "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+            ];
+        case "win32": {
+            const roots = [process.env["PROGRAMFILES"], process.env["PROGRAMFILES(X86)"], process.env["LOCALAPPDATA"]].filter((root) => Boolean(root));
+            return roots.flatMap((root) => [
+                path.join(root, "Google", "Chrome", "Application", "chrome.exe"),
+                path.join(root, "Microsoft", "Edge", "Application", "msedge.exe"),
+                path.join(root, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+            ]);
+        }
+        default:
+            return [
+                "/usr/bin/google-chrome",
+                "/usr/bin/google-chrome-stable",
+                "/usr/bin/chromium",
+                "/usr/bin/chromium-browser",
+                "/usr/bin/microsoft-edge",
+                "/usr/bin/brave-browser",
+                "/snap/bin/chromium",
+            ];
+    }
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function findBrowser() {
+    const override = process.env.CAREER_MCP_CHROME_PATH;
+    if (override) {
+        if (await exists(override))
+            return override;
+        throw new Error(`CAREER_MCP_CHROME_PATH is set to ${override}, but no file exists there.`);
+    }
+    for (const candidate of candidateBrowserPaths()) {
+        if (await exists(candidate))
+            return candidate;
+    }
+    return null;
+}
+// Writes <outBase>.pdf. If no browser is available, writes <outBase>.html instead
+// so the user can open it and Print → Save as PDF themselves.
+export async function renderMarkdownToPdf(markdown, outBase, options) {
+    const html = await markdownToHtml(markdown, options);
+    const browserPath = await findBrowser();
+    if (!browserPath) {
+        const htmlPath = `${outBase}.html`;
+        await writeFile(htmlPath, html, "utf8");
+        return {
+            ok: false,
+            htmlPath,
+            reason: "No Chrome, Edge, Chromium, or Brave install was found. Install one, or set CAREER_MCP_CHROME_PATH to your browser's executable. " +
+                `In the meantime, open ${htmlPath} in any browser and use Print → Save as PDF.`,
+        };
+    }
+    const browser = await puppeteer.launch({
+        executablePath: browserPath,
+        headless: true,
+        // Chrome refuses to start as root (common in containers/CI) without --no-sandbox.
+        args: process.getuid?.() === 0 ? ["--no-sandbox", "--disable-dev-shm-usage"] : [],
+    });
+    try {
+        const page = await browser.newPage();
+        await page.setContent(html, { waitUntil: "load" });
+        await page.evaluateHandle("document.fonts.ready");
+        const pdfPath = `${outBase}.pdf`;
+        await page.pdf({ path: pdfPath, printBackground: true, preferCSSPageSize: true });
+        return { ok: true, pdfPath };
+    }
+    finally {
+        await browser.close();
+    }
+}

package/dist/render/themes.js

@@ -0,0 +1,445 @@
+export const THEME_NAMES = ["navy", "minimal", "classic"];
+// Page-break rules shared by every theme: keep headings attached to what follows them.
+export const SHARED_CSS = `
+* { box-sizing: border-box; }
+
+h2, h3, h4 {
+  page-break-after: avoid;
+  break-after: avoid;
+}
+
+h2 + p, h2 + ul, h2 + table,
+h3 + p, h3 + ul,
+h4 + p, h4 + ul {
+  page-break-before: avoid;
+  break-before: avoid;
+}
+
+li, p {
+  orphans: 3;
+  widows: 3;
+}
+
+blockquote, table {
+  page-break-inside: avoid;
+  break-inside: avoid;
+}
+
+thead { display: none; }
+
+/* Cover letters reuse the theme but read as prose: roomier paragraphs. */
+body.letter { line-height: 1.55; }
+body.letter p { margin: 0 0 10pt 0; }
+`;
+// The original render-pdf.sh look: Inter, deep navy accents, tinted impact callouts.
+const navy = {
+    font: {
+        family: "Inter",
+        pkg: "@fontsource/inter",
+        filePrefix: "inter",
+        weights: [400, 500, 600, 700],
+        italicWeights: [400],
+    },
+    css: `
+body {
+  font-family: 'Inter', 'Calibri', 'Helvetica Neue', Arial, sans-serif;
+  font-size: 10.5pt;
+  color: #111827;
+  line-height: 1.45;
+  margin: 0;
+}
+
+h1 {
+  font-size: 21pt;
+  font-weight: 700;
+  color: #0F172A;
+  margin: 0 0 3pt 0;
+  letter-spacing: -0.02em;
+  line-height: 1.1;
+}
+
+h1 + p {
+  font-size: 10.5pt;
+  font-weight: 500;
+  color: #1E3A6E;
+  margin: 0 0 2pt 0;
+  letter-spacing: 0.01em;
+}
+
+h1 + p + p {
+  font-size: 9.5pt;
+  font-weight: 500;
+  color: #334155;
+  letter-spacing: 0.02em;
+  line-height: 1.7;
+  margin: 8pt 0 4pt 0;
+  padding-top: 6pt;
+  border-top: 0.75px solid #CBD5E1;
+}
+
+h1 + p + p a {
+  color: #1E3A6E;
+  font-weight: 600;
+  text-decoration: none;
+}
+
+h2 {
+  font-size: 9pt;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.13em;
+  color: #1E3A6E;
+  border-bottom: 1.5px solid #1E3A6E;
+  padding-bottom: 3pt;
+  margin: 17pt 0 7pt 0;
+}
+
+h3 {
+  font-size: 11.5pt;
+  font-weight: 700;
+  color: #0F172A;
+  margin: 10pt 0 0 0;
+  line-height: 1.3;
+}
+
+h3 + p {
+  font-size: 9.5pt;
+  font-style: italic;
+  color: #64748B;
+  margin: 1pt 0 4pt 0;
+}
+
+h3 + p + p {
+  font-size: 10pt;
+  color: #475569;
+  margin: 2pt 0 5pt 0;
+}
+
+h4 {
+  font-size: 10pt;
+  font-weight: 600;
+  font-style: italic;
+  color: #1E3A6E;
+  margin: 8pt 0 3pt 0;
+}
+
+p { margin: 2pt 0 4pt 0; }
+
+ul {
+  margin: 2pt 0 5pt 0;
+  padding-left: 15pt;
+  list-style-type: disc;
+}
+
+li {
+  font-size: 10.5pt;
+  color: #111827;
+  line-height: 1.45;
+  margin-bottom: 3pt;
+}
+
+strong { font-weight: 600; }
+em { font-style: italic; }
+a { color: #1E3A6E; }
+
+hr {
+  border: none;
+  border-top: 1px solid #E2E8F0;
+  margin: 8pt 0;
+}
+
+blockquote {
+  margin: 6pt 0 4pt 0;
+  padding: 6pt 10pt;
+  border-left: 3px solid #1E3A6E;
+  background: #EFF6FF;
+  border-radius: 0 3pt 3pt 0;
+  color: #1E293B;
+  font-size: 10pt;
+  font-weight: 500;
+}
+
+blockquote p { margin: 0; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 10pt;
+  margin: 4pt 0 2pt 0;
+}
+
+td {
+  padding: 4pt 8pt 4pt 0;
+  vertical-align: top;
+  border-bottom: 0.75px solid #E2E8F0;
+}
+
+td:first-child {
+  width: 25%;
+  font-weight: 600;
+  color: #1E3A6E;
+  font-size: 9.5pt;
+  padding-right: 12pt;
+  white-space: nowrap;
+}
+
+td:last-child {
+  color: #334155;
+  font-size: 10pt;
+}
+
+tr:last-child td { border-bottom: none; }
+`,
+};
+// Monochrome and compact: IBM Plex Sans, no color, thin rules. Fits more on a page.
+const minimal = {
+    font: {
+        family: "IBM Plex Sans",
+        pkg: "@fontsource/ibm-plex-sans",
+        filePrefix: "ibm-plex-sans",
+        weights: [400, 500, 600, 700],
+        italicWeights: [400],
+    },
+    css: `
+body {
+  font-family: 'IBM Plex Sans', 'Helvetica Neue', Arial, sans-serif;
+  font-size: 10pt;
+  color: #000000;
+  line-height: 1.4;
+  margin: 0;
+}
+
+h1 {
+  font-size: 18pt;
+  font-weight: 600;
+  margin: 0 0 2pt 0;
+  line-height: 1.1;
+}
+
+h1 + p {
+  font-size: 10pt;
+  color: #333333;
+  margin: 0 0 2pt 0;
+}
+
+h1 + p + p {
+  font-size: 9pt;
+  color: #333333;
+  margin: 0 0 6pt 0;
+}
+
+h1 + p + p a {
+  color: #000000;
+  text-decoration: none;
+}
+
+h2 {
+  font-size: 9.5pt;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  border-bottom: 0.75px solid #000000;
+  padding-bottom: 2pt;
+  margin: 13pt 0 5pt 0;
+}
+
+h3 {
+  font-size: 10.5pt;
+  font-weight: 600;
+  margin: 8pt 0 0 0;
+  line-height: 1.3;
+}
+
+h3 + p {
+  font-size: 9pt;
+  color: #555555;
+  margin: 0 0 3pt 0;
+}
+
+h3 + p + p {
+  font-size: 9.5pt;
+  color: #333333;
+  margin: 1pt 0 3pt 0;
+}
+
+h4 {
+  font-size: 9.5pt;
+  font-weight: 600;
+  margin: 6pt 0 2pt 0;
+}
+
+p { margin: 2pt 0 3pt 0; }
+
+ul {
+  margin: 1pt 0 4pt 0;
+  padding-left: 13pt;
+}
+
+li {
+  margin-bottom: 2pt;
+}
+
+strong { font-weight: 600; }
+a { color: #000000; }
+
+hr {
+  border: none;
+  border-top: 0.75px solid #CCCCCC;
+  margin: 6pt 0;
+}
+
+blockquote {
+  margin: 4pt 0;
+  padding: 0 0 0 8pt;
+  border-left: 2px solid #000000;
+}
+
+blockquote p { margin: 0; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 2pt 0;
+}
+
+td {
+  padding: 2pt 8pt 2pt 0;
+  vertical-align: top;
+}
+
+td:first-child {
+  width: 22%;
+  font-weight: 600;
+  white-space: nowrap;
+}
+`,
+};
+// Traditional: Source Serif, centered header, small-caps section rules. Suits finance, law, academia.
+const classic = {
+    font: {
+        family: "Source Serif 4",
+        pkg: "@fontsource/source-serif-4",
+        filePrefix: "source-serif-4",
+        weights: [400, 600, 700],
+        italicWeights: [400],
+    },
+    css: `
+body {
+  font-family: 'Source Serif 4', Georgia, 'Times New Roman', serif;
+  font-size: 10.5pt;
+  color: #1A1A1A;
+  line-height: 1.4;
+  margin: 0;
+}
+
+h1 {
+  font-size: 20pt;
+  font-weight: 600;
+  text-align: center;
+  letter-spacing: 0.04em;
+  margin: 0 0 3pt 0;
+  line-height: 1.1;
+}
+
+h1 + p {
+  font-size: 10.5pt;
+  font-style: italic;
+  text-align: center;
+  margin: 0 0 2pt 0;
+}
+
+h1 + p + p {
+  font-size: 9.5pt;
+  text-align: center;
+  margin: 0 0 6pt 0;
+  padding-bottom: 6pt;
+  border-bottom: 1px solid #1A1A1A;
+}
+
+h1 + p + p a {
+  color: #1A1A1A;
+  text-decoration: none;
+}
+
+h2 {
+  font-size: 11pt;
+  font-weight: 600;
+  font-variant: small-caps;
+  letter-spacing: 0.06em;
+  border-bottom: 0.5px solid #1A1A1A;
+  padding-bottom: 1pt;
+  margin: 14pt 0 6pt 0;
+}
+
+h3 {
+  font-size: 11pt;
+  font-weight: 700;
+  margin: 9pt 0 0 0;
+  line-height: 1.3;
+}
+
+h3 + p {
+  font-size: 10pt;
+  font-style: italic;
+  color: #444444;
+  margin: 0 0 3pt 0;
+}
+
+h3 + p + p {
+  font-size: 10pt;
+  margin: 1pt 0 4pt 0;
+}
+
+h4 {
+  font-size: 10.5pt;
+  font-weight: 600;
+  font-style: italic;
+  margin: 7pt 0 2pt 0;
+}
+
+p { margin: 2pt 0 4pt 0; }
+
+ul {
+  margin: 2pt 0 5pt 0;
+  padding-left: 15pt;
+}
+
+li {
+  margin-bottom: 2pt;
+}
+
+strong { font-weight: 600; }
+a { color: #1A1A1A; }
+
+hr {
+  border: none;
+  border-top: 0.5px solid #1A1A1A;
+  margin: 8pt 0;
+}
+
+blockquote {
+  margin: 5pt 16pt;
+  font-style: italic;
+}
+
+blockquote p { margin: 0; }
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 3pt 0;
+}
+
+td {
+  padding: 2pt 10pt 2pt 0;
+  vertical-align: top;
+}
+
+td:first-child {
+  width: 25%;
+  font-weight: 600;
+  white-space: nowrap;
+}
+`,
+};
+export const THEMES = { navy, minimal, classic };

package/dist/storage.js

@@ -142,6 +142,13 @@ export async function saveOutput(slug, type, content) {
     await writeFile(filePath, content, "utf8");
     return filePath;
 }
+// Path without extension, so renderers can write <base>.pdf / <base>.html next to <base>.md.
+export function outputBasePath(slug, type) {
+    return path.join(APPLICATIONS_DIR, slug, "outputs", type);
+}
+export function baseResumeOutputBasePath() {
+    return path.join(DATA_DIR, "resume");
+}
 export async function getOutput(slug, type) {
     const filePath = path.join(APPLICATIONS_DIR, slug, "outputs", `${type}.md`);
     if (!(await exists(filePath)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sindhujaks/career-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "MCP server for resume/JD match analysis, tailored resumes and cover letters, a structured career-story interview, and LinkedIn About drafting. Local-first — your data never leaves your machine.",
   "type": "module",
   "main": "dist/index.js",
@@ -45,9 +45,14 @@
     "access": "public"
   },
   "dependencies": {
+    "@fontsource/ibm-plex-sans": "^5.3.0",
+    "@fontsource/inter": "^5.3.0",
+    "@fontsource/source-serif-4": "^5.3.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "dotenv": "^16.4.0",
-    "pdf-parse": "^2.4.5"
+    "marked": "^18.1.2",
+    "pdf-parse": "^2.4.5",
+    "puppeteer-core": "^25.16.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",