@sindhujaks/career-mcp 0.0.0-stage → 1.0.0

package/.env.example

@@ -0,0 +1,20 @@
+# 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=
+
+# ─── 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,78 @@
-# 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, a cover letter, 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 |
+| `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 |
+
+## 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
+career-mcp-cli cover-letter
+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
+```
+
+Override the location with `CAREER_MCP_DATA_DIR`.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,124 @@
+#!/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";
+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 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":
+            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.");
+        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.");
+        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",
+                "  cover-letter",
+                "  about",
+            ].join("\n"));
+    }
+}
+main().catch((err) => {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/index.js

@@ -0,0 +1,245 @@
+#!/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";
+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.",
+            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.",
+            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: "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 "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);
+});

package/dist/interview.js

@@ -0,0 +1,79 @@
+import { randomUUID } from "node:crypto";
+import { saveStory } from "./storage.js";
+const QUESTIONS = [
+    {
+        key: "scene",
+        prompt: "What's a specific moment you're thinking of? Set the scene — your role, the team, roughly when this was.",
+    },
+    {
+        key: "situation",
+        prompt: "What was the problem or goal, and why did it actually matter?",
+    },
+    {
+        key: "action",
+        prompt: "What did you specifically do? Walk through your own actions, not the team's.",
+    },
+    {
+        key: "result",
+        prompt: "What happened as a result? Include real numbers or concrete outcomes if you have them.",
+    },
+    {
+        key: "reflection",
+        prompt: "Looking back, what's the honest tradeoff, or the thing you'd do differently?",
+    },
+    {
+        key: "tags",
+        prompt: "What would you tag this story as? (comma-separated, e.g. leadership, conflict, technical-deep-dive, failure-recovery)",
+    },
+    {
+        key: "title",
+        prompt: "Give this story a short title (3-6 words) so you can find it again later.",
+    },
+];
+const sessions = new Map();
+export function startStoryInterview() {
+    const session_id = randomUUID();
+    sessions.set(session_id, { index: 0, answers: {} });
+    return {
+        session_id,
+        status: "in_progress",
+        question: QUESTIONS[0].prompt,
+        question_number: 1,
+        total_questions: QUESTIONS.length,
+    };
+}
+export async function answerStoryQuestion(session_id, answer) {
+    const session = sessions.get(session_id);
+    if (!session) {
+        throw new Error(`No interview session found for session_id: ${session_id}. Start a new one with start_story_interview.`);
+    }
+    const current = QUESTIONS[session.index];
+    session.answers[current.key] = answer;
+    session.index += 1;
+    if (session.index < QUESTIONS.length) {
+        const next = QUESTIONS[session.index];
+        return {
+            session_id,
+            status: "in_progress",
+            question: next.prompt,
+            question_number: session.index + 1,
+            total_questions: QUESTIONS.length,
+        };
+    }
+    const { scene, situation, action, result, reflection, tags, title } = session.answers;
+    const content = [
+        `**Scene:** ${scene}`,
+        "",
+        `**Situation:** ${situation}`,
+        "",
+        `**Action:** ${action}`,
+        "",
+        `**Result:** ${result}`,
+        "",
+        `**Reflection:** ${reflection}`,
+    ].join("\n");
+    const storyTags = tags.split(",").map((t) => t.trim()).filter(Boolean);
+    const story = await saveStory(title, storyTags, content);
+    sessions.delete(session_id);
+    return { session_id, status: "complete", story };
+}

package/dist/llm-fallback.js

