resume-parser-ats 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dhanush Kandhan
+
+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

@@ -0,0 +1,294 @@
+# 📄 Resume Parser
+
+<p align="center">
+  <strong>Deep resume parsing • ATS compatibility scoring • Actionable improvement insights</strong>
+</p>
+
+<p align="center">
+  Made with ❤️ by <strong>Dhanush Kandhan</strong>
+</p>
+
+---
+
+A powerful agent skill that deeply parses resumes using the **OpenResume 4-step algorithm**, extracts structured information (Name, Email, Phone, Education, Work Experience, Skills, Projects), evaluates ATS (Applicant Tracking System) compatibility, and provides prioritized, actionable suggestions to improve your resume.
+
+## ✨ Features
+
+- **🔍 Deep Parsing** — Extracts 10+ fields from raw text or PDF using a feature-scoring engine
+- **📊 ATS Scoring** — Grades your resume A+ through F with detailed per-field confidence ratings
+- **💡 Smart Suggestions** — Prioritized, categorized fixes (critical → low) with before/after examples
+- **🛠️ CLI & MCP Server** — Use interactively from the command line or as an MCP tool
+- **⚙️ Configurable Strictness** — Lenient, moderate, or strict ATS evaluation modes
+- **🔒 Zero Dependencies on Proprietary APIs** — Runs entirely locally with no external calls
+
+## 📦 Installation
+
+```bash
+# Clone the repo
+git clone https://github.com/dhanushk-offl/resume-parser-skill.git
+cd resume-parser-skill
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+```
+
+## 🚀 Usage
+
+### As a CLI Tool
+
+```bash
+# Parse a resume and output structured data
+npx resume-parser parse resume.pdf
+
+# Parse + analyze ATS compatibility
+npx resume-parser analyze resume.pdf
+
+# Full pipeline: parse + analyze + actionable suggestions
+npx resume-parser insights resume.pdf
+
+# Parse from raw text
+npx resume-parser parse "John Doe\njohn@email.com\nSoftware Engineer"
+
+# Adjust ATS strictness
+npx resume-parser analyze resume.pdf --strictness strict
+
+# Focus on specific areas
+npx resume-parser insights resume.pdf --focus ats,formatting --json
+```
+
+### As a Library
+
+```typescript
+import { parseResume, analyzeResume, suggestImprovements } from "resume-parser-ats";
+
+// Step 1: Parse
+const parsed = parseResume({ rawText: "..." });
+console.log(parsed.data.profile.name);     // "Jane Doe"
+console.log(parsed.data.profile.email);    // "jane@example.com"
+console.log(parsed.data.education[0]?.school);  // "MIT"
+
+// Step 2: Analyze ATS compatibility
+const analysis = analyzeResume({
+  rawText: "...",
+  parsedResume: parsed.data,
+  strictness: "moderate",
+});
+console.log(analysis.data.atsScore);  // 72
+console.log(analysis.data.atsGrade);  // "B-"
+
+// Step 3: Get improvement suggestions
+const suggestions = suggestImprovements({
+  rawText: "...",
+  parsedResume: parsed.data,
+  analysisResult: analysis.data,
+  focusAreas: ["ats", "content", "formatting", "structure"],
+});
+console.log(suggestions.data.quickWins);           // ["Fix your name format...", ...]
+console.log(suggestions.data.suggestions[0].title); // "Name is not parseable by ATS"
+```
+
+### As an MCP Server
+
+```bash
+npm run mcp
+```
+
+Starts a Model Context Protocol server exposing three tools:
+
+| Tool | Description |
+|------|-------------|
+| `parse_resume` | Parse a resume PDF or raw text and return structured data |
+| `analyze_resume` | Parse + compute ATS compatibility score with per-field confidence |
+| `suggest_improvements` | Parse + analyze + generate prioritized improvement suggestions |
+
+## 🧠 How It Works: The 4-Step Algorithm
+
+The parser follows the **OpenResume algorithm**, a proven methodology used by real ATS systems:
+
+### Step 1 — Read Text Items
+
+Extracts all text items from the resume, including:
+- Text content
+- X/Y positions (relative to bottom-left origin)
+- Bold metadata
+- Newline markers
+
+### Step 2 — Group Into Lines
+
+Merges adjacent text items on the same Y-coordinate when their horizontal distance is less than the average character width. Groups by Y-coordinate to reconstruct the line-by-line reading order.
+
+### Step 3 — Group Into Sections
+
+Detects section titles using two heuristics:
+1. **Primary**: Only text item in line + bold + ALL UPPERCASE
+2. **Fallback**: Keyword match against known headers (EDUCATION, EXPERIENCE, SKILLS, etc.)
+
+### Step 4 — Extract Attributes via Feature Scoring
+
+Each attribute (Name, Email, Phone, etc.) has **feature sets** — matching functions with positive/negative scores. The text item with the highest total score wins. This is how real ATS systems rank candidates:
+
+| Feature (Name) | Score | Feature (Email) | Score |
+|---|---|---|---|
+| Contains only letters/spaces/periods | +3 | Matches email regex | +4 |
+| Is bolded | +2 | Contains @ symbol | +4 |
+| Is ALL UPPERCASE | +2 | Looks like a name (no @) | -1 |
+| Contains @ (probably email) | -4 | Contains digits (no @) | -2 |
+| Contains numbers (probably phone) | -4 | — | — |
+
+## 📊 Use Cases
+
+### 1. 🎯 Job Seeker — ATS Optimization
+
+> *Before applying to jobs, run your resume through the parser to see what an ATS actually extracts.*
+
+```bash
+npx resume-parser insights my-resume.pdf --strictness strict --json
+```
+
+Identify critical issues like a missing email, unparseable name, or sections an ATS can't detect — and fix them *before* you apply.
+
+### 2. 🏢 Recruiter — Bulk Resume Screening
+
+> *Programmatically parse and score hundreds of resumes to rank candidates by ATS readability.*
+
+```typescript
+import { parseResume, analyzeResume } from "resume-parser-ats";
+import fs from "fs";
+
+const files = fs.readdirSync("resumes/");
+for (const file of files) {
+  const parsed = parseResume({ filePath: `resumes/${file}` });
+  const analysis = analyzeResume({
+    filePath: `resumes/${file}`,
+    parsedResume: parsed.data,
+    strictness: "moderate",
+  });
+  console.log(`${file}: ATS Score ${analysis.data.atsScore}/100 (${analysis.data.atsGrade})`);
+}
+```
+
+### 3. 🤖 Agent Integration — AI-Powered Resume Coach
+
+> *Embed the skill into an AI agent that reviews resumes and gives personalized coaching.*
+
+```typescript
+import { fullPipeline } from "resume-parser-ats";
+
+const result = fullPipeline({ rawText: resumeText, strictness: "strict" });
+
+// result.parsed — structured data
+// result.analyzed — ATS score + field analysis
+// result.suggestions — prioritized actions
+
+// Feed to an LLM for natural-language coaching
+const prompt = `You are a resume coach. Here is the analysis:
+${JSON.stringify(result.analyzed.data)}
+Suggest improvements in a friendly, encouraging tone.`;
+```
+
+### 4. 📈 Career Platform — Resume Health Dashboard
+
+> *Show users a "resume health score" on your career platform dashboard.*
+
+- Parse on upload → store `atsScore`, `atsGrade`, and `fieldAnalyses`
+- Display a visual dashboard with color-coded field ratings
+- Surface `quickWins` as a checklist
+- Track score improvements over time as users update their resumes
+
+### 5. 🎓 University Career Center — Student Resume Reviews
+
+> *Automate initial resume screening for career centers at scale.*
+
+- Batch-parse student resumes and generate summary reports
+- Flag common issues (missing dates, non-standard section headers)
+- Provide standardized improvement templates
+
+### 6. 🔄 Resume Migration Tool
+
+> *Convert resumes from one format to structured JSON for database ingestion.*
+
+```typescript
+import { parseResume } from "resume-parser-ats";
+
+const result = parseResume({ filePath: "legacy-resume.pdf" });
+// result.data is a clean, typed JSON object ready for your database
+```
+
+## 🏗️ Architecture
+
+```
+resume-parser/
+├── package.json              # Project metadata & scripts
+├── README.md                 # This file
+├── LICENSE                   # MIT License — Dhanush Kandhan
+├── AGENTS.md                 # Agent-facing configuration
+├── SKILL.md                  # Skill definition for agent consumption
+├── src/
+│   ├── index.ts              # Main entry point + fullPipeline()
+│   ├── tools/
+│   │   ├── parse-resume.ts           # Step 1-4 parsing engine
+│   │   ├── analyze-resume.ts         # ATS scoring & analysis
+│   │   └── suggest-improvements.ts   # Fix suggestions generator
+│   └── prompts/
+│       ├── parser-prompt.ts          # Prompt templates for parsing
+│       └── insights-prompt.ts        # Prompt templates for insights
+├── mcp-server/
+│   └── server.ts             # MCP server implementation
+├── bin/
+│   └── cli.js                # CLI entry point
+└── test/
+    └── evals/                # Evaluation test suites
+        ├── parse-resume.test.js
+        ├── analyze-resume.test.js
+        └── suggest-improvements.test.js
+```
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run evaluation suites
+node --test test/evals/parse-resume.test.js
+node --test test/evals/analyze-resume.test.js
+node --test test/evals/suggest-improvements.test.js
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## ☁️ CI/CD
+
+This project uses GitHub Actions for continuous integration and npm publishing:
+
+| Workflow | Trigger | What it does |
+|----------|---------|-------------|
+| **Build & Test** | Push/PR to `master` | Lint, build, and test across Node 18/20/22 |
+| **Publish to npm** | Tag push `v*` (e.g. `v1.0.0`) | Builds and publishes to npmjs with provenance |
+
+To publish a new version:
+
+```bash
+npm version patch   # or minor, major
+git push --follow-tags
+```
+
+## 📄 License
+
+MIT License — Copyright (c) 2025 **Dhanush Kandhan**. See [LICENSE](./LICENSE) for details.
+
+---
+
+<p align="center">
+  Made with ❤️ by <strong>Dhanush Kandhan</strong><br>
+  <em>If this project helped you, consider giving it a ⭐ on GitHub!</em>
+</p>

