@sindhujaks/career-mcp 0.0.0-stage → 1.1.0

package/.env.example

@@ -0,0 +1,27 @@
+# career-mcp — environment variables
+# Copy this file to .env and fill in your values. Never commit .env.
+#
+# Only needed if you're using the standalone CLI (career-mcp-cli) without an
+# MCP-capable client. The MCP server itself (career-mcp) needs none of this —
+# it relies on the host LLM (Claude Code, Claude Desktop, etc.) to reason.
+
+# ─── Optional — where your resume/stories/applications are stored ────────────
+# 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.
+#
+# "groq"   — free tier at https://console.groq.com/keys
+# "gemini" — free tier at https://aistudio.google.com/apikey
+CAREER_MCP_LLM_PROVIDER=groq
+CAREER_MCP_API_KEY=
+# CAREER_MCP_LLM_MODEL=       # optional override, defaults per provider

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sindhuja Kalisrinivasan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,109 @@
-# Temporary Holding Version
+# career-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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.
+
+## How it works
+
+The MCP server itself doesn't call any LLM. It's a data layer: it stores your resume, job descriptions, voice profile, and stories, and hands them back as context. The actual reasoning — match analysis, tailoring, writing — is done by whatever MCP-capable client you're using (Claude Code, Claude Desktop, etc.), the same way any tool-using conversation works.
+
+If you don't have an MCP client, the bundled CLI (`career-mcp-cli`) does the same job standalone, using your own Groq or Gemini API key (both have usable free tiers) to do the reasoning itself.
+
+## Install
+
+```bash
+npm install -g @sindhujaks/career-mcp
+```
+
+## Use with an MCP client (recommended)
+
+Add to your client's MCP config (e.g. `.mcp.json` for Claude Code):
+
+```json
+{
+  "mcpServers": {
+    "career-mcp": {
+      "command": "career-mcp"
+    }
+  }
+}
+```
+
+Then, in conversation: save your resume, save a JD, and ask your client to run a match analysis, draft a tailored resume, write a cover letter, or draft a LinkedIn About. Say "let's capture a career story" to run the guided interview.
+
+### Tools
+
+| Tool | Purpose |
+|---|---|
+| `save_resume` / `get_resume` | Store/retrieve your base resume |
+| `save_voice_profile` / `get_voice_profile` | Store tone/style guidance so generated content sounds like you |
+| `save_jd` | Store a job description, sets it as the active application |
+| `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
+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                         # 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
+```
+
+## Data layout
+
+```
+~/.career-mcp/
+├── resume.json
+├── voice_profile.md
+├── stories/<slug>.md
+└── 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`.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import * as readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+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. " +
+    "Never fabricate experience that isn't in the provided resume or stories.";
+async function readArgFile(flagValue) {
+    if (!flagValue)
+        return undefined;
+    return storage.readTextFile(flagValue);
+}
+function parseFlags(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i].startsWith("--")) {
+            const key = argv[i].slice(2);
+            const value = argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : "true";
+            flags[key] = value;
+        }
+    }
+    return flags;
+}
+async function buildContext() {
+    const [resume, voice, application] = await Promise.all([
+        storage.getResume(),
+        storage.getVoiceProfile(),
+        storage.getActiveApplication(),
+    ]);
+    if (!application)
+        throw new Error("No active application. Run `career-mcp-cli set-jd` first.");
+    const stories = await storage.queryStories();
+    return { resume, voice, application, stories };
+}
+function contextToPrompt(ctx) {
+    return [
+        `Job description (${ctx.application.company} — ${ctx.application.role}):`,
+        ctx.application.jdText,
+        "",
+        "Resume:",
+        ctx.resume?.rawText ?? "(none provided)",
+        "",
+        "Voice profile:",
+        ctx.voice ?? "(none provided — default to clear, direct, honest)",
+        ctx.stories.length > 0 ? `\nCareer stories (use if relevant):\n${ctx.stories.map((s) => `${s.title}: ${s.content}`).join("\n\n")}` : "",
+    ].join("\n");
+}
+async function cmdSetResume(flags) {
+    const text = await readArgFile(flags.file);
+    if (!text)
+        throw new Error("Usage: career-mcp-cli set-resume --file <path>");
+    await storage.saveResume(text);
+    console.log("Resume saved.");
+}
+async function cmdSetJD(flags) {
+    const text = await readArgFile(flags.file);
+    if (!text || !flags.company || !flags.role) {
+        throw new Error("Usage: career-mcp-cli set-jd --company <name> --role <title> --file <path>");
+    }
+    const application = await storage.saveJD(flags.company, flags.role, text);
+    console.log(`Saved JD for ${flags.company} — ${flags.role} (${application.slug}), set as active.`);
+}
+async function cmdGenerate(outputType, instruction) {
+    const ctx = await buildContext();
+    const prompt = `${instruction}\n\n${contextToPrompt(ctx)}`;
+    const result = await callLLM(SYSTEM_PROMPT, prompt);
+    console.log(result);
+    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();
+    console.log(`Let's capture a story. ${step.total_questions} quick questions.\n`);
+    while (step.status === "in_progress") {
+        const answer = await rl.question(`${step.question}\n> `);
+        step = await answerStoryQuestion(step.session_id, answer);
+        console.log("");
+    }
+    console.log(`Saved: "${step.story?.title}" [${step.story?.tags.join(", ")}]`);
+    rl.close();
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    const flags = parseFlags(rest);
+    switch (command) {
+        case "set-resume":
+            return cmdSetResume(flags);
+        case "set-jd":
+            return cmdSetJD(flags);
+        case "interview":
+            return cmdInterview();
+        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":
+            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":
+            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:
+            console.log([
+                "career-mcp-cli — standalone mode (no MCP client needed)",
+                "Requires CAREER_MCP_API_KEY in your environment (Groq or Gemini free tier). See .env.example.",
+                "",
+                "Commands:",
+                "  set-resume --file <path>",
+                "  set-jd --company <name> --role <title> --file <path>",
+                "  interview",
+                "  analyze",
+                "  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"));
+    }
+}
+main().catch((err) => {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

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

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+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: [
+        {
+            name: "save_resume",
+            description: "Store the user's base resume, either as raw text or by reading a local file. Overwrites any previously stored resume. Provide exactly one of resume_text or resume_path.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    resume_text: { type: "string", description: "The full resume content" },
+                    resume_path: { type: "string", description: "Absolute path to a .pdf, .txt, or .md resume file to read instead of passing raw text" },
+                },
+            },
+        },
+        {
+            name: "get_resume",
+            description: "Retrieve the stored base resume.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "save_voice_profile",
+            description: "Store a description of the user's writing voice/tone (e.g. tone attributes, phrases to avoid, sample posts). Used to keep generated cover letters and LinkedIn About sections sounding like the user, not generic AI copy.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    voice_text: { type: "string", description: "Description of tone, style, and things to avoid" },
+                },
+                required: ["voice_text"],
+            },
+        },
+        {
+            name: "get_voice_profile",
+            description: "Retrieve the stored voice profile, if one has been saved.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "save_jd",
+            description: "Store a job description for a company/role and mark it as the active application. Creates a new application record. Provide exactly one of jd_text or jd_path.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    company: { type: "string" },
+                    role: { type: "string" },
+                    jd_text: { type: "string", description: "The full job description text" },
+                    jd_path: { type: "string", description: "Absolute path to a .pdf, .txt, or .md job description file to read instead of passing raw text" },
+                },
+                required: ["company", "role"],
+            },
+        },
+        {
+            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.\n\n${RESUME_MARKDOWN_GUIDE}`,
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "list_applications",
+            description: "List all stored applications (company, role, created date).",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            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. After saving a tailored resume, offer to export it with export_pdf.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    output_type: {
+                        type: "string",
+                        enum: ["match_analysis", "tailored_resume", "cover_letter", "linkedin_about"],
+                    },
+                    content: { type: "string" },
+                    application_slug: { type: "string", description: "Optional — defaults to the active application" },
+                },
+                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.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    title: { type: "string" },
+                    tags: { type: "array", items: { type: "string" } },
+                    content: { type: "string" },
+                },
+                required: ["title", "tags", "content"],
+            },
+        },
+        {
+            name: "query_stories",
+            description: "Retrieve saved career stories, optionally filtered by tag (e.g. leadership, conflict, failure-recovery, technical-deep-dive). Use to find a story relevant to a JD requirement, an interview-prep question, or a LinkedIn post idea.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tags: { type: "array", items: { type: "string" }, description: "Optional tag filter" },
+                },
+            },
+        },
+        {
+            name: "start_story_interview",
+            description: "Begin a structured interview to capture one new career story. Returns the first question and a session_id. Keep calling answer_story_question with that session_id, relaying each returned question to the user verbatim, until status is 'complete' — the story is then auto-saved.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "answer_story_question",
+            description: "Submit the user's answer to the current interview question and get the next one (or the completed, saved story).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: { type: "string" },
+                    answer: { type: "string" },
+                },
+                required: ["session_id", "answer"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "save_resume": {
+                const { resume_text, resume_path } = args;
+                const text = resume_text ?? (resume_path ? await storage.readTextFile(resume_path) : undefined);
+                if (!text)
+                    throw new Error("Provide either resume_text or resume_path.");
+                await storage.saveResume(text);
+                return textResult("Resume saved.");
+            }
+            case "get_resume": {
+                const resume = await storage.getResume();
+                return textResult(resume?.rawText ? resume.rawText : "No resume stored yet. Use save_resume first.");
+            }
+            case "save_voice_profile": {
+                const { voice_text } = args;
+                await storage.saveVoiceProfile(voice_text);
+                return textResult("Voice profile saved.");
+            }
+            case "get_voice_profile": {
+                const voice = await storage.getVoiceProfile();
+                return textResult(voice ?? "No voice profile stored yet.");
+            }
+            case "save_jd": {
+                const { company, role, jd_text, jd_path } = args;
+                const text = jd_text ?? (jd_path ? await storage.readTextFile(jd_path) : undefined);
+                if (!text)
+                    throw new Error("Provide either jd_text or jd_path.");
+                const application = await storage.saveJD(company, role, text);
+                return textResult(`Saved job description for ${company} — ${role}. Set as the active application (slug: ${application.slug}).`);
+            }
+            case "get_active_application": {
+                const application = await storage.getActiveApplication();
+                if (!application)
+                    return textResult("No active application. Use save_jd first.");
+                const [resume, voice, stories] = await Promise.all([
+                    storage.getResume(),
+                    storage.getVoiceProfile(),
+                    storage.queryStories(),
+                ]);
+                const relevantStories = stories.filter((s) => application.jdText.toLowerCase().split(/\W+/).some((word) => word.length > 4 && s.content.toLowerCase().includes(word)));
+                const sections = [
+                    `## Active application: ${application.company} — ${application.role}`,
+                    "",
+                    "### Job description",
+                    application.jdText,
+                    "",
+                    "### Resume",
+                    resume?.rawText ? resume.rawText : "(none stored)",
+                    "",
+                    "### Voice profile",
+                    voice ?? "(none stored — write in a clear, direct, honest tone; avoid buzzwords and AI-sounding phrases)",
+                ];
+                if (relevantStories.length > 0) {
+                    sections.push("", "### Potentially relevant stories", ...relevantStories.map((s) => `**${s.title}** [${s.tags.join(", ")}]\n${s.content}`));
+                }
+                return textResult(sections.join("\n"));
+            }
+            case "list_applications": {
+                const applications = await storage.listApplications();
+                if (applications.length === 0)
+                    return textResult("No applications stored yet.");
+                return textResult(applications.map((a) => `- ${a.company} — ${a.role} (${a.slug}, created ${a.createdAt})`).join("\n"));
+            }
+            case "save_output": {
+                const { output_type, content, application_slug } = args;
+                let slug = application_slug;
+                if (!slug) {
+                    const active = await storage.getActiveApplication();
+                    if (!active)
+                        throw new Error("No active application and no application_slug provided.");
+                    slug = active.slug;
+                }
+                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);
+                return textResult(`Story saved: ${story.title} (${story.slug})`);
+            }
+            case "query_stories": {
+                const { tags } = args;
+                const stories = await storage.queryStories(tags);
+                if (stories.length === 0)
+                    return textResult("No matching stories found.");
+                return textResult(stories.map((s) => `**${s.title}** [${s.tags.join(", ")}]\n${s.content}`).join("\n\n---\n\n"));
+            }
+            case "start_story_interview": {
+                const step = startStoryInterview();
+                return textResult(`Question 1 of ${step.total_questions}:\n${step.question}\n\n(session_id: ${step.session_id})`);
+            }
+            case "answer_story_question": {
+                const { session_id, answer } = args;
+                const step = await answerStoryQuestion(session_id, answer);
+                if (step.status === "complete") {
+                    return textResult(`Story complete and saved: "${step.story?.title}" (tags: ${step.story?.tags.join(", ")})`);
+                }
+                return textResult(`Question ${step.question_number} of ${step.total_questions}:\n${step.question}\n\n(session_id: ${step.session_id})`);
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+    }
+});
+function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("career-mcp server error:", err);
+    process.exit(1);
+});