@syke1/mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,518 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const child_process_1 = require("child_process");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const path = __importStar(require("path"));
+const graph_1 = require("./graph");
+const plugin_1 = require("./languages/plugin");
+const analyze_impact_1 = require("./tools/analyze-impact");
+const gate_build_1 = require("./tools/gate-build");
+const analyzer_1 = require("./ai/analyzer");
+const server_1 = require("./web/server");
+const file_cache_1 = require("./watcher/file-cache");
+const validator_1 = require("./license/validator");
+// Configuration — auto-detect if env vars not set
+let currentProjectRoot = process.env.SYKE_currentProjectRoot || (0, plugin_1.detectProjectRoot)();
+let currentPackageName = process.env.SYKE_currentPackageName || (0, plugin_1.detectPackageName)(currentProjectRoot, (0, plugin_1.detectLanguages)(currentProjectRoot));
+const WEB_PORT = parseInt(process.env.SYKE_WEB_PORT || "3333", 10);
+function resolveFilePath(fileArg, projectRoot, sourceDir) {
+    const srcDir = sourceDir || path.join(projectRoot, "src");
+    const srcDirName = path.basename(srcDir); // "lib" or "src"
+    if (path.isAbsolute(fileArg)) {
+        return path.normalize(fileArg);
+    }
+    if (fileArg.startsWith(srcDirName + "/") || fileArg.startsWith(srcDirName + "\\")) {
+        return path.normalize(path.join(projectRoot, fileArg));
+    }
+    return path.normalize(path.join(srcDir, fileArg));
+}
+// License state — set at startup
+let licenseStatus = { plan: "free", source: "default" };
+// Free tier limits
+const FREE_MAX_FILES = 50;
+const FREE_MAX_HUB_FILES = 3;
+/**
+ * Check if a resolved file path is within the free tier limit.
+ * Free set = first 50 files sorted alphabetically by relative path.
+ */
+function isFileInFreeSet(resolvedPath, graph) {
+    if (licenseStatus.plan === "pro")
+        return true;
+    const allFiles = [...graph.files].sort();
+    const idx = allFiles.indexOf(resolvedPath);
+    return idx >= 0 && idx < FREE_MAX_FILES;
+}
+const PRO_UPGRADE_MSG = "This file exceeds the Free tier limit (50 files). Upgrade to Pro for unlimited analysis: https://syke.cloud/dashboard/";
+async function main() {
+    if (!currentProjectRoot) {
+        console.error("[syke] ERROR: Could not detect project root. Set SYKE_currentProjectRoot or run from project directory.");
+        process.exit(1);
+    }
+    // Check license before starting
+    licenseStatus = await (0, validator_1.checkLicense)();
+    // Show device binding errors
+    if (licenseStatus.error) {
+        console.error(`[syke] LICENSE ERROR: ${licenseStatus.error}`);
+    }
+    // Graceful shutdown — deactivate session so another device can use the license
+    const shutdown = async () => {
+        console.error("[syke] Shutting down — deactivating session...");
+        await (0, validator_1.stopAndDeactivate)();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    const server = new index_js_1.Server({ name: "syke", version: "0.4.0" }, { capabilities: { tools: {} } });
+    // List tools
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "gate_build",
+                description: "MANDATORY: Call this BEFORE any build, deploy, or test command. "
+                    + "Returns PASS, WARN, or FAIL verdict with detailed reasons. "
+                    + "If FAIL, do NOT proceed with build — fix issues first. "
+                    + "Always call this as the final check before any compilation or deployment.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional list of modified files (absolute or relative to source directory)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "analyze_impact",
+                description: "Analyze which files are impacted when a given file is modified. Returns direct and transitive dependents with risk level.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file: {
+                            type: "string",
+                            description: 'Source file path (absolute or relative to source directory). Example: "features/auth/data/auth_repository.dart"',
+                        },
+                    },
+                    required: ["file"],
+                },
+            },
+            {
+                name: "check_safe",
+                description: "Quick safety check for modifying a file. Returns a one-line verdict: HIGH/MEDIUM/LOW/NONE risk with impacted file count.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file: { type: "string", description: "Source file path to check" },
+                    },
+                    required: ["file"],
+                },
+            },
+            {
+                name: "get_dependencies",
+                description: "List the internal files that a given file imports (forward dependencies).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file: { type: "string", description: "Source file path" },
+                    },
+                    required: ["file"],
+                },
+            },
+            {
+                name: "get_hub_files",
+                description: "Rank files by how many other files depend on them. High-hub files are risky to modify.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        top_n: {
+                            type: "number",
+                            description: "Number of top files to return (default 10)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "refresh_graph",
+                description: "Re-scan all source files and rebuild the dependency graph. Use after adding/removing files.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "ai_analyze",
+                description: "Use Gemini AI to perform semantic analysis on a file. Reads the file's source code and its dependents to explain what might break when modified and how to safely make changes. Returns Korean analysis.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file: {
+                            type: "string",
+                            description: "Source file path to analyze with AI",
+                        },
+                    },
+                    required: ["file"],
+                },
+            },
+            {
+                name: "check_warnings",
+                description: "Check for unresolved warnings from SYKE's real-time monitoring. Returns warnings about file changes that may have broken dependents. Use this AFTER modifying files to see if SYKE caught any issues you may have missed. Pass acknowledge=true to clear warnings after reading them.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        acknowledge: {
+                            type: "boolean",
+                            description: "If true, mark all warnings as acknowledged after returning them (default: false)",
+                        },
+                    },
+                },
+            },
+        ],
+    }));
+    // Handle tool calls
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        switch (name) {
+            case "gate_build": {
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                const files = args.files?.map((f) => resolveFilePath(f, currentProjectRoot, graph.sourceDir));
+                const result = (0, gate_build_1.gateCheck)(graph, files);
+                return {
+                    content: [
+                        { type: "text", text: (0, gate_build_1.formatGateResult)(result) },
+                    ],
+                    isError: result.verdict === "FAIL",
+                };
+            }
+            case "analyze_impact": {
+                const file = args.file;
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                const resolved = resolveFilePath(file, currentProjectRoot, graph.sourceDir);
+                if (!graph.files.has(resolved)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `File not found in dependency graph: ${file}\nResolved to: ${resolved}\nTip: Use a path relative to the source directory`,
+                            },
+                        ],
+                    };
+                }
+                if (!isFileInFreeSet(resolved, graph)) {
+                    return { content: [{ type: "text", text: PRO_UPGRADE_MSG }] };
+                }
+                const result = (0, analyze_impact_1.analyzeImpact)(resolved, graph);
+                const lines = [
+                    `## Impact Analysis: ${result.relativePath}`,
+                    `**Risk Level:** ${result.riskLevel}`,
+                    `**Total impacted files:** ${result.totalImpacted}`,
+                    "",
+                ];
+                if (result.directDependents.length > 0) {
+                    lines.push(`### Direct Dependents (${result.directDependents.length})`);
+                    for (const d of result.directDependents) {
+                        lines.push(`- ${d}`);
+                    }
+                }
+                if (result.transitiveDependents.length > 0) {
+                    lines.push("");
+                    lines.push(`### Transitive Dependents (${result.transitiveDependents.length})`);
+                    for (const d of result.transitiveDependents) {
+                        lines.push(`- ${d}`);
+                    }
+                }
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
+            case "check_safe": {
+                const file = args.file;
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                const resolved = resolveFilePath(file, currentProjectRoot, graph.sourceDir);
+                if (!graph.files.has(resolved)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `UNKNOWN — file not found in graph: ${file}`,
+                            },
+                        ],
+                    };
+                }
+                if (!isFileInFreeSet(resolved, graph)) {
+                    return { content: [{ type: "text", text: PRO_UPGRADE_MSG }] };
+                }
+                const result = (0, analyze_impact_1.analyzeImpact)(resolved, graph);
+                const rel = path.relative(graph.sourceDir, resolved).replace(/\\/g, "/");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${result.riskLevel} — ${rel} impacts ${result.totalImpacted} file(s)`,
+                        },
+                    ],
+                };
+            }
+            case "get_dependencies": {
+                const file = args.file;
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                const resolved = resolveFilePath(file, currentProjectRoot, graph.sourceDir);
+                if (!graph.files.has(resolved)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `File not found in graph: ${file}`,
+                            },
+                        ],
+                    };
+                }
+                if (!isFileInFreeSet(resolved, graph)) {
+                    return { content: [{ type: "text", text: PRO_UPGRADE_MSG }] };
+                }
+                const deps = graph.forward.get(resolved) || [];
+                const rel = path.relative(graph.sourceDir, resolved).replace(/\\/g, "/");
+                if (deps.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${rel} has no internal dependencies.`,
+                            },
+                        ],
+                    };
+                }
+                const lines = [`## Dependencies of ${rel}`, ""];
+                for (const d of deps) {
+                    lines.push(`- ${path.relative(graph.sourceDir, d).replace(/\\/g, "/")}`);
+                }
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
+            case "get_hub_files": {
+                const requestedN = args.top_n || 10;
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                // Free: limited to top 3, Pro: unlimited
+                const maxN = licenseStatus.plan === "pro" ? requestedN : Math.min(requestedN, FREE_MAX_HUB_FILES);
+                const hubs = (0, analyze_impact_1.getHubFiles)(graph, maxN);
+                const lines = [
+                    `## Hub Files (Top ${hubs.length})`,
+                    "",
+                    "| # | File | Dependents | Risk |",
+                    "|---|------|-----------|------|",
+                ];
+                hubs.forEach((h, i) => {
+                    lines.push(`| ${i + 1} | ${h.relativePath} | ${h.dependentCount} | ${h.riskLevel} |`);
+                });
+                lines.push("");
+                lines.push(`Total files in graph: ${graph.files.size}`);
+                if (licenseStatus.plan !== "pro" && requestedN > FREE_MAX_HUB_FILES) {
+                    lines.push("");
+                    lines.push(`Free tier shows top ${FREE_MAX_HUB_FILES} hub files. Upgrade to Pro for full ranking: https://syke.cloud/dashboard/`);
+                }
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
+            case "refresh_graph": {
+                const graph = (0, graph_1.refreshGraph)(currentProjectRoot, currentPackageName);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Graph refreshed (${graph.languages.join("+")}): ${graph.files.size} files scanned.`,
+                        },
+                    ],
+                };
+            }
+            case "ai_analyze": {
+                // Pro-only feature
+                if (licenseStatus.plan !== "pro") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "ai_analyze requires SYKE Pro. Upgrade at https://syke.cloud/dashboard/\n\nSet SYKE_LICENSE_KEY in your MCP config to activate Pro features.",
+                            },
+                        ],
+                    };
+                }
+                const file = args.file;
+                const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+                const resolved = resolveFilePath(file, currentProjectRoot, graph.sourceDir);
+                if (!graph.files.has(resolved)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `File not found in graph: ${file}`,
+                            },
+                        ],
+                    };
+                }
+                const impactResult = (0, analyze_impact_1.analyzeImpact)(resolved, graph);
+                const aiResult = await (0, analyzer_1.analyzeWithAI)(resolved, impactResult, graph);
+                return {
+                    content: [{ type: "text", text: aiResult }],
+                };
+            }
+            case "check_warnings": {
+                const shouldAck = args.acknowledge || false;
+                const warnings = (0, server_1.getUnacknowledgedWarnings)();
+                if (warnings.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No unresolved warnings. All clear.",
+                            },
+                        ],
+                    };
+                }
+                const lines = [
+                    `SYKE detected ${warnings.length} unresolved warning(s):`,
+                    "",
+                ];
+                for (const w of warnings) {
+                    const time = new Date(w.timestamp).toLocaleTimeString();
+                    lines.push(`### [${w.riskLevel}] ${w.file} (${time})`);
+                    lines.push(`**Summary:** ${w.summary}`);
+                    if (w.brokenImports.length > 0) {
+                        lines.push(`**Broken imports:** ${w.brokenImports.join(", ")}`);
+                    }
+                    if (w.sideEffects.length > 0) {
+                        lines.push(`**Side effects:** ${w.sideEffects.join("; ")}`);
+                    }
+                    if (w.warnings.length > 0) {
+                        lines.push(`**Warnings:** ${w.warnings.join("; ")}`);
+                    }
+                    if (w.suggestion) {
+                        lines.push(`**Suggestion:** ${w.suggestion}`);
+                    }
+                    lines.push(`**Affected files:** ${w.affectedCount}`);
+                    lines.push("");
+                }
+                if (shouldAck) {
+                    const count = (0, server_1.acknowledgeWarnings)();
+                    lines.push(`---`);
+                    lines.push(`${count} warning(s) acknowledged.`);
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        { type: "text", text: `Unknown tool: ${name}` },
+                    ],
+                    isError: true,
+                };
+        }
+    });
+    // Pre-warm the graph
+    const detectedLangs = (0, plugin_1.detectLanguages)(currentProjectRoot).map(p => p.name).join(", ") || "none";
+    console.error(`[syke] Starting SYKE MCP Server v0.4.0`);
+    console.error(`[syke] License: ${licenseStatus.plan.toUpperCase()} (${licenseStatus.source})`);
+    if (licenseStatus.plan === "pro") {
+        console.error(`[syke] Pro activated for: ${licenseStatus.email || "unknown"}`);
+    }
+    else {
+        console.error(`[syke] Free tier: ${FREE_MAX_FILES} file limit, ai_analyze disabled`);
+        console.error(`[syke] Upgrade at https://syke.cloud/dashboard/`);
+    }
+    console.error(`[syke] Project root: ${currentProjectRoot}`);
+    console.error(`[syke] Detected languages: ${detectedLangs}`);
+    console.error(`[syke] Package name: ${currentPackageName}`);
+    const graph = (0, graph_1.getGraph)(currentProjectRoot, currentPackageName);
+    // Free tier: warn if over file limit
+    if (licenseStatus.plan === "free" && graph.files.size > FREE_MAX_FILES) {
+        console.error(`[syke] WARNING: Free tier limited to ${FREE_MAX_FILES} files. Your project has ${graph.files.size} files.`);
+        console.error(`[syke] Only the first ${FREE_MAX_FILES} files will be analyzed. Upgrade to Pro for unlimited files.`);
+    }
+    // Initialize file cache (load ALL source files into memory)
+    let fileCache = new file_cache_1.FileCache(currentProjectRoot);
+    fileCache.initialize();
+    fileCache.startWatching();
+    // Switch project callback — reinitializes graph + file cache
+    function switchProject(newRoot) {
+        currentProjectRoot = newRoot;
+        const plugins = (0, plugin_1.detectLanguages)(newRoot);
+        currentPackageName = (0, plugin_1.detectPackageName)(newRoot, plugins);
+        // Stop old file cache and create new one
+        fileCache.stop();
+        fileCache = new file_cache_1.FileCache(newRoot);
+        fileCache.initialize();
+        fileCache.startWatching();
+        // Rebuild graph
+        const graph = (0, graph_1.refreshGraph)(newRoot, currentPackageName);
+        console.error(`[syke] Switched to project: ${newRoot}`);
+        console.error(`[syke] Languages: ${plugins.map(p => p.name).join(", ")}`);
+        console.error(`[syke] Package: ${currentPackageName}`);
+        console.error(`[syke] Files: ${graph.files.size}`);
+        let edgeCount = 0;
+        for (const deps of graph.forward.values())
+            edgeCount += deps.length;
+        return {
+            projectRoot: newRoot,
+            packageName: currentPackageName,
+            languages: graph.languages,
+            fileCount: graph.files.size,
+            edgeCount,
+        };
+    }
+    // Start Express web server with file cache for SSE
+    const webApp = (0, server_1.createWebServer)(() => (0, graph_1.getGraph)(currentProjectRoot, currentPackageName), fileCache, switchProject, () => currentProjectRoot, () => currentPackageName, () => licenseStatus);
+    webApp.listen(WEB_PORT, () => {
+        const dashUrl = `http://localhost:${WEB_PORT}`;
+        console.error(`[syke] Web dashboard: ${dashUrl}`);
+        // Auto-open browser (disable with SYKE_NO_BROWSER=1)
+        if (process.env.SYKE_NO_BROWSER !== "1") {
+            const cmd = process.platform === "win32" ? `start ${dashUrl}`
+                : process.platform === "darwin" ? `open ${dashUrl}`
+                    : `xdg-open ${dashUrl}`;
+            (0, child_process_1.exec)(cmd, () => { });
+        }
+    });
+    // Connect via stdio
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("[syke] MCP server connected via stdio");
+}
+main().catch((err) => {
+    console.error("[syke] Fatal error:", err);
+    process.exit(1);
+});

