guardvibe 2.4.4 → 2.5.0

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to GuardVibe are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.0] - 2026-04-04
+
+### Added
+- Cross-file taint analysis — tracks tainted data flowing across module boundaries (`analyze_cross_file_dataflow` tool)
+- Import/export resolution, module graph building, and cross-file taint propagation
+- Detects SQL injection, XSS, open redirect, code injection, and path traversal across files
+
+## [2.4.5] - 2026-04-04
+
+### Added
+- Official MCP Registry support (`mcpName` in package.json, `server.json`)
+
 ## [2.4.4] - 2026-04-04
 
 ### Added

package/README.md

@@ -6,7 +6,7 @@
 [![npm provenance](https://img.shields.io/badge/provenance-verified-brightgreen)](https://www.npmjs.com/package/guardvibe)
 [![codecov](https://codecov.io/gh/goklab/guardvibe/graph/badge.svg)](https://codecov.io/gh/goklab/guardvibe)
 
-**The security MCP built for vibe coding.** 313 security rules covering the entire AI-generated code journey — from first line to production deployment.
+**The security MCP built for vibe coding.** 313 security rules, 26 tools covering the entire AI-generated code journey — from first line to production deployment.
 
 Works with **Claude Code, Cursor, Gemini CLI, Codex, VS Code (Copilot), Windsurf**, and any MCP-compatible coding agent.
 
@@ -14,7 +14,7 @@ Works with **Claude Code, Cursor, Gemini CLI, Codex, VS Code (Copilot), Windsurf
 
 Most security tools are built for enterprise security teams. GuardVibe is built for **you** — the developer using AI to build and ship web apps fast.
 
-- **313 security rules** purpose-built for the stacks AI agents generate
+- **313 security rules, 26 tools** purpose-built for the stacks AI agents generate
 - **Zero setup friction** — `npx guardvibe` and you're scanning
 - **No account required** — runs 100% locally, no API keys, no cloud
 - **Understands your stack** — not generic SAST, but rules that know Next.js, Supabase, Stripe, Clerk, and the tools you actually use
@@ -179,7 +179,7 @@ SOC2, PCI-DSS, HIPAA control mapping with compliance reports
 ### Supply Chain
 Malicious postinstall scripts, unpinned GitHub Actions, typosquat detection
 
-## Tools (25 MCP tools)
+## Tools (26 MCP tools)
 
 | Tool | What it does |
 |------|-------------|
@@ -201,6 +201,7 @@ Malicious postinstall scripts, unpinned GitHub Actions, typosquat detection
 | `scan_secrets_history` | Scan git history for leaked secrets (active and removed) |
 | `policy_check` | Check project against compliance policies defined in .guardviberc |
 | `analyze_dataflow` | Track tainted data flows from user input to dangerous sinks |
+| `analyze_cross_file_dataflow` | **Cross-file taint analysis** — track tainted data across module boundaries |
 | `check_command` | Analyze shell commands for security risks before execution |
 | `scan_config_change` | Compare config file versions to detect security downgrades |
 | `repo_security_posture` | Assess overall repository security posture and map sensitive areas |

package/build/index.js

@@ -23,6 +23,7 @@ import { reviewPr } from "./tools/review-pr.js";
 import { scanSecretsHistory } from "./tools/scan-secrets-history.js";
 import { policyCheck } from "./tools/policy-check.js";
 import { analyzeTaint, formatTaintFindings } from "./tools/taint-analysis.js";
+import { analyzeCrossFileTaint, formatCrossFileTaintFindings } from "./tools/cross-file-taint.js";
 import { checkCommand } from "./tools/check-command.js";
 import { scanConfigChange } from "./tools/scan-config-change.js";
 import { repoSecurityPosture } from "./tools/repo-posture.js";
@@ -340,6 +341,26 @@ server.tool("analyze_dataflow", "Track user input (request body, URL params, for
     const results = formatTaintFindings(findings, format);
     return { content: [{ type: "text", text: results }] };
 });
+// Tool 18b: Cross-File Taint/Dataflow Analysis
+server.tool("analyze_cross_file_dataflow", "Track user input flowing across module boundaries — detects injection vulnerabilities that span multiple files. Resolves imports/exports, builds a module graph, and follows tainted data from HTTP handlers through helper functions to dangerous sinks (SQL, eval, redirect, file ops). Pass all related files for best results.", {
+    files: z
+        .array(z.object({
+        path: z.string().describe("Relative file path (e.g. src/lib/db.ts)"),
+        content: z.string().describe("File source code"),
+    }))
+        .describe("List of files to analyze: [{path, content}]"),
+    format: z.enum(["markdown", "json"]).default("markdown").describe("Output format"),
+}, async ({ files, format }) => {
+    const { crossFileFindings, perFileFindings } = analyzeCrossFileTaint(files);
+    const total = crossFileFindings.length + Array.from(perFileFindings.values()).reduce((sum, f) => sum + f.length, 0);
+    if (total === 0) {
+        if (format === "json")
+            return { content: [{ type: "text", text: JSON.stringify({ summary: { crossFileFlows: 0, perFileFlows: 0, total: 0, critical: 0, high: 0, medium: 0 }, crossFileFindings: [], perFileFindings: [] }) }] };
+        return { content: [{ type: "text", text: "No tainted data flows detected across files." }] };
+    }
+    const results = formatCrossFileTaintFindings(crossFileFindings, perFileFindings, format);
+    return { content: [{ type: "text", text: results }] };
+});
 // Tool 19: Shell Command Risk Analyzer
 server.tool("check_command", "Analyze a shell command for security risks before execution. Returns allow/ask/deny verdict with blast radius, safer alternatives, and context-aware risk assessment. Detects: destructive ops, git history rewrites, secret exposure, data exfiltration, deploy triggers, privilege escalation, database drops.", {
     command: z.string().describe("Shell command to analyze"),

package/build/tools/cross-file-taint.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Cross-file taint analysis — tracks user input flowing across module boundaries.
+ * Resolves imports/exports, builds a module graph, and propagates taint between files.
+ */
+import { type TaintFinding } from "./taint-analysis.js";
+export interface FileEntry {
+    path: string;
+    content: string;
+}
+export interface CrossFileTaintFinding {
+    source: {
+        file: string;
+        type: string;
+        line: number;
+        variable: string;
+    };
+    sink: {
+        file: string;
+        type: string;
+        line: number;
+        code: string;
+    };
+    chain: string[];
+    severity: "critical" | "high" | "medium";
+    description: string;
+    fix: string;
+}
+interface ImportInfo {
+    /** The file that contains the import statement */
+    importer: string;
+    /** Resolved path of the module being imported */
+    source: string;
+    /** Named imports: local name -> exported name */
+    names: Map<string, string>;
+    /** Default import name, if any */
+    defaultName?: string;
+    /** Namespace import name (import * as X), if any */
+    namespaceName?: string;
+    /** Line number of the import statement */
+    line: number;
+}
+interface ExportInfo {
+    /** The file that exports */
+    file: string;
+    /** Exported name -> local name */
+    names: Map<string, string>;
+    /** Has default export */
+    hasDefault: boolean;
+    /** Default export local name (function/class name or "default") */
+    defaultLocal?: string;
+}
+interface FunctionSignature {
+    file: string;
+    name: string;
+    params: string[];
+    startLine: number;
+    endLine: number;
+    body: string;
+}
+interface TaintedExport {
+    file: string;
+    exportName: string;
+    /** Which parameter indices receive taint and flow to sinks */
+    taintedParams: Map<number, {
+        sinkType: string;
+        sinkLine: number;
+        sinkCode: string;
+    }>;
+}
+declare function normalizePath(from: string, importPath: string): string;
+declare function stripExtension(filePath: string): string;
+declare function parseImports(file: string, content: string): ImportInfo[];
+declare function parseExports(file: string, content: string): ExportInfo;
+declare function extractFunctions(file: string, content: string): FunctionSignature[];
+declare function findTaintedExports(files: FileEntry[]): TaintedExport[];
+export declare function analyzeCrossFileTaint(files: FileEntry[]): {
+    crossFileFindings: CrossFileTaintFinding[];
+    perFileFindings: Map<string, TaintFinding[]>;
+};
+export declare function formatCrossFileTaintFindings(crossFileFindings: CrossFileTaintFinding[], perFileFindings: Map<string, TaintFinding[]>, format: "markdown" | "json"): string;
+export { parseImports, parseExports, extractFunctions, findTaintedExports, normalizePath, stripExtension };

package/build/tools/cross-file-taint.js

@@ -0,0 +1,554 @@
+// guardvibe-ignore — this file defines cross-file taint analysis patterns, not vulnerable code
+/**
+ * Cross-file taint analysis — tracks user input flowing across module boundaries.
+ * Resolves imports/exports, builds a module graph, and propagates taint between files.
+ */
+import { analyzeTaint } from "./taint-analysis.js";
+// --- Import/Export Resolution ---
+function normalizePath(from, importPath) {
+    if (!importPath.startsWith("."))
+        return importPath;
+    const fromDir = from.includes("/") ? from.substring(0, from.lastIndexOf("/")) : ".";
+    const parts = fromDir.split("/").filter(Boolean);
+    const importParts = importPath.split("/");
+    for (const p of importParts) {
+        if (p === "..")
+            parts.pop();
+        else if (p !== ".")
+            parts.push(p);
+    }
+    let resolved = parts.join("/");
+    resolved = resolved.replace(/\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/, "");
+    return resolved;
+}
+function stripExtension(filePath) {
+    return filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/, "");
+}
+function parseImports(file, content) {
+    const imports = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // import X, { a, b } from './mod'
+        {
+            const re = /import\s+([\w$]+)\s*,\s*\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                const names = new Map();
+                for (const spec of m[2].split(",")) {
+                    const parts = spec.trim().split(/\s+as\s+/);
+                    const exported = parts[0].trim();
+                    const local = (parts[1] ?? parts[0]).trim();
+                    if (exported)
+                        names.set(local, exported);
+                }
+                imports.push({
+                    importer: file,
+                    source: normalizePath(file, m[3]),
+                    names,
+                    defaultName: m[1].trim(),
+                    line: i + 1,
+                });
+            }
+        }
+        // import { a, b as c } from './mod'
+        {
+            const re = /import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                if (/import\s+[\w$]+\s*,\s*\{/.test(line))
+                    continue;
+                const names = new Map();
+                for (const spec of m[1].split(",")) {
+                    const parts = spec.trim().split(/\s+as\s+/);
+                    const exported = parts[0].trim();
+                    const local = (parts[1] ?? parts[0]).trim();
+                    if (exported)
+                        names.set(local, exported);
+                }
+                imports.push({ importer: file, source: normalizePath(file, m[2]), names, line: i + 1 });
+            }
+        }
+        // import * as X from './mod'
+        {
+            const re = /import\s+\*\s+as\s+([\w$]+)\s+from\s+['"]([^'"]+)['"]/g;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                imports.push({
+                    importer: file,
+                    source: normalizePath(file, m[2]),
+                    names: new Map(),
+                    namespaceName: m[1].trim(),
+                    line: i + 1,
+                });
+            }
+        }
+        // import X from './mod' (default only)
+        {
+            const re = /import\s+([\w$]+)\s+from\s+['"]([^'"]+)['"]/g;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                if (/import\s+\{/.test(line) || /import\s+\*\s+as/.test(line))
+                    continue;
+                if (/import\s+[\w$]+\s*,\s*\{/.test(line))
+                    continue;
+                imports.push({
+                    importer: file,
+                    source: normalizePath(file, m[2]),
+                    names: new Map(),
+                    defaultName: m[1].trim(),
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    return imports;
+}
+function parseExports(file, content) {
+    const names = new Map();
+    let hasDefault = false;
+    let defaultLocal;
+    const lines = content.split("\n");
+    for (const line of lines) {
+        // export { a, b as c }
+        {
+            const re = /export\s+\{([^}]+)\}/g;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                for (const spec of m[1].split(",")) {
+                    const parts = spec.trim().split(/\s+as\s+/);
+                    const local = parts[0].trim();
+                    const exported = (parts[1] ?? parts[0]).trim();
+                    if (exported === "default") {
+                        hasDefault = true;
+                        defaultLocal = local;
+                    }
+                    else if (exported) {
+                        names.set(exported, local);
+                    }
+                }
+            }
+        }
+        // export default function/class name
+        {
+            const re = /export\s+default\s+(?:async\s+)?(?:function|class)\s+([\w$]+)/;
+            const m = re.exec(line);
+            if (m) {
+                hasDefault = true;
+                defaultLocal = m[1];
+            }
+        }
+        // export default (anonymous)
+        if (!hasDefault && /export\s+default\s+/.test(line) && !/export\s+default\s+(?:async\s+)?(?:function|class)\s+[\w$]/.test(line)) {
+            hasDefault = true;
+            defaultLocal = "default";
+        }
+        // export function/const/class name
+        {
+            const re = /export\s+(?:async\s+)?(?:function|const|let|var|class)\s+([\w$]+)/;
+            const m = re.exec(line);
+            if (m && !/export\s+default/.test(line)) {
+                names.set(m[1], m[1]);
+            }
+        }
+    }
+    return { file, names, hasDefault, defaultLocal };
+}
+// --- Function Extraction ---
+function extractFunctions(file, content) {
+    const functions = [];
+    const lines = content.split("\n");
+    const funcPattern = /(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([\w$]+)\s*\(([^)]*)\)/;
+    const arrowPattern = /(?:export\s+)?(?:const|let|var)\s+([\w$]+)\s*=\s*(?:async\s+)?(?:\(([^)]*)\)\s*=>|\([^)]*\)\s*:\s*\w+\s*=>|function\s*\(([^)]*)\))/;
+    for (let i = 0; i < lines.length; i++) {
+        let match = funcPattern.exec(lines[i]);
+        if (match) {
+            const params = match[2].split(",").map(p => p.trim().split(/[:\s=]/)[0].trim()).filter(Boolean);
+            const body = extractFunctionBody(lines, i);
+            functions.push({ file, name: match[1], params, startLine: i + 1, endLine: i + body.split("\n").length, body });
+            continue;
+        }
+        match = arrowPattern.exec(lines[i]);
+        if (match) {
+            const paramStr = match[2] ?? match[3] ?? "";
+            const params = paramStr.split(",").map(p => p.trim().split(/[:\s=]/)[0].trim()).filter(Boolean);
+            const body = extractFunctionBody(lines, i);
+            functions.push({ file, name: match[1], params, startLine: i + 1, endLine: i + body.split("\n").length, body });
+        }
+    }
+    return functions;
+}
+function extractFunctionBody(lines, startIdx) {
+    let braceCount = 0;
+    let started = false;
+    const bodyLines = [];
+    for (let i = startIdx; i < lines.length; i++) {
+        const line = lines[i];
+        bodyLines.push(line);
+        for (const ch of line) {
+            if (ch === "{") {
+                braceCount++;
+                started = true;
+            }
+            if (ch === "}")
+                braceCount--;
+        }
+        if (started && braceCount <= 0)
+            break;
+    }
+    return bodyLines.join("\n");
+}
+// --- Cross-File Analysis Engine ---
+// Sink patterns used for checking if a param flows to a dangerous operation
+const SINK_PATTERNS = [
+    { pattern: /\beval\s*\(/g, type: "code-injection" },
+    { pattern: /\.query\s*\(\s*`/g, type: "sql-injection" },
+    { pattern: /\.raw\s*\(\s*`/g, type: "sql-injection" },
+    { pattern: /\.query\s*\(\s*["'][\s\S]*?\$\{/g, type: "sql-injection" },
+    { pattern: /\.query\s*\(\s*(?:["'][\s\S]*?\+|[\w]+\s*\+)/g, type: "sql-injection" },
+    { pattern: /redirect\s*\(/g, type: "open-redirect" },
+    { pattern: /\.(?:innerHTML|outerHTML)\s*=/g, type: "xss" },
+    { pattern: /new\s+Function\s*\(/g, type: "code-injection" },
+    { pattern: /writeFileSync?\s*\(/g, type: "path-traversal" },
+    { pattern: /readFileSync?\s*\(/g, type: "path-traversal" },
+];
+function checkParamFlowsToSink(paramName, body, startLine) {
+    const lines = body.split("\n");
+    const taintedNames = new Set([paramName]);
+    const assignPattern = /(?:const|let|var)\s+([\w$]+)\s*=\s*(.*)/;
+    for (const line of lines) {
+        const m = assignPattern.exec(line);
+        if (m) {
+            for (const t of taintedNames) {
+                if (m[2].includes(t)) {
+                    taintedNames.add(m[1]);
+                    break;
+                }
+            }
+        }
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const sink of SINK_PATTERNS) {
+            sink.pattern.lastIndex = 0;
+            if (!sink.pattern.test(line))
+                continue;
+            for (const t of taintedNames) {
+                if (line.includes(t)) {
+                    return { sinkType: sink.type, sinkLine: startLine + i, sinkCode: line.trim().substring(0, 100) };
+                }
+            }
+        }
+    }
+    return null;
+}
+function findTaintedExports(files) {
+    const taintedExports = [];
+    for (const file of files) {
+        const exports = parseExports(file.path, file.content);
+        const functions = extractFunctions(file.path, file.content);
+        for (const fn of functions) {
+            const exportedName = exports.names.get(fn.name)
+                ? fn.name
+                : (exports.defaultLocal === fn.name ? "default" : null);
+            if (!exportedName)
+                continue;
+            const taintedParams = new Map();
+            for (let pIdx = 0; pIdx < fn.params.length; pIdx++) {
+                const param = fn.params[pIdx];
+                if (!param)
+                    continue;
+                const paramAsTainted = checkParamFlowsToSink(param, fn.body, fn.startLine);
+                if (paramAsTainted) {
+                    taintedParams.set(pIdx, paramAsTainted);
+                }
+            }
+            if (taintedParams.size > 0) {
+                taintedExports.push({ file: file.path, exportName: exportedName === "default" ? fn.name : exportedName, taintedParams });
+            }
+        }
+    }
+    return taintedExports;
+}
+// Taint source patterns
+const TAINT_SOURCES = [
+    { pattern: /(?:req|request)\.(?:body|query|params|headers|cookies)\b/g, type: "http-input" },
+    { pattern: /(?:formData|searchParams)\.get\s*\(/g, type: "form-input" },
+    { pattern: /(?:params|searchParams)\s*[\.\[]/g, type: "url-params" },
+    { pattern: /(?:await\s+)?(?:request|req)\.(?:json|text|formData)\s*\(\)/g, type: "request-body" },
+    { pattern: /new\s+URL\s*\([\s\S]*?(?:req|request)/g, type: "url-input" },
+    { pattern: /(?:event|e)\.(?:target|currentTarget)\.(?:value|textContent|innerHTML)/g, type: "dom-input" },
+];
+function findTaintedCallSites(files, allImports, taintedExports) {
+    const findings = [];
+    const exportsByPath = new Map();
+    for (const te of taintedExports) {
+        const key = stripExtension(te.file);
+        const existing = exportsByPath.get(key) ?? [];
+        existing.push(te);
+        exportsByPath.set(key, existing);
+    }
+    for (const file of files) {
+        const fileImports = allImports.filter(imp => imp.importer === file.path);
+        const lines = file.content.split("\n");
+        // Find tainted variables in this file
+        const taintedVars = [];
+        const assignPattern = /(?:const|let|var)\s+([\w$]+)\s*=\s*(.*)/;
+        for (let i = 0; i < lines.length; i++) {
+            const m = assignPattern.exec(lines[i]);
+            if (!m)
+                continue;
+            for (const src of TAINT_SOURCES) {
+                src.pattern.lastIndex = 0;
+                if (src.pattern.test(m[2])) {
+                    taintedVars.push({ name: m[1], line: i + 1, sourceType: src.type });
+                    break;
+                }
+            }
+        }
+        // Propagate taint within file
+        let changed = true;
+        let iterations = 0;
+        const taintedSet = new Set(taintedVars.map(v => v.name));
+        while (changed && iterations < 10) {
+            changed = false;
+            iterations++;
+            for (let i = 0; i < lines.length; i++) {
+                const m = assignPattern.exec(lines[i]);
+                if (!m || taintedSet.has(m[1]))
+                    continue;
+                for (const t of taintedSet) {
+                    if (m[2].includes(t)) {
+                        taintedSet.add(m[1]);
+                        taintedVars.push({ name: m[1], line: i + 1, sourceType: "propagated" });
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+        }
+        for (const imp of fileImports) {
+            const sourceExports = exportsByPath.get(imp.source) ?? exportsByPath.get(stripExtension(imp.source)) ?? [];
+            if (sourceExports.length === 0)
+                continue;
+            for (const te of sourceExports) {
+                let localName = null;
+                for (const [local, exported] of imp.names) {
+                    if (exported === te.exportName) {
+                        localName = local;
+                        break;
+                    }
+                }
+                if (!localName && imp.defaultName && (te.exportName === "default" || te.exportName === imp.defaultName)) {
+                    localName = imp.defaultName;
+                }
+                if (!localName && imp.namespaceName) {
+                    localName = `${imp.namespaceName}.${te.exportName}`;
+                }
+                if (!localName)
+                    continue;
+                const callPattern = new RegExp(`(?:await\\s+)?${localName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`, "g");
+                for (let i = 0; i < lines.length; i++) {
+                    callPattern.lastIndex = 0;
+                    if (!callPattern.test(lines[i]))
+                        continue;
+                    const args = extractCallArgs(lines[i], localName);
+                    for (const [paramIdx, sinkInfo] of te.taintedParams) {
+                        const argAtIdx = args[paramIdx];
+                        if (!argAtIdx)
+                            continue;
+                        const taintSource = taintedVars.find(v => argAtIdx.includes(v.name));
+                        if (!taintSource) {
+                            let isInlineTainted = false;
+                            let inlineSourceType = "";
+                            for (const src of TAINT_SOURCES) {
+                                src.pattern.lastIndex = 0;
+                                if (src.pattern.test(argAtIdx)) {
+                                    isInlineTainted = true;
+                                    inlineSourceType = src.type;
+                                    break;
+                                }
+                            }
+                            if (!isInlineTainted)
+                                continue;
+                            findings.push({
+                                source: { file: file.path, type: inlineSourceType, line: i + 1, variable: "(inline)" },
+                                sink: { file: te.file, type: sinkInfo.sinkType, line: sinkInfo.sinkLine, code: sinkInfo.sinkCode },
+                                chain: [
+                                    `[SOURCE] ${inlineSourceType} in ${file.path}:${i + 1}`,
+                                    `[CALL] ${localName}() in ${file.path}:${i + 1}`,
+                                    `[SINK] ${sinkInfo.sinkType} in ${te.file}:${sinkInfo.sinkLine}`,
+                                ],
+                                severity: deriveSeverity(sinkInfo.sinkType),
+                                description: `Tainted data flows from ${file.path} through ${localName}() into ${sinkInfo.sinkType} sink in ${te.file}.`,
+                                fix: `Validate/sanitize input before passing to ${localName}(). ${getSinkFix(sinkInfo.sinkType)}`,
+                            });
+                            continue;
+                        }
+                        findings.push({
+                            source: { file: file.path, type: taintSource.sourceType, line: taintSource.line, variable: taintSource.name },
+                            sink: { file: te.file, type: sinkInfo.sinkType, line: sinkInfo.sinkLine, code: sinkInfo.sinkCode },
+                            chain: [
+                                `[SOURCE] ${taintSource.sourceType} -> ${taintSource.name} in ${file.path}:${taintSource.line}`,
+                                `[CALL] ${localName}(${taintSource.name}) in ${file.path}:${i + 1}`,
+                                `[SINK] ${sinkInfo.sinkType} in ${te.file}:${sinkInfo.sinkLine}`,
+                            ],
+                            severity: deriveSeverity(sinkInfo.sinkType),
+                            description: `Tainted data flows from ${taintSource.sourceType} in ${file.path} through ${localName}() into ${sinkInfo.sinkType} sink in ${te.file}.`,
+                            fix: `Validate/sanitize '${taintSource.name}' before passing to ${localName}(). ${getSinkFix(sinkInfo.sinkType)}`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return findings;
+}
+function extractCallArgs(line, funcName) {
+    const escapedName = funcName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const callMatch = new RegExp(`(?:await\\s+)?${escapedName}\\s*\\((.*)\\)`, "s").exec(line);
+    if (!callMatch)
+        return [];
+    const argsStr = callMatch[1];
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of argsStr) {
+        if (ch === "(" || ch === "[" || ch === "{")
+            depth++;
+        if (ch === ")" || ch === "]" || ch === "}")
+            depth--;
+        if (ch === "," && depth === 0) {
+            args.push(current.trim());
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}
+function deriveSeverity(sinkType) {
+    if (sinkType === "code-injection" || sinkType === "sql-injection")
+        return "critical";
+    if (sinkType === "xss" || sinkType === "path-traversal")
+        return "high";
+    return "medium";
+}
+function getSinkFix(sinkType) {
+    const fixes = {
+        "sql-injection": "Use parameterized queries instead of string interpolation.",
+        "code-injection": "Never pass user input to eval() or Function constructor.",
+        "xss": "Use textContent instead of innerHTML, or sanitize with DOMPurify.",
+        "open-redirect": "Validate redirect URLs against a trusted domain allowlist.",
+        "path-traversal": "Validate file paths with path.resolve() and check they stay within allowed directories.",
+    };
+    return fixes[sinkType] ?? "Sanitize input before use in sensitive operations.";
+}
+// --- Public API ---
+export function analyzeCrossFileTaint(files) {
+    const perFileFindings = new Map();
+    for (const file of files) {
+        const lang = detectLang(file.path);
+        if (lang === "unknown")
+            continue;
+        const findings = analyzeTaint(file.content, lang);
+        if (findings.length > 0)
+            perFileFindings.set(file.path, findings);
+    }
+    const allImports = [];
+    for (const file of files) {
+        allImports.push(...parseImports(file.path, file.content));
+    }
+    const taintedExports = findTaintedExports(files);
+    const crossFileFindings = findTaintedCallSites(files, allImports, taintedExports);
+    return { crossFileFindings, perFileFindings };
+}
+function detectLang(path) {
+    if (/\.(ts|tsx|mts|cts)$/.test(path))
+        return "typescript";
+    if (/\.(js|jsx|mjs|cjs)$/.test(path))
+        return "javascript";
+    return "unknown";
+}
+export function formatCrossFileTaintFindings(crossFileFindings, perFileFindings, format) {
+    const perFileSummary = [];
+    for (const [file, findings] of perFileFindings) {
+        perFileSummary.push({ file, findings });
+    }
+    if (format === "json") {
+        return JSON.stringify({
+            summary: {
+                crossFileFlows: crossFileFindings.length,
+                perFileFlows: perFileSummary.reduce((sum, f) => sum + f.findings.length, 0),
+                total: crossFileFindings.length + perFileSummary.reduce((sum, f) => sum + f.findings.length, 0),
+                critical: crossFileFindings.filter(f => f.severity === "critical").length +
+                    perFileSummary.reduce((sum, f) => sum + f.findings.filter(ff => ff.severity === "critical").length, 0),
+                high: crossFileFindings.filter(f => f.severity === "high").length +
+                    perFileSummary.reduce((sum, f) => sum + f.findings.filter(ff => ff.severity === "high").length, 0),
+                medium: crossFileFindings.filter(f => f.severity === "medium").length +
+                    perFileSummary.reduce((sum, f) => sum + f.findings.filter(ff => ff.severity === "medium").length, 0),
+            },
+            crossFileFindings: crossFileFindings.map(f => ({
+                severity: f.severity, source: f.source, sink: f.sink,
+                chain: f.chain, description: f.description, fix: f.fix,
+            })),
+            perFileFindings: perFileSummary.map(pf => ({
+                file: pf.file,
+                findings: pf.findings.map(f => ({
+                    severity: f.severity, source: f.source, sink: f.sink,
+                    chain: f.chain, description: f.description, fix: f.fix,
+                })),
+            })),
+        });
+    }
+    const lines = [];
+    const totalCross = crossFileFindings.length;
+    const totalPerFile = perFileSummary.reduce((sum, f) => sum + f.findings.length, 0);
+    lines.push(`## Cross-File Dataflow Analysis`);
+    lines.push(``);
+    lines.push(`| Scope | Flows |`);
+    lines.push(`|-------|-------|`);
+    lines.push(`| Cross-file | ${totalCross} |`);
+    lines.push(`| Per-file | ${totalPerFile} |`);
+    lines.push(`| **Total** | **${totalCross + totalPerFile}** |`);
+    lines.push(``);
+    if (totalCross > 0) {
+        lines.push(`### Cross-File Tainted Flows`);
+        lines.push(``);
+        const severityOrder = { critical: 0, high: 1, medium: 2 };
+        crossFileFindings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+        for (const f of crossFileFindings) {
+            lines.push(`#### [${f.severity.toUpperCase()}] ${f.sink.type}`);
+            lines.push(`**Source:** \`${f.source.file}\`:${f.source.line} (${f.source.type})`);
+            lines.push(`**Sink:** \`${f.sink.file}\`:${f.sink.line} (${f.sink.type})`);
+            lines.push(`**Variable:** \`${f.source.variable}\``);
+            lines.push(`**Flow chain:**`);
+            for (const step of f.chain) {
+                lines.push(`  ${step}`);
+            }
+            lines.push(`${f.description}`);
+            lines.push(`**Fix:** ${f.fix}`);
+            lines.push(``);
+        }
+    }
+    if (totalPerFile > 0) {
+        lines.push(`### Per-File Tainted Flows`);
+        lines.push(``);
+        for (const pf of perFileSummary) {
+            lines.push(`**${pf.file}:** ${pf.findings.length} flow(s)`);
+            for (const f of pf.findings) {
+                lines.push(`- [${f.severity.toUpperCase()}] ${f.source.type} (line ${f.source.line}) -> ${f.sink.type} (line ${f.sink.line})`);
+            }
+            lines.push(``);
+        }
+    }
+    if (totalCross === 0 && totalPerFile === 0) {
+        lines.push(`No tainted data flows detected across files.`);
+    }
+    return lines.join("\n");
+}
+// Exported for testing
+export { parseImports, parseExports, extractFunctions, findTaintedExports, normalizePath, stripExtension };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "guardvibe",
-  "version": "2.4.4",
-  "description": "Security MCP for vibe coding. 313 rules, 25 tools for Next.js, Supabase, Clerk, Stripe, Prisma, tRPC, Hono, GraphQL, Convex, Turso, Uploadthing, AI SDK, and the full AI-generated stack.",
+  "version": "2.5.0",
+  "mcpName": "io.github.goklab/guardvibe",
+  "description": "Security MCP for vibe coding. 313 rules, 26 tools for Next.js, Supabase, Clerk, Stripe, Prisma, tRPC, Hono, GraphQL, Convex, Turso, Uploadthing, AI SDK, and the full AI-generated stack.",
   "type": "module",
   "bin": {
     "guardvibe": "build/cli.js",
@@ -108,7 +109,7 @@
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.5.2",
     "c8": "^11.0.0",
     "eslint": "^10.2.0",
     "tsx": "^4.21.0",