@@ -0,0 +1,64 @@
+// Only used by the standalone CLI (src/cli.ts). The MCP server itself never
+// calls an LLM — it relies on the host (Claude Code/Desktop, etc.) to reason
+// over the data these tools return. This file exists for people running
+// career-mcp without an MCP-capable client. It always uses YOUR OWN API key —
+// career-mcp never calls a shared/hosted key, so there's no cost or liability
+// on the maintainer's side.
+function getProvider() {
+    const provider = (process.env.CAREER_MCP_LLM_PROVIDER || "groq").toLowerCase();
+    if (provider !== "groq" && provider !== "gemini") {
+        throw new Error(`Unknown CAREER_MCP_LLM_PROVIDER: ${provider}. Use "groq" or "gemini".`);
+    }
+    return provider;
+}
+function getApiKey() {
+    const key = process.env.CAREER_MCP_API_KEY;
+    if (!key) {
+        throw new Error("CAREER_MCP_API_KEY is not set. The standalone CLI needs your own API key " +
+            "(a free-tier Groq or Gemini key both work) — see .env.example.");
+    }
+    return key;
+}
+async function callGroq(systemPrompt, userPrompt) {
+    const model = process.env.CAREER_MCP_LLM_MODEL || "llama-3.3-70b-versatile";
+    const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${getApiKey()}`,
+        },
+        body: JSON.stringify({
+            model,
+            temperature: 0.4,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ],
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`Groq API error (${res.status}): ${await res.text()}`);
+    }
+    const data = await res.json();
+    return data.choices?.[0]?.message?.content ?? "";
+}
+async function callGemini(systemPrompt, userPrompt) {
+    const model = process.env.CAREER_MCP_LLM_MODEL || "gemini-2.0-flash";
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${getApiKey()}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            systemInstruction: { parts: [{ text: systemPrompt }] },
+            contents: [{ parts: [{ text: userPrompt }] }],
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`Gemini API error (${res.status}): ${await res.text()}`);
+    }
+    const data = await res.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
+}
+export async function callLLM(systemPrompt, userPrompt) {
+    const provider = getProvider();
+    return provider === "groq" ? callGroq(systemPrompt, userPrompt) : callGemini(systemPrompt, userPrompt);
+}

package/dist/storage.js

@@ -0,0 +1,150 @@
+import { mkdir, readFile, writeFile, readdir, access } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { PDFParse } from "pdf-parse";
+const DATA_DIR = process.env.CAREER_MCP_DATA_DIR || path.join(os.homedir(), ".career-mcp");
+const STORIES_DIR = path.join(DATA_DIR, "stories");
+const APPLICATIONS_DIR = path.join(DATA_DIR, "applications");
+const RESUME_PATH = path.join(DATA_DIR, "resume.json");
+const VOICE_PROFILE_PATH = path.join(DATA_DIR, "voice_profile.md");
+const ACTIVE_APPLICATION_PATH = path.join(DATA_DIR, "active_application.json");
+async function ensureDirs() {
+    await mkdir(DATA_DIR, { recursive: true });
+    await mkdir(STORIES_DIR, { recursive: true });
+    await mkdir(APPLICATIONS_DIR, { recursive: true });
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export async function readTextFile(filePath) {
+    const expanded = filePath.startsWith("~") ? path.join(os.homedir(), filePath.slice(1)) : filePath;
+    const resolved = path.resolve(expanded);
+    if (resolved.toLowerCase().endsWith(".pdf")) {
+        return readPdfText(resolved);
+    }
+    return readFile(resolved, "utf8");
+}
+async function readPdfText(resolvedPath) {
+    const buffer = await readFile(resolvedPath);
+    const parser = new PDFParse({ data: buffer });
+    try {
+        const result = await parser.getText();
+        return result.text;
+    }
+    finally {
+        await parser.destroy();
+    }
+}
+export async function saveResume(rawText) {
+    await ensureDirs();
+    const resume = { rawText, updatedAt: new Date().toISOString() };
+    await writeFile(RESUME_PATH, JSON.stringify(resume, null, 2), "utf8");
+    return resume;
+}
+export async function getResume() {
+    if (!(await exists(RESUME_PATH)))
+        return null;
+    return JSON.parse(await readFile(RESUME_PATH, "utf8"));
+}
+export async function saveVoiceProfile(text) {
+    await ensureDirs();
+    await writeFile(VOICE_PROFILE_PATH, text, "utf8");
+}
+export async function getVoiceProfile() {
+    if (!(await exists(VOICE_PROFILE_PATH)))
+        return null;
+    return readFile(VOICE_PROFILE_PATH, "utf8");
+}
+export async function saveStory(title, tags, content) {
+    await ensureDirs();
+    const slug = `${slugify(title)}-${Date.now().toString(36)}`;
+    const story = { slug, title, tags, content, createdAt: new Date().toISOString() };
+    const frontmatter = [
+        "---",
+        `title: ${title}`,
+        `tags: ${tags.join(", ")}`,
+        `createdAt: ${story.createdAt}`,
+        "---",
+        "",
+        content,
+    ].join("\n");
+    await writeFile(path.join(STORIES_DIR, `${slug}.md`), frontmatter, "utf8");
+    return story;
+}
+export async function queryStories(tags) {
+    await ensureDirs();
+    const files = (await readdir(STORIES_DIR)).filter((f) => f.endsWith(".md"));
+    const stories = [];
+    for (const file of files) {
+        const raw = await readFile(path.join(STORIES_DIR, file), "utf8");
+        const match = raw.match(/^---\ntitle: (.*)\ntags: (.*)\ncreatedAt: (.*)\n---\n\n([\s\S]*)$/);
+        if (!match)
+            continue;
+        const [, title, tagsLine, createdAt, content] = match;
+        const storyTags = tagsLine.split(",").map((t) => t.trim()).filter(Boolean);
+        stories.push({ slug: file.replace(/\.md$/, ""), title, tags: storyTags, content, createdAt });
+    }
+    if (!tags || tags.length === 0)
+        return stories;
+    const wanted = tags.map((t) => t.toLowerCase());
+    return stories.filter((s) => s.tags.some((t) => wanted.includes(t.toLowerCase())));
+}
+export async function saveJD(company, role, jdText) {
+    await ensureDirs();
+    const slug = slugify(`${company}-${role}`);
+    const appDir = path.join(APPLICATIONS_DIR, slug);
+    await mkdir(path.join(appDir, "outputs"), { recursive: true });
+    const application = { slug, company, role, jdText, createdAt: new Date().toISOString() };
+    await writeFile(path.join(appDir, "jd.json"), JSON.stringify(application, null, 2), "utf8");
+    await writeFile(ACTIVE_APPLICATION_PATH, JSON.stringify({ slug }, null, 2), "utf8");
+    return application;
+}
+export async function getApplication(slug) {
+    const p = path.join(APPLICATIONS_DIR, slug, "jd.json");
+    if (!(await exists(p)))
+        return null;
+    return JSON.parse(await readFile(p, "utf8"));
+}
+export async function getActiveApplication() {
+    if (!(await exists(ACTIVE_APPLICATION_PATH)))
+        return null;
+    const { slug } = JSON.parse(await readFile(ACTIVE_APPLICATION_PATH, "utf8"));
+    return getApplication(slug);
+}
+export async function listApplications() {
+    await ensureDirs();
+    const dirs = await readdir(APPLICATIONS_DIR);
+    const applications = [];
+    for (const dir of dirs) {
+        const application = await getApplication(dir);
+        if (application)
+            applications.push(application);
+    }
+    return applications.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export async function saveOutput(slug, type, content) {
+    const appDir = path.join(APPLICATIONS_DIR, slug, "outputs");
+    await mkdir(appDir, { recursive: true });
+    const filePath = path.join(appDir, `${type}.md`);
+    await writeFile(filePath, content, "utf8");
+    return filePath;
+}
+export async function getOutput(slug, type) {
+    const filePath = path.join(APPLICATIONS_DIR, slug, "outputs", `${type}.md`);
+    if (!(await exists(filePath)))
+        return null;
+    return readFile(filePath, "utf8");
+}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@sindhujaks/career-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.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",
+  "bin": {
+    "career-mcp": "dist/index.js",
+    "career-mcp-cli": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    ".env.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "cli": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "resume",
+    "career",
+    "job-search",
+    "claude",
+    "ai-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sindhujaIBM/career-mcp.git"
+  },
+  "homepage": "https://github.com/sindhujaIBM/career-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/sindhujaIBM/career-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "dotenv": "^16.4.0",
+    "pdf-parse": "^2.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.0"
+  },
+  "license": "MIT"
+}