package/dist/languages/cpp.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from "./plugin";
+export declare const cppPlugin: LanguagePlugin;

package/dist/languages/cpp.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppPlugin = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plugin_1 = require("./plugin");
+const INCLUDE_RE = /^#include\s+"(.+?)"/;
+exports.cppPlugin = {
+    id: "cpp",
+    name: "C/C++",
+    extensions: [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hxx"],
+    codeBlockLang: "cpp",
+    detectProject(root) {
+        return fs.existsSync(path.join(root, "CMakeLists.txt")) ||
+            fs.existsSync(path.join(root, "Makefile")) ||
+            fs.existsSync(path.join(root, "meson.build"));
+    },
+    getSourceDirs(root) {
+        const dirs = [];
+        const srcDir = path.join(root, "src");
+        const includeDir = path.join(root, "include");
+        if (fs.existsSync(srcDir))
+            dirs.push(srcDir);
+        if (fs.existsSync(includeDir))
+            dirs.push(includeDir);
+        if (dirs.length === 0)
+            dirs.push(root);
+        return dirs;
+    },
+    getPackageName(root) {
+        try {
+            const cmake = fs.readFileSync(path.join(root, "CMakeLists.txt"), "utf-8");
+            const match = cmake.match(/project\s*\(\s*(\w+)/i);
+            return match ? match[1] : path.basename(root);
+        }
+        catch {
+            return path.basename(root);
+        }
+    },
+    discoverFiles(dir) {
+        return (0, plugin_1.discoverAllFiles)(dir, [".cpp", ".cc", ".cxx", ".c", ".h", ".hpp", ".hxx"]);
+    },
+    parseImports(filePath, projectRoot, sourceDir) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return [];
+        }
+        const fileDir = path.dirname(filePath);
+        const imports = [];
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            // Only process local includes (#include "..."), skip system <...>
+            const match = trimmed.match(INCLUDE_RE);
+            if (!match)
+                continue;
+            const includePath = match[1];
+            // Try resolving: relative to file, then to sourceDir, then to projectRoot
+            const candidates = [
+                path.normalize(path.resolve(fileDir, includePath)),
+                path.normalize(path.join(sourceDir, includePath)),
+                path.normalize(path.join(projectRoot, "include", includePath)),
+                path.normalize(path.join(projectRoot, includePath)),
+            ];
+            for (const c of candidates) {
+                if (fs.existsSync(c)) {
+                    imports.push(c);
+                    break;
+                }
+            }
+        }
+        return imports;
+    },
+};

package/dist/languages/dart.d.ts

@@ -0,0 +1,2 @@
+import { LanguagePlugin } from "./plugin";
+export declare const dartPlugin: LanguagePlugin;