corpus-mcp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Corpus MCP Server
+ *
+ * Exposes security scanning tools to AI coding agents via the
+ * Model Context Protocol (MCP). The AI can check proposed code
+ * for secrets, PII, and unsafe patterns BEFORE writing to disk.
+ *
+ * Tools:
+ *   scan_content   - Scan code content for security issues
+ *   check_secret   - Check if a string looks like a secret/credential
+ *   check_safety   - Check code for unsafe patterns (eval, innerHTML, etc.)
+ *   get_policy     - Get the verdict for an action type
+ *
+ * Setup in Claude Code / .mcp.json:
+ *   { "command": "npx", "args": ["corpus-mcp"], "type": "stdio" }
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+/**
+ * Corpus MCP Server
+ *
+ * Exposes security scanning tools to AI coding agents via the
+ * Model Context Protocol (MCP). The AI can check proposed code
+ * for secrets, PII, and unsafe patterns BEFORE writing to disk.
+ *
+ * Tools:
+ *   scan_content   - Scan code content for security issues
+ *   check_secret   - Check if a string looks like a secret/credential
+ *   check_safety   - Check code for unsafe patterns (eval, innerHTML, etc.)
+ *   get_policy     - Get the verdict for an action type
+ *
+ * Setup in Claude Code / .mcp.json:
+ *   { "command": "npx", "args": ["corpus-mcp"], "type": "stdio" }
+ */
+import { detectSecrets } from '@corpus/core';
+import { checkCodeSafety } from '@corpus/core';
+import { scanForInjection } from '@corpus/core';
+import { scanPayload } from '@corpus/core';
+import { computeFileTrust } from '@corpus/core';
+import { checkForCVEs } from '@corpus/core';
+import { checkDependencies } from '@corpus/core';
+// ── Tool Definitions ─────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: 'scan_content',
+        description: 'Scan code content for secrets, PII, injection patterns, and unsafe code. Call this before writing any file to check for security issues.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The code content to scan' },
+                filename: { type: 'string', description: 'The filename (used to determine scan rules)' },
+            },
+            required: ['content', 'filename'],
+        },
+    },
+    {
+        name: 'check_secret',
+        description: 'Check if a string value looks like a secret, API key, token, or credential. Use this before hardcoding any string value.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                value: { type: 'string', description: 'The string value to check' },
+            },
+            required: ['value'],
+        },
+    },
+    {
+        name: 'check_safety',
+        description: 'Check code for unsafe patterns like eval(), innerHTML, SQL injection, command injection, disabled SSL, wildcard CORS.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The code to check' },
+                filename: { type: 'string', description: 'The filename' },
+            },
+            required: ['content', 'filename'],
+        },
+    },
+    {
+        name: 'check_injection',
+        description: 'Scan text content for prompt injection patterns. Use this before including any external content in LLM context.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The content to scan' },
+                source: { type: 'string', description: 'Where this content came from' },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'verify_file',
+        description: 'Compute a deterministic trust score (0-100) for a file with line-by-line findings and fix suggestions. Call this BEFORE writing any file. If score is below 50, do NOT write the file -- fix the issues first.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The code content to verify' },
+                filename: { type: 'string', description: 'The filename' },
+            },
+            required: ['content', 'filename'],
+        },
+    },
+    {
+        name: 'corpus_check',
+        description: 'CORPUS IMMUNE SYSTEM: Check code against the codebase contract graph BEFORE writing. If this returns VIOLATES, you MUST fix the violations and re-check. Do NOT write the file until this returns VERIFIED. This catches behavioral breakage: removed functions, deleted guard clauses, changed signatures.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The code content to check against the graph' },
+                filepath: { type: 'string', description: 'The absolute file path being written' },
+                project_root: { type: 'string', description: 'The project root directory (where .corpus/ lives)' },
+            },
+            required: ['content', 'filepath'],
+        },
+    },
+    {
+        name: 'check_dependencies',
+        description: 'CORPUS IMMUNE SYSTEM: Check imports for hallucinated or typosquatted npm packages. AI coding tools sometimes invent package names that do not exist. Call this before writing any file with new imports. If CRITICAL findings are returned, the imports MUST be fixed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The code content to check for dependency issues' },
+                filename: { type: 'string', description: 'The filename' },
+                project_root: { type: 'string', description: 'The project root directory (to read package.json)' },
+            },
+            required: ['content', 'filename'],
+        },
+    },
+    {
+        name: 'corpus_health',
+        description: 'Get the current health status of the codebase immune system. Returns overall health score, verified/violating/uncertain counts, and recent changes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_root: { type: 'string', description: 'The project root directory' },
+            },
+            required: ['project_root'],
+        },
+    },
+];
+// ── Tool Handlers ────────────────────────────────────────────────────────────
+async function handleToolCall(name, args) {
+    switch (name) {
+        case 'scan_content': {
+            const content = String(args.content ?? '');
+            const filename = String(args.filename ?? 'unknown');
+            const secrets = detectSecrets(content, filename);
+            const safety = checkCodeSafety(content, filename);
+            const pii = scanPayload(content);
+            const issues = [
+                ...secrets.map((s) => ({
+                    severity: s.severity,
+                    type: s.type,
+                    line: s.line,
+                    message: s.message,
+                    isAiPattern: s.isAiPattern,
+                })),
+                ...safety.map((s) => ({
+                    severity: s.severity,
+                    type: s.rule,
+                    line: s.line,
+                    message: s.message,
+                    isAiPattern: false,
+                })),
+                ...(pii.hasPii ? pii.matches.map((m) => ({
+                    severity: 'WARNING',
+                    type: `PII: ${m.type}`,
+                    line: 0,
+                    message: `${m.type} found in content`,
+                    isAiPattern: false,
+                })) : []),
+            ];
+            // CVE pattern detection
+            try {
+                const cveFindings = checkForCVEs(content, filename);
+                for (const cve of cveFindings) {
+                    issues.push({
+                        severity: cve.severity === 'HIGH' ? 'CRITICAL' : cve.severity === 'MEDIUM' ? 'WARNING' : cve.severity,
+                        type: `CVE: ${cve.cveId}`,
+                        line: cve.line,
+                        message: `${cve.name}: ${cve.description}`,
+                        isAiPattern: false,
+                    });
+                }
+            }
+            catch { }
+            const clean = issues.length === 0;
+            const text = clean
+                ? `CLEAN: No security issues found in ${filename}.`
+                : `FOUND ${issues.length} issue(s) in ${filename}:\n${issues.map((i) => `  [${i.severity}] ${i.message}${i.isAiPattern ? ' (AI pattern)' : ''}`).join('\n')}`;
+            return { content: [{ type: 'text', text }] };
+        }
+        case 'check_secret': {
+            const value = String(args.value ?? '');
+            const findings = detectSecrets(`const x = "${value}";`, 'check.ts');
+            const isSecret = findings.length > 0;
+            return {
+                content: [{
+                        type: 'text',
+                        text: isSecret
+                            ? `WARNING: This looks like a ${findings[0].type}. Do NOT hardcode this value. Use an environment variable instead.`
+                            : `OK: This value does not match known secret patterns.`,
+                    }],
+            };
+        }
+        case 'check_safety': {
+            const content = String(args.content ?? '');
+            const filename = String(args.filename ?? 'unknown');
+            const findings = checkCodeSafety(content, filename);
+            if (findings.length === 0) {
+                return { content: [{ type: 'text', text: 'SAFE: No unsafe code patterns found.' }] };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `FOUND ${findings.length} unsafe pattern(s):\n${findings.map((f) => `  [${f.severity}] ${f.message}\n    Fix: ${f.suggestion}`).join('\n')}`,
+                    }],
+            };
+        }
+        case 'check_injection': {
+            const content = String(args.content ?? '');
+            const source = String(args.source ?? 'unknown');
+            const result = scanForInjection(content, source);
+            return {
+                content: [{
+                        type: 'text',
+                        text: result.severity === 'CLEAN'
+                            ? 'CLEAN: No injection patterns found.'
+                            : `${result.severity}: ${result.message}`,
+                    }],
+            };
+        }
+        case 'verify_file': {
+            const content = String(args.content ?? '');
+            const filename = String(args.filename ?? 'unknown');
+            const result = computeFileTrust(content, filename);
+            // Also check for dependency issues
+            let depWarning = '';
+            try {
+                const depFindings = await checkDependencies(content, filename, { projectRoot: process.cwd() });
+                if (depFindings.length > 0) {
+                    depWarning = `\n\nDEPENDENCY WARNINGS:\n${depFindings.map(f => `  [${f.severity}] Package '${f.package}': ${f.suggestion}`).join('\n')}`;
+                }
+            }
+            catch { }
+            if (result.findings.length === 0 && !depWarning) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `TRUST SCORE: ${result.score}/100 - CLEAN. No issues found in ${filename}. Safe to write.`,
+                        }],
+                };
+            }
+            const findingsText = result.findings
+                .map((f) => `  [${f.severity}] Line ${f.line}: ${f.message}\n    FIX: ${f.fix}`)
+                .join('\n');
+            const recommendation = result.score < 50
+                ? 'DO NOT write this file. Fix the critical issues first.'
+                : result.score < 80
+                    ? 'File has warnings. Consider fixing before writing.'
+                    : 'File is acceptable. Safe to write.';
+            return {
+                content: [{
+                        type: 'text',
+                        text: `TRUST SCORE: ${result.score}/100 for ${filename}\n${recommendation}\n\n${result.findings.length} finding(s):\n${findingsText}${depWarning}`,
+                    }],
+            };
+        }
+        case 'corpus_check': {
+            const content = String(args.content ?? '');
+            const filepath = String(args.filepath ?? '');
+            const projectRoot = String(args.project_root ?? process.cwd());
+            try {
+                // Dynamic import to avoid breaking if graph-engine isn't built yet
+                const { checkFile } = await import('@corpus/core');
+                const result = checkFile(projectRoot, filepath, content);
+                if (result.verdict === 'VERIFIED') {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `CORPUS VERIFIED: All contracts satisfied for ${result.file}. Safe to write.`,
+                            }],
+                    };
+                }
+                if (result.verdict === 'UNCERTAIN') {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `CORPUS UNCERTAIN: ${result.instructions}`,
+                            }],
+                    };
+                }
+                // VIOLATES - return fix instructions
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `CORPUS VIOLATES: ${result.instructions}\n\nYou MUST fix these violations before writing the file. Regenerate the code with these fixes applied, then call corpus_check again.`,
+                        }],
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `CORPUS UNCERTAIN: Could not check graph contracts. ${e instanceof Error ? e.message : 'Unknown error'}. Run \`corpus init\` to build the immune system.`,
+                        }],
+                };
+            }
+        }
+        case 'corpus_health': {
+            const projectRoot = String(args.project_root ?? process.cwd());
+            try {
+                const { getHealthSummary } = await import('@corpus/core');
+                const health = getHealthSummary(projectRoot);
+                const status = health.healthy ? 'HEALTHY' : 'DEGRADED';
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `CORPUS ${status}: Score ${health.score}/100 | ${health.totalNodes} nodes | ${health.verified} verified | ${health.violating} violating | ${health.uncertain} uncertain`,
+                        }],
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `CORPUS: No immune system found. Run \`corpus init\` to build the codebase graph.`,
+                        }],
+                };
+            }
+        }
+        case 'check_dependencies': {
+            const content = String(args.content ?? '');
+            const filename = String(args.filename ?? 'unknown');
+            const projectRoot = String(args.project_root ?? process.cwd());
+            try {
+                const findings = await checkDependencies(content, filename, { projectRoot });
+                if (findings.length === 0) {
+                    return { content: [{ type: 'text', text: 'CORPUS VERIFIED: All imported packages are legitimate. No hallucinated dependencies detected.' }] };
+                }
+                const text = findings.map(f => {
+                    let msg = `[${f.severity}] Package '${f.package}': ${f.reason === 'nonexistent' ? 'DOES NOT EXIST on npm' : f.reason === 'typosquat' ? 'Possible typosquat' : 'Suspiciously unpopular'}`;
+                    if (f.similarPackages?.length)
+                        msg += `\n    Did you mean: ${f.similarPackages.join(', ')}?`;
+                    msg += `\n    ${f.suggestion}`;
+                    return msg;
+                }).join('\n');
+                return { content: [{ type: 'text', text: `CORPUS ALERT: ${findings.length} suspicious dependency(ies) found:\n${text}\n\nFix these imports before writing the file.` }] };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `CORPUS: Dependency check unavailable. ${e instanceof Error ? e.message : 'Unknown error'}` }] };
+            }
+        }
+        default:
+            return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
+    }
+}
+// ── MCP stdio transport ──────────────────────────────────────────────────────
+function sendResponse(response) {
+    const json = JSON.stringify(response);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+function handleRequest(request) {
+    switch (request.method) {
+        case 'initialize':
+            sendResponse({
+                jsonrpc: '2.0',
+                id: request.id,
+                result: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'corpus-mcp', version: '0.2.0' },
+                },
+            });
+            break;
+        case 'tools/list':
+            sendResponse({
+                jsonrpc: '2.0',
+                id: request.id,
+                result: { tools: TOOLS },
+            });
+            break;
+        case 'tools/call': {
+            const params = request.params;
+            handleToolCall(params.name, params.arguments ?? {}).then((result) => {
+                sendResponse({
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    result,
+                });
+            }).catch((err) => {
+                sendResponse({
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    error: { code: -32603, message: err instanceof Error ? err.message : 'Internal error' },
+                });
+            });
+            break;
+        }
+        case 'notifications/initialized':
+            // No response needed for notifications
+            break;
+        default:
+            sendResponse({
+                jsonrpc: '2.0',
+                id: request.id,
+                error: { code: -32601, message: `Method not found: ${request.method}` },
+            });
+    }
+}
+// ── Main ─────────────────────────────────────────────────────────────────────
+let buffer = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+    while (true) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd === -1)
+            break;
+        const header = buffer.slice(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+            buffer = buffer.slice(headerEnd + 4);
+            continue;
+        }
+        const contentLength = parseInt(match[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (buffer.length < bodyStart + contentLength)
+            break;
+        const body = buffer.slice(bodyStart, bodyStart + contentLength);
+        buffer = buffer.slice(bodyStart + contentLength);
+        try {
+            const request = JSON.parse(body);
+            handleRequest(request);
+        }
+        catch {
+            // Invalid JSON, skip
+        }
+    }
+});
+process.stderr.write('[corpus-mcp] Server started\n');

