@vibecodeqa/mcp 0.2.0

package/README.md

@@ -0,0 +1,91 @@
+# @vibecodeqa/mcp
+
+MCP server for VibeCode QA — gives AI coding agents real-time code health context.
+
+When an AI agent writes or modifies code, it can query vcqa to check: "Is this file healthy? What patterns should I follow? Will this change degrade quality?"
+
+## Quick start
+
+### Claude Code
+
+```bash
+claude mcp add vcqa -- npx @vibecodeqa/mcp
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "vcqa": {
+      "command": "npx",
+      "args": ["@vibecodeqa/mcp"]
+    }
+  }
+}
+```
+
+### Cursor / other MCP clients
+
+```bash
+npx @vibecodeqa/mcp
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `vcqa_score` | Quick score + grade + check summary (uses cache) |
+| `vcqa_scan` | Full scan — all 34 checks with issues and details |
+| `vcqa_file_health` | Issues for a specific file (use before/after editing) |
+| `vcqa_check` | Detailed results for one check (e.g., "complexity") |
+| `vcqa_explain` | What a check measures, why it matters, how to fix |
+| `vcqa_fix` | AI-powered fix for code issues (needs ANTHROPIC_API_KEY) |
+| `vcqa_delta` | Compare current scan vs previous — shows fixed/new issues |
+
+## How agents use it
+
+**Before modifying a file:**
+```
+→ vcqa_file_health({ file: "src/auth.ts" })
+← 3 issues: complexity 28 (max 15), empty catch block, no test file
+```
+The agent now knows to simplify the function, add error handling, and write a test.
+
+**After generating code:**
+```
+→ vcqa_score()
+← B 78/100 (was B 80 — dropped 2 pts)
+→ vcqa_check({ check: "security" })
+← 1 new issue: innerHTML assignment in src/dashboard.tsx:42
+```
+The agent fixes the security issue before committing.
+
+**After a fix session:**
+```
+→ vcqa_delta()
+← Score: C 64 → B 80 (+16)
+  Fixed: 89 issues | New: 3 issues
+  +73 confusion (0 → 73), +55 lint (45 → 100), +12 standards (36 → 48)
+```
+
+**Understanding a check:**
+```
+→ vcqa_explain({ check: "confusion" })
+← Measures naming ambiguity that causes LLMs to edit the wrong file...
+```
+
+## Performance
+
+- Uses cached `report.json` from previous CLI runs (< 5 min old)
+- Falls back to live scan via `npx @vibecodeqa/cli --skip-tests --json`
+- In-memory cache with 60s TTL prevents redundant scans
+- Typical response: < 100ms (cached), 3-8s (live scan)
+
+## Links
+
+- [VibeCode QA CLI](https://www.npmjs.com/package/@vibecodeqa/cli)
+- [Website](https://vibecodeqa.online)
+- [GitHub](https://github.com/vibecodeqa/mcp)

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * VibeCode QA MCP Server
+ *
+ * Gives AI coding agents real-time code health context.
+ * Tools:
+ *   vcqa_score       — Quick score + grade (fastest, uses cache)
+ *   vcqa_scan        — Full scan with all 25 check results
+ *   vcqa_file_health — Get issues for a specific file
+ *   vcqa_check       — Get details for a specific check
+ *   vcqa_explain     — Explain what a check measures and how to fix it
+ *   vcqa_fix         — AI-powered fix for code issues (needs ANTHROPIC_API_KEY)
+ *
+ * Usage:
+ *   npx @vibecodeqa/mcp                  # stdio transport (for Claude Code, Cursor, etc.)
+ *   Add to claude_desktop_config.json:
+ *   { "mcpServers": { "vcqa": { "command": "npx", "args": ["@vibecodeqa/mcp"] } } }
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+/**
+ * VibeCode QA MCP Server
+ *
+ * Gives AI coding agents real-time code health context.
+ * Tools:
+ *   vcqa_score       — Quick score + grade (fastest, uses cache)
+ *   vcqa_scan        — Full scan with all 25 check results
+ *   vcqa_file_health — Get issues for a specific file
+ *   vcqa_check       — Get details for a specific check
+ *   vcqa_explain     — Explain what a check measures and how to fix it
+ *   vcqa_fix         — AI-powered fix for code issues (needs ANTHROPIC_API_KEY)
+ *
+ * Usage:
+ *   npx @vibecodeqa/mcp                  # stdio transport (for Claude Code, Cursor, etc.)
+ *   Add to claude_desktop_config.json:
+ *   { "mcpServers": { "vcqa": { "command": "npx", "args": ["@vibecodeqa/mcp"] } } }
+ */
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+// Check metadata — embedded to avoid shelling out for explain
+const CHECK_META = {
+    structure: { label: "Project Structure", category: "Foundations", weight: 6, description: "Checks for standard project files: package.json, tsconfig.json, LICENSE, README, .gitignore, lockfile. Verifies test-to-source ratio.", risk: "Missing config files cause build failures in CI. No lockfile means non-reproducible builds.", recommendation: "Ensure every project has package.json, tsconfig.json, LICENSE, .gitignore, and a lockfile." },
+    lint: { label: "Lint", category: "Foundations", weight: 5, description: "Runs the project's linter (Biome or ESLint) and counts errors and warnings.", risk: "Unlinted code accumulates inconsistencies and latent bugs.", recommendation: "Fix all lint errors. Add Biome if no linter configured." },
+    types: { label: "Type Check", category: "Foundations", weight: 6, description: "Runs tsc --noEmit to find TypeScript compilation errors.", risk: "Type errors are bugs — every unresolved error is a potential runtime crash.", recommendation: "Fix all type errors. Enable strict mode." },
+    "type-safety": { label: "Type Safety", category: "Foundations", weight: 3, description: "Counts unsafe type patterns: 'as any', ': any', @ts-ignore, non-null assertions.", risk: "'as any' silences the type checker. Accumulated any usage correlates with higher defect density.", recommendation: "Replace 'as any' with proper types or type guards." },
+    standards: { label: "Code Standards", category: "Foundations", weight: 3, description: "Checks naming conventions, file size, code smells (console.log, var, ==, eval).", risk: "Large files are hard to review. console.log in production leaks data.", recommendation: "Split files over 300 lines. Use const/let, ===, and safe DOM APIs." },
+    complexity: { label: "Complexity", category: "Quality", weight: 5, description: "Measures cognitive complexity per function.", risk: "Complex functions are the #1 source of bugs.", recommendation: "Extract complex functions into smaller ones. Use early returns." },
+    duplication: { label: "Duplication", category: "Quality", weight: 5, description: "Detects copy-pasted code blocks of 6+ lines.", risk: "Duplicated code means bugs must be fixed in multiple places.", recommendation: "Extract duplicated logic into shared functions." },
+    "error-handling": { label: "Error Handling", category: "Quality", weight: 3, description: "Detects empty catch, throw string, floating promises, unsafe JSON.parse.", risk: "Empty catch blocks silently swallow errors.", recommendation: "Handle or log every catch. Use throw new Error()." },
+    react: { label: "React Patterns", category: "Quality", weight: 3, description: "Checks conditional hooks, missing keys, index as key, prop spreading.", risk: "Conditional hooks crash React. Missing keys cause incorrect reconciliation.", recommendation: "Never call hooks inside conditions. Always provide stable keys." },
+    accessibility: { label: "Accessibility", category: "Quality", weight: 4, description: "Checks img alt, click handlers without keyboard, unlabeled forms.", risk: "1 in 4 adults has a disability.", recommendation: "Add alt text. Use <button> for clickable elements." },
+    docs: { label: "Documentation", category: "Quality", weight: 3, description: "Checks README quality and JSDoc coverage.", risk: "Undocumented code is hard to onboard to.", recommendation: "Write README with install/usage. Add JSDoc to public exports." },
+    "best-practices": { label: "Best Practices", category: "Quality", weight: 3, description: "CI/CD, supply chain, OIDC, pinned actions, SECURITY.md, CODEOWNERS.", risk: "Missing CI practices lead to supply chain attacks.", recommendation: "Pin actions to SHA. Use OIDC. Add SECURITY.md." },
+    testing: { label: "Testing", category: "Testing", weight: 15, description: "Test pyramid, execution, coverage, file pairing, quality metrics.", risk: "Code without tests is code you can't safely change.", recommendation: "Follow testing pyramid. Aim for >80% branch coverage." },
+    secrets: { label: "Secrets", category: "Security", weight: 6, description: "Scans for hardcoded secrets: AWS, GitHub, Stripe, OpenAI keys. Delegates to gitleaks.", risk: "Hardcoded secrets are the #1 cause of credential leaks.", recommendation: "Use environment variables or a secret manager." },
+    security: { label: "Security Patterns", category: "Security", weight: 5, description: "31 CWE patterns: XSS, injection, weak crypto, prototype pollution, path traversal.", risk: "These patterns represent OWASP Top 10 vulnerabilities.", recommendation: "Replace innerHTML with textContent. Never use eval(). Use parameterized queries." },
+    dependencies: { label: "Dependencies", category: "Security", weight: 5, description: "npm audit for CVEs, outdated package detection.", risk: "Vulnerable dependencies are the most common supply chain attack vector.", recommendation: "Run audit regularly. Use Dependabot or Renovate." },
+    architecture: { label: "Architecture", category: "Architecture", weight: 5, description: "Circular deps, god modules, orphans, fan-out, import graph analysis.", risk: "Circular deps make refactoring impossible. God modules become bottlenecks.", recommendation: "Break circular deps. Split god modules by concern." },
+    performance: { label: "Performance", category: "Architecture", weight: 4, description: "Barrel imports, heavy deps, dynamic import opportunities, CSS-in-JS overhead.", risk: "Barrel files prevent tree-shaking, bloating bundles 2-10x.", recommendation: "Replace barrel re-exports with direct imports." },
+    confusion: { label: "Confusion Index", category: "LLM Readiness", weight: 6, description: "Naming ambiguity that causes LLMs to misunderstand code.", risk: "LLMs drop 28.6% on code tasks when names are ambiguous.", recommendation: "Use descriptive, unique names. Avoid synonym files." },
+    context: { label: "Context Locality", category: "LLM Readiness", weight: 5, description: "Token density, import depth, circular dep impact on LLM navigation.", risk: "Files over 4000 tokens exceed the LLM attention sweet spot.", recommendation: "Keep files under 400 lines. Limit imports to <15 per file." },
+    "doc-coherence": { label: "Doc Coherence", category: "AI Analysis", weight: 0, description: "LLM-powered: stale README claims, incorrect JSDoc, outdated CHANGELOG.", risk: "Stale docs actively mislead developers and LLMs.", recommendation: "Pro feature — set VCQA_PRO_KEY." },
+    "code-coherence": { label: "Code Coherence", category: "AI Analysis", weight: 0, description: "LLM-powered: inconsistent validation, conflicting defaults, naming drift.", risk: "Incoherent codebases cause 'works on my machine' bugs.", recommendation: "Pro feature — set VCQA_PRO_KEY." },
+    "comment-staleness": { label: "Comment Staleness", category: "AI Analysis", weight: 0, description: "Stale TODOs, numeric mismatches, commented-out code, @deprecated without replacement.", risk: "Stale comments mislead developers and AI agents.", recommendation: "Delete old TODOs. Remove commented-out code." },
+    "dead-patterns": { label: "Dead Patterns", category: "AI Analysis", weight: 0, description: "Leftover code from incomplete refactors: fallbacks, parallel impls, dead guards.", risk: "Vibe-coded projects accumulate dead patterns fast.", recommendation: "Pro feature — set VCQA_PRO_KEY." },
+    "test-audit": { label: "Test Audit", category: "AI Analysis", weight: 0, description: "Fake/shallow tests: empty bodies, trivial assertions, mock abuse.", risk: "AI-generated tests often look real but test nothing.", recommendation: "Pro feature — set VCQA_PRO_KEY." },
+};
+// Cache scan results to avoid re-scanning on every tool call
+let cachedReport = null;
+let cachedCwd = null;
+let cachedAt = 0;
+const CACHE_TTL = 60_000; // 1 minute
+function runScan(cwd) {
+    const now = Date.now();
+    if (cachedReport && cachedCwd === cwd && now - cachedAt < CACHE_TTL) {
+        return cachedReport;
+    }
+    // Try reading cached report.json first (from previous CLI run)
+    const reportPath = join(cwd, ".vibe-check", "report.json");
+    if (existsSync(reportPath)) {
+        try {
+            const stat = statSync(reportPath);
+            if (now - stat.mtimeMs < 300_000) {
+                const report = JSON.parse(readFileSync(reportPath, "utf-8"));
+                cachedReport = report;
+                cachedCwd = cwd;
+                cachedAt = now;
+                return report;
+            }
+        }
+        catch { /* fall through to live scan */ }
+    }
+    // Run live scan
+    try {
+        const stdout = execSync("npx @vibecodeqa/cli --skip-tests --json .", {
+            cwd,
+            encoding: "utf-8",
+            timeout: 60_000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const report = JSON.parse(stdout);
+        cachedReport = report;
+        cachedCwd = cwd;
+        cachedAt = now;
+        return report;
+    }
+    catch (err) {
+        throw new Error(`vcqa scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+const server = new McpServer({
+    name: "vcqa",
+    version: "0.2.0",
+});
+// ── Tool: vcqa_score ──
+server.tool("vcqa_score", "Get the code health score and grade for the current project. Fast — uses cached results when available.", { path: z.string().optional().describe("Project directory path (defaults to cwd)") }, async ({ path }) => {
+    const cwd = path || process.cwd();
+    const report = runScan(cwd);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    score: report.score,
+                    grade: report.grade,
+                    summary: `${report.grade} ${report.score}/100`,
+                    checks: report.checks.map(c => ({
+                        name: c.name,
+                        score: c.score,
+                        grade: c.grade,
+                        issues: c.issues.length,
+                    })),
+                }, null, 2),
+            }],
+    };
+});
+// ── Tool: vcqa_scan ──
+server.tool("vcqa_scan", "Run a full code health scan. Returns score, grade, and all 25 check results with issues. Use vcqa_score for a quicker summary.", { path: z.string().optional().describe("Project directory path (defaults to cwd)") }, async ({ path }) => {
+    const cwd = path || process.cwd();
+    const report = runScan(cwd);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(report, null, 2),
+            }],
+    };
+});
+// ── Tool: vcqa_file_health ──
+server.tool("vcqa_file_health", "Get all code health issues for a specific file. Use before modifying a file to understand existing problems, or after to check for new issues.", {
+    file: z.string().describe("File path relative to project root (e.g., 'src/auth.ts')"),
+    path: z.string().optional().describe("Project directory path (defaults to cwd)"),
+}, async ({ file, path }) => {
+    const cwd = path || process.cwd();
+    const report = runScan(cwd);
+    const fileIssues = [];
+    for (const c of report.checks) {
+        for (const i of c.issues) {
+            if (i.file && (i.file === file || i.file.endsWith(`/${file}`) || file.endsWith(i.file))) {
+                fileIssues.push({ check: c.name, severity: i.severity, message: i.message, line: i.line, rule: i.rule });
+            }
+        }
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    file,
+                    issues: fileIssues.length,
+                    details: fileIssues,
+                    advice: fileIssues.length === 0
+                        ? "No issues found for this file."
+                        : `${fileIssues.length} issues found. Fix errors first, then warnings.`,
+                }, null, 2),
+            }],
+    };
+});
+// ── Tool: vcqa_check ──
+server.tool("vcqa_check", "Get detailed results for a specific check (e.g., 'complexity', 'security', 'testing'). Shows score, issues, and metadata.", {
+    check: z.string().describe("Check name (e.g., 'complexity', 'security', 'testing', 'architecture')"),
+    path: z.string().optional().describe("Project directory path (defaults to cwd)"),
+}, async ({ check, path }) => {
+    const cwd = path || process.cwd();
+    const report = runScan(cwd);
+    const c = report.checks.find(ch => ch.name === check);
+    if (!c) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: `Unknown check: ${check}`, available: report.checks.map(ch => ch.name) }, null, 2),
+                }],
+        };
+    }
+    const meta = CHECK_META[check];
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    name: c.name,
+                    label: meta?.label || c.name,
+                    score: c.score,
+                    grade: c.grade,
+                    category: meta?.category,
+                    weight: meta ? `${meta.weight}%` : undefined,
+                    details: c.details,
+                    issues: c.issues,
+                    recommendation: meta?.recommendation,
+                }, null, 2),
+            }],
+    };
+});
+// ── Tool: vcqa_explain ──
+server.tool("vcqa_explain", "Explain what a specific check measures, why it matters, and how to fix issues. Use to understand WHY a check is flagging something.", {
+    check: z.string().describe("Check name to explain (e.g., 'confusion', 'context', 'architecture')"),
+}, async ({ check }) => {
+    const meta = CHECK_META[check];
+    if (!meta) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: `Unknown check: ${check}`, available: Object.keys(CHECK_META) }, null, 2),
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    name: check,
+                    label: meta.label,
+                    category: meta.category,
+                    weight: `${meta.weight}%`,
+                    what: meta.description,
+                    risk: meta.risk,
+                    fix: meta.recommendation,
+                }, null, 2),
+            }],
+    };
+});
+// ── Tool: vcqa_fix ──
+server.tool("vcqa_fix", "AI-powered fix for code quality issues. Scans the project, identifies fixable issues, and uses Claude to generate and apply fixes. Requires ANTHROPIC_API_KEY env var.", {
+    path: z.string().optional().describe("Project directory path (defaults to cwd)"),
+    check: z.string().optional().describe("Only fix issues from a specific check (e.g., 'security')"),
+    dryRun: z.boolean().optional().describe("Preview fixes without applying (default: false)"),
+}, async ({ path, check, dryRun }) => {
+    const cwd = path || process.cwd();
+    const flags = ["fix", "--ai"];
+    if (check)
+        flags.push("--check", check);
+    if (dryRun)
+        flags.push("--dry-run");
+    flags.push(cwd);
+    try {
+        const stdout = execSync(`npx @vibecodeqa/cli ${flags.join(" ")}`, {
+            cwd,
+            encoding: "utf-8",
+            timeout: 120_000,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env },
+        });
+        // Invalidate cache after fix
+        cachedReport = null;
+        return {
+            content: [{
+                    type: "text",
+                    text: stdout.replace(/\x1b\[[0-9;]*m/g, ""), // strip ANSI
+                }],
+        };
+    }
+    catch (err) {
+        const output = err.stdout || err.stderr || String(err);
+        return {
+            content: [{
+                    type: "text",
+                    text: output.replace(/\x1b\[[0-9;]*m/g, ""),
+                }],
+        };
+    }
+});
+// ── Tool: vcqa_delta ──
+server.tool("vcqa_delta", "Compare current scan against previous scan. Shows what changed: score delta, fixed issues, new issues, per-check changes. Useful after making fixes to see impact.", {
+    path: z.string().optional().describe("Project directory path (defaults to cwd)"),
+}, async ({ path }) => {
+    const cwd = path || process.cwd();
+    const reportPath = join(cwd, ".vibe-check", "report.json");
+    // Load previous report
+    let prevReport = null;
+    if (existsSync(reportPath)) {
+        try {
+            prevReport = JSON.parse(readFileSync(reportPath, "utf-8"));
+        }
+        catch { /* corrupt */ }
+    }
+    if (!prevReport) {
+        return { content: [{ type: "text", text: "No previous report found. Run vcqa_scan first to establish a baseline, then make changes and run vcqa_delta." }] };
+    }
+    // Run fresh scan (invalidate cache to get live results)
+    cachedReport = null;
+    const currentReport = runScan(cwd);
+    // Compute delta (issue-level diffing)
+    const beforeIssues = new Map();
+    const afterIssues = new Map();
+    for (const c of prevReport.checks) {
+        for (const iss of c.issues) {
+            const key = `${c.name}|${iss.rule || ""}|${iss.file || ""}|${iss.message}`;
+            beforeIssues.set(key, (beforeIssues.get(key) || 0) + 1);
+        }
+    }
+    for (const c of currentReport.checks) {
+        for (const iss of c.issues) {
+            const key = `${c.name}|${iss.rule || ""}|${iss.file || ""}|${iss.message}`;
+            afterIssues.set(key, (afterIssues.get(key) || 0) + 1);
+        }
+    }
+    let fixedCount = 0;
+    let newCount = 0;
+    const fixedSamples = [];
+    const newSamples = [];
+    for (const [key, bCount] of beforeIssues) {
+        const aCount = afterIssues.get(key) || 0;
+        if (bCount > aCount) {
+            fixedCount += bCount - aCount;
+            if (fixedSamples.length < 5)
+                fixedSamples.push(key.split("|").slice(0, 2).join(": "));
+        }
+    }
+    for (const [key, aCount] of afterIssues) {
+        const bCount = beforeIssues.get(key) || 0;
+        if (aCount > bCount) {
+            newCount += aCount - bCount;
+            if (newSamples.length < 5)
+                newSamples.push(key.split("|").slice(0, 2).join(": "));
+        }
+    }
+    const scoreDelta = currentReport.score - prevReport.score;
+    const checkChanges = currentReport.checks
+        .map((c) => {
+        const prev = prevReport.checks.find((p) => p.name === c.name);
+        return { name: c.name, before: prev?.score ?? 0, after: c.score, delta: c.score - (prev?.score ?? 0) };
+    })
+        .filter((c) => c.delta !== 0)
+        .sort((a, b) => b.delta - a.delta);
+    let text = `Score: ${prevReport.grade} ${prevReport.score} → ${currentReport.grade} ${currentReport.score} (${scoreDelta > 0 ? "+" : ""}${scoreDelta})\n`;
+    text += `Fixed: ${fixedCount} issues | New: ${newCount} issues\n\n`;
+    if (checkChanges.length > 0) {
+        text += "Check changes:\n";
+        for (const c of checkChanges.slice(0, 10)) {
+            text += `  ${c.delta > 0 ? "+" : ""}${c.delta} ${c.name} (${c.before} → ${c.after})\n`;
+        }
+        text += "\n";
+    }
+    if (fixedSamples.length > 0)
+        text += `Fixed examples: ${fixedSamples.join(", ")}\n`;
+    if (newSamples.length > 0)
+        text += `New examples: ${newSamples.join(", ")}\n`;
+    return { content: [{ type: "text", text }] };
+});
+// ── Start server ──
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("vcqa-mcp error:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@vibecodeqa/mcp",
+	"version": "0.2.0",
+	"description": "MCP server for VibeCode QA — gives AI coding agents real-time code health context",
+	"type": "module",
+	"bin": {
+		"vcqa-mcp": "./dist/index.js"
+	},
+	"files": [
+		"dist",
+		"LICENSE",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch"
+	},
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"code-quality",
+		"code-health",
+		"ai-agent",
+		"vibecodeqa"
+	],
+	"author": "VibeCode QA <hello@vibecodeqa.online>",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/vibecodeqa/mcp"
+	},
+	"homepage": "https://vibecodeqa.online",
+	"engines": {
+		"node": ">=20"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.12.1",
+		"zod": "^3.25.32"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.0",
+		"typescript": "^5.8.3"
+	}
+}