package/bin/cli.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+/**
+ * Resume Parser — CLI Entry Point
+ *
+ * Usage:
+ *   resume-parser parse <file|text>          Parse a resume and output structured data
+ *   resume-parser analyze <file|text>         Parse + analyze ATS compatibility
+ *   resume-parser insights <file|text>       Full pipeline: parse + analyze + suggestions
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { parseResume } = require("../dist/src/tools/parse-resume");
+const { analyzeResume } = require("../dist/src/tools/analyze-resume");
+const { suggestImprovements } = require("../dist/src/tools/suggest-improvements");
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+
+function printUsage() {
+  console.log(`
+Resume Parser CLI — Deep resume parsing with ATS insights
+
+Usage:
+  resume-parser <command> <input> [options]
+
+Commands:
+  parse <file|text>       Parse a resume and output structured data
+  analyze <file|text>     Parse + analyze ATS compatibility
+  insights <file|text>    Full pipeline: parse + analyze + suggestions
+
+Options:
+  --strictness <level>    ATS strictness: lenient, moderate, strict (default: moderate)
+  --focus <areas>         Focus areas: ats,content,formatting,structure (default: all)
+  --json                  Output raw JSON instead of formatted report
+  --help                  Show this help message
+
+Examples:
+  resume-parser parse resume.pdf
+  resume-parser analyze resume.pdf --strictness strict
+  resume-parser insights resume.pdf --focus ats,formatting --json
+  resume-parser parse "John Doe\\njohn@email.com\\nSoftware Engineer"
+`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const command = args[0];
+  const inputArg = args[1];
+
+  if (!inputArg) {
+    console.error("Error: Please provide a file path or text input.");
+    printUsage();
+    process.exit(1);
+  }
+
+  // Parse options
+  const strictnessIdx = args.indexOf("--strictness");
+  const strictness = strictnessIdx >= 0 ? args[strictnessIdx + 1] : "moderate";
+
+  const focusIdx = args.indexOf("--focus");
+  const focusAreas = focusIdx >= 0
+    ? args[focusIdx + 1].split(",")
+    : ["ats", "content", "formatting", "structure"];
+
+  const jsonOutput = args.includes("--json");
+
+  // Determine input type: file path or raw text
+  let filePath;
+  let rawText;
+
+  if (fs.existsSync(inputArg)) {
+    filePath = path.resolve(inputArg);
+  } else {
+    rawText = inputArg.replace(/\\n/g, "\n");
+  }
+
+  // Execute command
+  switch (command) {
+    case "parse": {
+      const result = parseResume({ filePath, rawText });
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        printParseResult(result);
+      }
+      break;
+    }
+
+    case "analyze": {
+      const parsed = parseResume({ filePath, rawText });
+      const analyzed = analyzeResume({
+        filePath,
+        rawText,
+        parsedResume: parsed.data,
+        strictness,
+      });
+      if (jsonOutput) {
+        console.log(JSON.stringify(analyzed, null, 2));
+      } else {
+        printAnalysisResult(analyzed);
+      }
+      break;
+    }
+
+    case "insights": {
+      const parsed = parseResume({ filePath, rawText });
+      const analyzed = analyzeResume({
+        filePath,
+        rawText,
+        parsedResume: parsed.data,
+        strictness,
+      });
+      const suggestions = suggestImprovements({
+        filePath,
+        rawText,
+        parsedResume: parsed.data,
+        analysisResult: analyzed.data,
+        focusAreas,
+      });
+      if (jsonOutput) {
+        console.log(JSON.stringify(suggestions, null, 2));
+      } else {
+        printInsightsResult(suggestions);
+      }
+      break;
+    }
+
+    default:
+      console.error("Unknown command: " + command);
+      printUsage();
+      process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Formatted output helpers
+// ---------------------------------------------------------------------------
+
+function printParseResult(result) {
+  if (!result.success) {
+    console.log("❌ Failed to parse resume");
+    console.log("Warnings:", result.metadata.warnings.join(", "));
+    return;
+  }
+
+  const { profile, education, experience, skills, projects } = result.data;
+
+  console.log("\n📄 Resume Parsing Results\n");
+  console.log("━".repeat(50));
+
+  // Profile
+  console.log("\n✨ Profile");
+  console.log("─".repeat(30));
+  console.log("  Name:      " + (profile.name || "Not parsed"));
+  console.log("  Email:     " + (profile.email || "Not parsed"));
+  console.log("  Phone:     " + (profile.phone || "Not parsed"));
+  console.log("  Location:  " + (profile.location || "Not parsed"));
+  console.log("  Link:      " + (profile.url || "Not parsed"));
+
+  if (profile.summary) {
+    console.log("  Summary:   " + profile.summary);
+  }
+
+  // Education
+  if (education.length > 0) {
+    console.log("\n🎓 Education");
+    console.log("─".repeat(30));
+    for (const edu of education) {
+      console.log("  School:       " + (edu.school || "Not parsed"));
+      console.log("  Degree:       " + (edu.degree || "Not parsed"));
+      console.log("  GPA:          " + (edu.gpa || "Not parsed"));
+      console.log("  Date:         " + (edu.date || "Not parsed"));
+      if (edu.descriptions.length > 0) {
+        console.log("  Descriptions: " + edu.descriptions.join("; "));
+      }
+      console.log();
+    }
+  }
+
+  // Work Experience
+  if (experience.length > 0) {
+    console.log("💼 Work Experience");
+    console.log("─".repeat(30));
+    for (const exp of experience) {
+      console.log("  Company:      " + (exp.company || "Not parsed"));
+      console.log("  Job Title:    " + (exp.jobTitle || "Not parsed"));
+      console.log("  Date:         " + (exp.date || "Not parsed"));
+      if (exp.descriptions.length > 0) {
+        console.log("  Descriptions:");
+        for (const d of exp.descriptions) {
+          console.log("    • " + d);
+        }
+      }
+      console.log();
+    }
+  }
+
+  // Skills
+  if (skills.length > 0) {
+    console.log("🛠️  Skills");
+    console.log("─".repeat(30));
+    for (const skill of skills) {
+      for (const d of skill.descriptions) {
+        console.log("  • " + d);
+      }
+    }
+  }
+
+  // Projects
+  if (projects.length > 0) {
+    console.log("\n🚀 Projects");
+    console.log("─".repeat(30));
+    for (const proj of projects) {
+      console.log("  Name:         " + (proj.name || "Not parsed"));
+      console.log("  Date:         " + (proj.date || "Not parsed"));
+      if (proj.descriptions.length > 0) {
+        console.log("  Descriptions:");
+        for (const d of proj.descriptions) {
+          console.log("    • " + d);
+        }
+      }
+      console.log();
+    }
+  }
+
+  // Metadata
+  console.log("\n" + "━".repeat(50));
+  console.log("Steps completed: " + result.metadata.stepsCompleted.join(" → "));
+  if (result.metadata.warnings.length > 0) {
+    console.log("Warnings: " + result.metadata.warnings.join(", "));
+  }
+}
+
+function printAnalysisResult(result) {
+  if (!result.success) {
+    console.log("❌ Failed to analyze resume");
+    return;
+  }
+
+  const { atsScore, atsGrade, fieldAnalyses, sectionAnalyses, overallNotes, formatIssues } = result.data;
+
+  console.log("\n📊 Resume Analysis Report\n");
+  console.log("━".repeat(50));
+  console.log("\n🎯 ATS Compatibility Score: " + atsScore + "/100 (Grade: " + atsGrade + ")\n");
+
+  // Field analyses
+  console.log("📋 Field Extraction Analysis");
+  console.log("─".repeat(40));
+  for (const field of fieldAnalyses) {
+    let icon = "❌";
+    if (field.confidence === "high") icon = "✅";
+    else if (field.confidence === "medium") icon = "⚠️";
+    else if (field.confidence === "low") icon = "🔶";
+    const val = field.value || "Not parsed";
+    console.log("  " + icon + " " + field.field.padEnd(12) + " | " + val.padEnd(30) + " | " + field.confidence);
+  }
+
+  // Section analyses
+  console.log("\n📑 Section Detection");
+  console.log("─".repeat(40));
+  for (const section of sectionAnalyses) {
+    const icon = section.detected ? "✅" : "❌";
+    const issues = section.issues.length > 0 ? section.issues.join(", ") : "OK";
+    console.log("  " + icon + " " + section.section.padEnd(25) + " | Lines: " + section.lineCount + " | " + issues);
+  }
+
+  // Format issues
+  if (formatIssues.length > 0) {
+    console.log("\n⚠️  Format Issues");
+    console.log("─".repeat(40));
+    for (const issue of formatIssues) {
+      let severityIcon = "🟢";
+      if (issue.severity === "critical") severityIcon = "🔴";
+      else if (issue.severity === "high") severityIcon = "🟠";
+      else if (issue.severity === "medium") severityIcon = "🟡";
+      console.log("  " + severityIcon + " [" + issue.severity.toUpperCase() + "] " + issue.description);
+      console.log("     Affected: " + issue.affectedFields.join(", "));
+      console.log("     Fix: " + issue.suggestion);
+    }
+  }
+
+  // Overall notes
+  console.log("\n📝 Overall Notes");
+  console.log("─".repeat(40));
+  for (const note of overallNotes) {
+    console.log("  • " + note);
+  }
+
+  console.log("\n" + "━".repeat(50));
+}
+
+function printInsightsResult(result) {
+  const { overallScore, overallGrade, criticalFixes, totalSuggestions, suggestions, sectionSuggestions, quickWins, longTermAdvice } = result.data;
+
+  console.log("\n🔍 Resume Insights Report\n");
+  console.log("━".repeat(50));
+  console.log("\n🎯 ATS Compatibility Score: " + overallScore + "/100 (Grade: " + overallGrade + ")");
+  console.log("🔴 Critical fixes needed: " + criticalFixes);
+  console.log("📝 Total suggestions: " + totalSuggestions + "\n");
+
+  // Quick wins
+  if (quickWins.length > 0) {
+    console.log("⚡ Quick Wins (fix these first):");
+    console.log("─".repeat(40));
+    for (let i = 0; i < quickWins.length; i++) {
+      console.log("  " + (i + 1) + ". " + quickWins[i]);
+    }
+    console.log();
+  }
+
+  // All suggestions
+  if (suggestions.length > 0) {
+    console.log("📋 All Suggestions (sorted by priority):");
+    console.log("─".repeat(40));
+    for (const sug of suggestions) {
+      let icon = "🟢";
+      if (sug.priority === "critical") icon = "🔴";
+      else if (sug.priority === "high") icon = "🟠";
+      else if (sug.priority === "medium") icon = "🟡";
+      console.log("\n  " + icon + " [" + sug.priority.toUpperCase() + "] " + sug.title);
+      console.log("     Field: " + sug.field);
+      console.log("     Issue: " + sug.description);
+      console.log("     Current: " + (sug.currentValue || "Not parsed"));
+      console.log("     Suggested: " + sug.suggestedValue);
+      console.log("     Why: " + sug.rationale);
+    }
+    console.log();
+  }
+
+  // Section suggestions
+  console.log("📑 Section Status:");
+  console.log("─".repeat(40));
+  for (const section of sectionSuggestions) {
+    const icon = section.present ? "✅" : "❌";
+    console.log("  " + icon + " " + section.section);
+    if (section.issues.length > 0) {
+      for (const issue of section.issues) {
+        console.log("     ⚠️  " + issue);
+      }
+    }
+    if (section.recommendations.length > 0) {
+      for (const rec of section.recommendations) {
+        console.log("     💡 " + rec);
+      }
+    }
+  }
+
+  // Long-term advice
+  console.log("\n🌟 Long-term Improvement Advice:");
+  console.log("─".repeat(40));
+  for (const advice of longTermAdvice) {
+    console.log("  • " + advice);
+  }
+
+  console.log("\n" + "━".repeat(50));
+}
+
+// Run
+main();

package/dist/mcp-server/server.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resume Parser — MCP Server
+ *
+ * Exposes the resume parsing, analysis, and suggestion tools
+ * via the Model Context Protocol (MCP).
+ *
+ * Tools:
+ *   - parse_resume: Parse a resume PDF/text and return structured data
+ *   - analyze_resume: Parse + compute ATS compatibility score
+ *   - suggest_improvements: Generate actionable fix suggestions
+ *
+ * Usage:
+ *   npm run mcp
+ *
+ * The server communicates via stdio using the MCP protocol.
+ */
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp-server/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../mcp-server/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}