package/dist/standalone.d.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Corpus MCP Server (Standalone)
+ * Self-contained -- all scanner logic inline, no external imports.
+ * Works from any directory without workspace resolution.
+ */
+declare const SECRET_PATTERNS: {
+    name: string;
+    regex: RegExp;
+    fix: string;
+}[];
+declare const SAFETY_PATTERNS: {
+    name: string;
+    regex: RegExp;
+    severity: string;
+    fix: string;
+}[];
+declare const INJECTION_PATTERNS: string[];
+declare const PLACEHOLDER_SKIP: RegExp[];
+interface Finding {
+    severity: string;
+    type: string;
+    line: number;
+    message: string;
+    fix: string;
+}
+declare function scanContent(content: string, filename: string): Finding[];
+declare function computeTrustScore(findings: Finding[]): number;
+declare function checkInjection(content: string, source: string): {
+    severity: string;
+    message: string;
+};
+declare const TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            filename: {
+                type: string;
+                description: string;
+            };
+            value?: undefined;
+            source?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            value: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            filename?: undefined;
+            source?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            source: {
+                type: string;
+                description: string;
+            };
+            filename?: undefined;
+            value?: undefined;
+        };
+        required: string[];
+    };
+})[];
+declare function handleTool(name: string, args: Record<string, unknown>): {
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+interface McpRequest {
+    jsonrpc: string;
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+declare function send(response: object): void;
+declare function handle(req: McpRequest): void;
+declare let buffer: string;

package/dist/standalone.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Corpus MCP Server (Standalone)
+ * Self-contained -- all scanner logic inline, no external imports.
+ * Works from any directory without workspace resolution.
+ */
+// ── Inline Scanners ──────────────────────────────────────────────────────────
+const SECRET_PATTERNS = [
+    { name: 'AWS Access Key', regex: /AKIA[0-9A-Z]{16}/g, fix: 'Move to process.env.AWS_ACCESS_KEY_ID' },
+    { name: 'GitHub Token', regex: /gh[pousr]_[A-Za-z0-9_]{36,}/g, fix: 'Move to process.env.GITHUB_TOKEN' },
+    { name: 'OpenAI/Anthropic Key', regex: /sk-[A-Za-z0-9]{20,}/g, fix: 'Move to process.env.API_KEY' },
+    { name: 'Stripe Live Key', regex: /[sr]k_live_[A-Za-z0-9]{20,}/g, fix: 'Move to process.env.STRIPE_SECRET_KEY' },
+    { name: 'Private Key', regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g, fix: 'Never hardcode private keys' },
+    { name: 'Database URL', regex: /(?:postgres|mysql|mongodb|redis):\/\/[^\s'"]+:[^\s'"]+@[^\s'"]+/g, fix: 'Move to process.env.DATABASE_URL' },
+    { name: 'Slack Token', regex: /xox[baprs]-[0-9a-zA-Z-]{10,}/g, fix: 'Move to process.env.SLACK_TOKEN' },
+    { name: 'Hardcoded Password', regex: /(?:password|passwd|pwd)\s*[=:]\s*['"]([^'"]{8,})['"]/gi, fix: 'Use environment variable' },
+];
+const SAFETY_PATTERNS = [
+    { name: 'eval()', regex: /\beval\s*\(/g, severity: 'CRITICAL', fix: 'Use JSON.parse() or Function()' },
+    { name: 'innerHTML', regex: /\.innerHTML\s*=/g, severity: 'WARNING', fix: 'Use textContent or DOMPurify' },
+    { name: 'Disabled SSL', regex: /rejectUnauthorized\s*:\s*false/g, severity: 'WARNING', fix: 'Set rejectUnauthorized: true' },
+    { name: 'Wildcard CORS', regex: /(?:cors|origin)\s*[=:]\s*['"]\*['"]/gi, severity: 'WARNING', fix: 'Set specific origin' },
+    { name: 'chmod 777', regex: /chmod\s+777/g, severity: 'WARNING', fix: 'Use 755 or 644' },
+    { name: 'Wildcard IAM', regex: /"(?:Action|Resource)"\s*:\s*"\*"/g, severity: 'CRITICAL', fix: 'Use least-privilege' },
+    { name: 'dangerouslySetInnerHTML', regex: /dangerouslySetInnerHTML/g, severity: 'WARNING', fix: 'Sanitize HTML first' },
+];
+const INJECTION_PATTERNS = [
+    'ignore previous instructions', 'ignore all previous', 'you are now',
+    'system prompt', 'developer mode', 'jailbreak', 'bypass safety',
+    'new instructions:', 'forget everything',
+];
+const PLACEHOLDER_SKIP = [/test|fake|dummy|placeholder|example|changeme|xxx|your_/i];
+function scanContent(content, filename) {
+    const findings = [];
+    // Secrets
+    for (const pat of SECRET_PATTERNS) {
+        pat.regex.lastIndex = 0;
+        let m;
+        while ((m = pat.regex.exec(content)) !== null) {
+            const val = m[1] ?? m[0];
+            if (PLACEHOLDER_SKIP.some(p => p.test(val)))
+                continue;
+            const line = content.slice(0, m.index).split('\n').length;
+            findings.push({ severity: 'CRITICAL', type: pat.name, line, message: `${pat.name} detected`, fix: pat.fix });
+        }
+    }
+    // Safety
+    for (const pat of SAFETY_PATTERNS) {
+        pat.regex.lastIndex = 0;
+        let m;
+        while ((m = pat.regex.exec(content)) !== null) {
+            const line = content.slice(0, m.index).split('\n').length;
+            findings.push({ severity: pat.severity, type: pat.name, line, message: pat.name, fix: pat.fix });
+        }
+    }
+    // PII
+    if (/\b\d{3}-\d{2}-\d{4}\b/.test(content)) {
+        const idx = content.search(/\b\d{3}-\d{2}-\d{4}\b/);
+        findings.push({ severity: 'CRITICAL', type: 'SSN', line: content.slice(0, idx).split('\n').length, message: 'SSN in source', fix: 'Remove immediately' });
+    }
+    return findings;
+}
+function computeTrustScore(findings) {
+    let critD = 0, warnD = 0, infoD = 0;
+    for (const f of findings) {
+        if (f.severity === 'CRITICAL')
+            critD += 15;
+        else if (f.severity === 'WARNING')
+            warnD += 5;
+        else
+            infoD += 1;
+    }
+    return Math.max(0, Math.round(100 - Math.min(critD, 60) - Math.min(warnD, 25) - Math.min(infoD, 10)));
+}
+function checkInjection(content, source) {
+    const lower = content.toLowerCase();
+    for (const pattern of INJECTION_PATTERNS) {
+        if (lower.includes(pattern)) {
+            return { severity: 'BLOCK', message: `Injection pattern "${pattern}" from ${source}` };
+        }
+    }
+    return { severity: 'CLEAN', message: '' };
+}
+// ── MCP Protocol ─────────────────────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: 'verify_file',
+        description: 'Compute a trust score (0-100) for code with line-by-line findings and fixes. If score < 50, do NOT write the file.',
+        inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Code content' }, filename: { type: 'string', description: 'Filename' } }, required: ['content', 'filename'] },
+    },
+    {
+        name: 'scan_content',
+        description: 'Scan code for secrets, PII, and unsafe patterns.',
+        inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Code content' }, filename: { type: 'string', description: 'Filename' } }, required: ['content', 'filename'] },
+    },
+    {
+        name: 'check_secret',
+        description: 'Check if a string value is a secret/credential.',
+        inputSchema: { type: 'object', properties: { value: { type: 'string', description: 'Value to check' } }, required: ['value'] },
+    },
+    {
+        name: 'check_safety',
+        description: 'Check code for unsafe patterns like eval(), innerHTML, SQL injection.',
+        inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Code' }, filename: { type: 'string', description: 'Filename' } }, required: ['content', 'filename'] },
+    },
+    {
+        name: 'check_injection',
+        description: 'Scan text for prompt injection patterns.',
+        inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Content to scan' }, source: { type: 'string', description: 'Source' } }, required: ['content'] },
+    },
+];
+function handleTool(name, args) {
+    const text = (t) => ({ content: [{ type: 'text', text: t }] });
+    switch (name) {
+        case 'verify_file': {
+            const content = String(args.content ?? '');
+            const filename = String(args.filename ?? 'unknown');
+            const findings = scanContent(content, filename);
+            const score = computeTrustScore(findings);
+            if (findings.length === 0)
+                return text(`TRUST SCORE: ${score}/100 - CLEAN. Safe to write.`);
+            const rec = score < 50 ? 'DO NOT write this file. Fix critical issues first.' : score < 80 ? 'Warnings found. Consider fixing.' : 'Safe to write.';
+            const details = findings.map(f => `  [${f.severity}] Line ${f.line}: ${f.message}\n    FIX: ${f.fix}`).join('\n');
+            return text(`TRUST SCORE: ${score}/100 for ${filename}\n${rec}\n\n${findings.length} finding(s):\n${details}`);
+        }
+        case 'scan_content': {
+            const findings = scanContent(String(args.content ?? ''), String(args.filename ?? 'unknown'));
+            if (findings.length === 0)
+                return text('CLEAN: No issues found.');
+            return text(`FOUND ${findings.length} issue(s):\n${findings.map(f => `  [${f.severity}] ${f.message}`).join('\n')}`);
+        }
+        case 'check_secret': {
+            const findings = scanContent(`const x = "${args.value}";`, 'check.ts');
+            return text(findings.length > 0 ? `WARNING: Looks like a ${findings[0].type}. Use an environment variable.` : 'OK: Not a known secret pattern.');
+        }
+        case 'check_safety': {
+            const findings = scanContent(String(args.content ?? ''), String(args.filename ?? 'unknown')).filter(f => ['eval()', 'innerHTML', 'Disabled SSL', 'Wildcard CORS', 'chmod 777', 'Wildcard IAM', 'dangerouslySetInnerHTML'].includes(f.type));
+            if (findings.length === 0)
+                return text('SAFE: No unsafe patterns.');
+            return text(`FOUND ${findings.length} unsafe pattern(s):\n${findings.map(f => `  [${f.severity}] ${f.message}\n    FIX: ${f.fix}`).join('\n')}`);
+        }
+        case 'check_injection': {
+            const result = checkInjection(String(args.content ?? ''), String(args.source ?? 'unknown'));
+            return text(result.severity === 'CLEAN' ? 'CLEAN: No injection patterns.' : `${result.severity}: ${result.message}`);
+        }
+        default:
+            return text(`Unknown tool: ${name}`);
+    }
+}
+function send(response) {
+    const json = JSON.stringify(response);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+function handle(req) {
+    switch (req.method) {
+        case 'initialize':
+            send({ jsonrpc: '2.0', id: req.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'corpus-mcp', version: '0.1.0' } } });
+            break;
+        case 'tools/list':
+            send({ jsonrpc: '2.0', id: req.id, result: { tools: TOOLS } });
+            break;
+        case 'tools/call': {
+            const p = req.params;
+            send({ jsonrpc: '2.0', id: req.id, result: handleTool(p.name, p.arguments ?? {}) });
+            break;
+        }
+        case 'notifications/initialized':
+            break;
+        default:
+            send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: `Method not found: ${req.method}` } });
+    }
+}
+let buffer = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+    while (true) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd === -1)
+            break;
+        const header = buffer.slice(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+            buffer = buffer.slice(headerEnd + 4);
+            continue;
+        }
+        const len = parseInt(match[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (buffer.length < bodyStart + len)
+            break;
+        const body = buffer.slice(bodyStart, bodyStart + len);
+        buffer = buffer.slice(bodyStart + len);
+        try {
+            handle(JSON.parse(body));
+        }
+        catch { }
+    }
+});
+process.stderr.write('[corpus-mcp] Server started\n');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "corpus-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Corpus — AI coding tools check security before writing code",
+  "type": "module",
+  "main": "dist/standalone.js",
+  "bin": {
+    "corpus-mcp": "dist/standalone.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && tsc src/standalone.ts --outDir dist --target ES2022 --module CommonJS --moduleResolution node --esModuleInterop --skipLibCheck"
+  },
+  "dependencies": {
+    "corpus-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.0"
+  },
+  "keywords": ["mcp", "ai", "security", "corpus", "claude", "cursor", "copilot", "trust-score", "jac"],
+  "repository": { "type": "git", "url": "https://github.com/fluentflier/corpus" },
+  "license": "MIT"
+}