@syke1/mcp-server 1.0.0

package/dist/web/server.js

@@ -0,0 +1,744 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addWarning = addWarning;
+exports.getUnacknowledgedWarnings = getUnacknowledgedWarnings;
+exports.acknowledgeWarnings = acknowledgeWarnings;
+exports.getAllWarnings = getAllWarnings;
+exports.createWebServer = createWebServer;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const express_1 = __importDefault(require("express"));
+const plugin_1 = require("../languages/plugin");
+const analyze_impact_1 = require("../tools/analyze-impact");
+const analyzer_1 = require("../ai/analyzer");
+const realtime_analyzer_1 = require("../ai/realtime-analyzer");
+function resolveFilePath(fileArg, projectRoot, sourceDir) {
+    const srcDir = sourceDir || path.join(projectRoot, "lib");
+    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));
+}
+function classifyFile(relPath) {
+    const lower = relPath.toLowerCase();
+    const fileName = lower.split("/").pop() || "";
+    // ── Layer — try plugin-specific classification first ──
+    let layer = "UTIL";
+    const plugin = (0, plugin_1.getPluginForFile)(relPath);
+    const pluginLayer = plugin?.classifyLayer?.(relPath);
+    if (pluginLayer) {
+        layer = pluginLayer;
+    }
+    else {
+        // FE: presentation layer, UI components
+        if (lower.includes("/presentation/") ||
+            lower.includes("/widgets/") ||
+            lower.includes("/screens/") ||
+            lower.includes("/pages/") ||
+            lower.includes("web/public/") ||
+            lower.includes("components/") ||
+            fileName.endsWith("_screen.dart") ||
+            fileName.endsWith("_page.dart") ||
+            fileName.endsWith("_widget.dart") ||
+            fileName.endsWith("_dialog.dart") ||
+            fileName.endsWith("_view.dart") ||
+            fileName.endsWith("_card.dart") ||
+            fileName.endsWith("_tile.dart") ||
+            fileName.endsWith("_form.dart") ||
+            fileName.endsWith("_bottom_sheet.dart") ||
+            fileName.endsWith(".html") ||
+            fileName.endsWith(".css") ||
+            fileName.endsWith(".jsx") ||
+            fileName.endsWith(".tsx")) {
+            layer = "FE";
+        }
+        // API: network/remote layer
+        else if (lower.includes("/api/") ||
+            fileName.includes("cloud_function") ||
+            fileName.endsWith("_api.dart") ||
+            fileName.endsWith("_client.dart") ||
+            fileName.endsWith("_remote.dart") ||
+            fileName.includes("_datasource") ||
+            fileName.includes("_data_source") ||
+            lower.includes("web/server") ||
+            fileName.endsWith("server.ts") ||
+            fileName.endsWith("server.js")) {
+            layer = "API";
+        }
+        // DB: data models, entities
+        else if (lower.includes("/models/") ||
+            lower.includes("/entities/") ||
+            fileName.endsWith("_model.dart") ||
+            fileName.endsWith("_entity.dart") ||
+            fileName.endsWith("_dto.dart") ||
+            fileName.endsWith("_schema.dart") ||
+            fileName.endsWith(".model.ts") ||
+            fileName.endsWith(".entity.ts") ||
+            fileName.endsWith(".schema.ts")) {
+            layer = "DB";
+        }
+        // BE: business logic, repositories, services, state management
+        else if (lower.includes("/data/") ||
+            lower.includes("/domain/") ||
+            lower.includes("/application/") ||
+            lower.includes("/providers/") ||
+            lower.includes("/notifiers/") ||
+            lower.includes("tools/") ||
+            lower.includes("ai/") ||
+            lower.includes("watcher/") ||
+            fileName.endsWith("_repository.dart") ||
+            fileName.endsWith("_service.dart") ||
+            fileName.endsWith("_provider.dart") ||
+            fileName.endsWith("_notifier.dart") ||
+            fileName.endsWith("_controller.dart") ||
+            fileName.endsWith("_usecase.dart") ||
+            fileName.endsWith("_state.dart") ||
+            fileName.endsWith("_bloc.dart") ||
+            fileName.endsWith("_cubit.dart") ||
+            fileName.endsWith(".service.ts") ||
+            fileName.endsWith(".controller.ts")) {
+            layer = "BE";
+        }
+        // CONFIG: app config, themes, routing, constants
+        else if (lower.includes("/config/") ||
+            lower.includes("/theme/") ||
+            lower.includes("/router/") ||
+            lower.includes("/routing/") ||
+            lower.startsWith("app/") ||
+            fileName.endsWith("_config.dart") ||
+            fileName.endsWith("_theme.dart") ||
+            fileName.endsWith("_constants.dart") ||
+            fileName.endsWith("_routes.dart") ||
+            fileName === "main.dart" ||
+            fileName === "index.ts" ||
+            fileName === "index.js" ||
+            fileName.endsWith(".config.ts") ||
+            fileName.endsWith(".config.js")) {
+            layer = "CONFIG";
+        }
+        // UTIL: utilities, helpers, extensions, shared
+        else if (lower.includes("/utils/") ||
+            lower.includes("/helpers/") ||
+            lower.includes("/extensions/") ||
+            lower.includes("shared/") ||
+            lower.includes("languages/") ||
+            fileName.endsWith("_util.dart") ||
+            fileName.endsWith("_helper.dart") ||
+            fileName.endsWith("_extension.dart") ||
+            fileName.endsWith("_mixin.dart") ||
+            fileName.endsWith(".util.ts") ||
+            fileName.endsWith(".helper.ts")) {
+            layer = "UTIL";
+        }
+    } // end plugin fallback
+    // ── Action (infer from filename patterns) ──
+    let action = "X";
+    if (fileName.includes("create") || fileName.includes("add") || fileName.includes("register") || fileName.includes("new")) {
+        action = "C";
+    }
+    else if (fileName.includes("list") || fileName.includes("get") || fileName.includes("fetch") || fileName.includes("show") || fileName.includes("detail") || fileName.includes("_screen") || fileName.includes("_page")) {
+        action = "R";
+    }
+    else if (fileName.includes("update") || fileName.includes("edit") || fileName.includes("modify") || fileName.includes("change")) {
+        action = "U";
+    }
+    else if (fileName.includes("delete") || fileName.includes("remove")) {
+        action = "D";
+    }
+    // ── Environment ──
+    const env = (fileName.includes("_test") || fileName.includes("_mock") || fileName.includes("_fake") || lower.includes("/test/")) ? "DEV" : "PROD";
+    return { layer, action, env };
+}
+const warningStore = [];
+const MAX_WARNINGS = 50;
+function addWarning(analysis) {
+    // Only store non-SAFE warnings
+    if (analysis.riskLevel === "SAFE")
+        return;
+    warningStore.unshift({
+        file: analysis.file,
+        riskLevel: analysis.riskLevel,
+        summary: analysis.summary,
+        brokenImports: analysis.brokenImports,
+        sideEffects: analysis.sideEffects,
+        warnings: analysis.warnings,
+        suggestion: analysis.suggestion,
+        affectedCount: analysis.affectedNodes.length,
+        timestamp: analysis.timestamp,
+        acknowledged: false,
+    });
+    // Cap the store
+    while (warningStore.length > MAX_WARNINGS)
+        warningStore.pop();
+}
+function getUnacknowledgedWarnings() {
+    return warningStore.filter(w => !w.acknowledged);
+}
+function acknowledgeWarnings() {
+    let count = 0;
+    for (const w of warningStore) {
+        if (!w.acknowledged) {
+            w.acknowledged = true;
+            count++;
+        }
+    }
+    return count;
+}
+function getAllWarnings() {
+    return [...warningStore];
+}
+function createWebServer(getGraphFn, fileCache, switchProjectFn, getProjectRoot, getPackageName, getLicenseStatus) {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    // Serve static files from public/
+    const publicDir = path.join(__dirname, "public");
+    app.use(express_1.default.static(publicDir));
+    // ── SSE: Server-Sent Events for real-time updates ──
+    const sseClients = new Set();
+    function broadcastSSE(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        for (const client of sseClients) {
+            try {
+                client.write(payload);
+            }
+            catch (_) {
+                sseClients.delete(client);
+            }
+        }
+    }
+    app.get("/api/events", (_req, res) => {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+        });
+        // Send initial connection event
+        res.write(`event: connected\ndata: ${JSON.stringify({ clients: sseClients.size + 1, cacheSize: fileCache?.size || 0 })}\n\n`);
+        sseClients.add(res);
+        console.error(`[syke:sse] Client connected (${sseClients.size} total)`);
+        _req.on("close", () => {
+            sseClients.delete(res);
+            console.error(`[syke:sse] Client disconnected (${sseClients.size} total)`);
+        });
+    });
+    // Wire FileCache change events → SSE broadcast + AI analysis
+    if (fileCache) {
+        fileCache.on("change", async (change) => {
+            const graph = getGraphFn();
+            const absPath = path.normalize(path.join(graph.sourceDir, change.relativePath));
+            // Compute affected nodes for visual pulse
+            const revDeps = graph.reverse.get(absPath) || [];
+            const fwdDeps = graph.forward.get(absPath) || [];
+            const connectedNodes = [...new Set([...revDeps, ...fwdDeps])].map(f => path.relative(graph.sourceDir, f).replace(/\\/g, "/"));
+            // Send diff lines (capped at 100 for bandwidth)
+            const diffLines = change.diff.slice(0, 100).map(d => ({
+                line: d.line,
+                type: d.type,
+                old: d.old,
+                new: d.new,
+            }));
+            // Send new file content (for code crawl display)
+            const newLines = change.newContent
+                ? change.newContent.split("\n").slice(0, 300)
+                : [];
+            // Immediately broadcast the file change event (node pulse starts)
+            broadcastSSE("file-change", {
+                file: change.relativePath,
+                type: change.type,
+                diffCount: change.diff.length,
+                diff: diffLines,
+                newContent: newLines,
+                connectedNodes,
+                timestamp: change.timestamp,
+            });
+            // Run Gemini real-time analysis (Pro only)
+            const license = getLicenseStatus?.();
+            if (license && license.plan === "pro") {
+                broadcastSSE("analysis-start", { file: change.relativePath });
+                try {
+                    const analysis = await (0, realtime_analyzer_1.analyzeChangeRealtime)(change, graph, (relPath) => fileCache.getFileByRelPath(relPath));
+                    broadcastSSE("analysis-result", analysis);
+                    // Store warnings for MCP check_warnings tool
+                    addWarning(analysis);
+                    // If graph structure changed (new/deleted files), rebuild
+                    if (change.type === "added" || change.type === "deleted") {
+                        broadcastSSE("graph-rebuild", { reason: change.type, file: change.relativePath });
+                    }
+                }
+                catch (err) {
+                    broadcastSSE("analysis-error", {
+                        file: change.relativePath,
+                        error: err.message,
+                    });
+                }
+            }
+            else {
+                // Free: still rebuild graph on structural changes, but skip AI
+                if (change.type === "added" || change.type === "deleted") {
+                    broadcastSSE("graph-rebuild", { reason: change.type, file: change.relativePath });
+                }
+            }
+        });
+    }
+    // GET /api/cache-status — Memory cache stats
+    app.get("/api/cache-status", (_req, res) => {
+        if (!fileCache) {
+            return res.json({ enabled: false });
+        }
+        res.json({
+            enabled: true,
+            fileCount: fileCache.size,
+            totalLines: fileCache.totalLines,
+            sseClients: sseClients.size,
+        });
+    });
+    // GET /api/graph — Cytoscape.js compatible JSON
+    app.get("/api/graph", (_req, res) => {
+        const graph = getGraphFn();
+        const nodes = [];
+        const edges = [];
+        // ── Compute depth for each file (BFS from roots) ──
+        const depthMap = new Map();
+        const roots = [...graph.files].filter(f => {
+            const rev = graph.reverse.get(f);
+            return !rev || rev.length === 0;
+        });
+        const queue = roots.map(r => [r, 0]);
+        while (queue.length > 0) {
+            const [file, d] = queue.shift();
+            if (depthMap.has(file))
+                continue;
+            depthMap.set(file, d);
+            const fwdDeps = graph.forward.get(file) || [];
+            for (const dep of fwdDeps) {
+                if (!depthMap.has(dep))
+                    queue.push([dep, d + 1]);
+            }
+        }
+        for (const file of graph.files) {
+            const rel = path.relative(graph.sourceDir, file).replace(/\\/g, "/");
+            const revDeps = graph.reverse.get(file) || [];
+            const dependentCount = revDeps.length;
+            const riskLevel = (0, analyze_impact_1.classifyRisk)(dependentCount);
+            const parts = rel.split("/");
+            const group = parts.length > 1 ? parts[0] + "/" + parts[1] : parts[0];
+            const { layer, action, env } = classifyFile(rel);
+            // Count lines
+            let lineCount = 0;
+            try {
+                const content = fs.readFileSync(file, "utf-8");
+                lineCount = content.split("\n").length;
+            }
+            catch (_) { }
+            // Imports count (direct forward dependencies)
+            const importsCount = (graph.forward.get(file) || []).length;
+            // Depth in dependency tree
+            const depth = depthMap.get(file) ?? 0;
+            nodes.push({
+                data: {
+                    id: rel,
+                    label: parts[parts.length - 1],
+                    fullPath: rel,
+                    riskLevel,
+                    dependentCount,
+                    lineCount,
+                    importsCount,
+                    depth,
+                    group,
+                    layer,
+                    action,
+                    env,
+                },
+            });
+        }
+        for (const [file, deps] of graph.forward) {
+            const from = path.relative(graph.sourceDir, file).replace(/\\/g, "/");
+            for (const d of deps) {
+                const to = path.relative(graph.sourceDir, d).replace(/\\/g, "/");
+                edges.push({ data: { source: from, target: to } });
+            }
+        }
+        res.json({ nodes, edges });
+    });
+    // GET /api/impact/:file — Impact analysis for a specific file
+    app.get("/api/impact/*splat", (req, res) => {
+        const splat = req.params.splat;
+        const fileParam = Array.isArray(splat) ? splat.join("/") : splat;
+        if (!fileParam) {
+            return res.status(400).json({ error: "File path required" });
+        }
+        const graph = getGraphFn();
+        const resolved = resolveFilePath(fileParam, graph.projectRoot, graph.sourceDir);
+        if (!graph.files.has(resolved)) {
+            return res.status(404).json({ error: `File not found in graph: ${fileParam}` });
+        }
+        const result = (0, analyze_impact_1.analyzeImpact)(resolved, graph);
+        res.json(result);
+    });
+    // POST /api/ai-analyze — Gemini AI semantic analysis (Pro only)
+    app.post("/api/ai-analyze", async (req, res) => {
+        // License check — Pro only
+        const license = getLicenseStatus?.();
+        if (!license || license.plan !== "pro") {
+            return res.status(403).json({
+                error: "AI analysis requires SYKE Pro. Upgrade at https://syke.cloud/dashboard/",
+                requiresPro: true,
+            });
+        }
+        const { file } = req.body;
+        if (!file) {
+            return res.status(400).json({ error: "file is required in body" });
+        }
+        const graph = getGraphFn();
+        const resolved = resolveFilePath(file, graph.projectRoot, graph.sourceDir);
+        if (!graph.files.has(resolved)) {
+            return res.status(404).json({ error: `File not found in graph: ${file}` });
+        }
+        const impactResult = (0, analyze_impact_1.analyzeImpact)(resolved, graph);
+        try {
+            const aiResult = await (0, analyzer_1.analyzeWithAI)(resolved, impactResult, graph);
+            res.json({ file: impactResult.relativePath, analysis: aiResult });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || "AI analysis failed" });
+        }
+    });
+    // GET /api/hub-files — Top hub files ranking (Free: top 3, Pro: unlimited)
+    app.get("/api/hub-files", (req, res) => {
+        const requested = parseInt(req.query.top) || 10;
+        const license = getLicenseStatus?.();
+        const isPro = license?.plan === "pro";
+        const top = isPro ? requested : Math.min(requested, 3);
+        const graph = getGraphFn();
+        const hubs = (0, analyze_impact_1.getHubFiles)(graph, top);
+        res.json({ hubs, totalFiles: graph.files.size, limited: !isPro, plan: license?.plan || "free" });
+    });
+    // POST /api/connected-code — Batch load code from file + connected nodes
+    app.post("/api/connected-code", (req, res) => {
+        const { file, maxFiles = 6, maxLinesPerFile = 80 } = req.body;
+        if (!file)
+            return res.status(400).json({ error: "file required" });
+        const graph = getGraphFn();
+        const resolved = resolveFilePath(file, graph.projectRoot, graph.sourceDir);
+        const toRel = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+        if (!graph.files.has(resolved)) {
+            return res.status(404).json({ error: `File not found: ${file}` });
+        }
+        // Gather: selected file + direct dependents + direct imports
+        const filesToLoad = [resolved];
+        const revDeps = graph.reverse.get(resolved) || [];
+        const fwdDeps = graph.forward.get(resolved) || [];
+        for (const d of [...revDeps, ...fwdDeps]) {
+            if (!filesToLoad.includes(d))
+                filesToLoad.push(d);
+            if (filesToLoad.length >= maxFiles)
+                break;
+        }
+        const results = [];
+        for (const f of filesToLoad) {
+            try {
+                const content = fs.readFileSync(f, "utf-8");
+                const allLines = content.split("\n");
+                const rel = toRel(f);
+                const { layer } = classifyFile(rel);
+                results.push({
+                    path: rel,
+                    layer,
+                    lines: allLines.slice(0, maxLinesPerFile),
+                    lineCount: allLines.length,
+                });
+            }
+            catch (_) { }
+        }
+        res.json({ files: results });
+    });
+    // GET /api/file-content/:file — Source code preview
+    app.get("/api/file-content/*splat", (req, res) => {
+        const splat = req.params.splat;
+        const fileParam = Array.isArray(splat) ? splat.join("/") : splat;
+        if (!fileParam)
+            return res.status(400).json({ error: "File path required" });
+        const graph = getGraphFn();
+        const resolved = resolveFilePath(fileParam, graph.projectRoot, graph.sourceDir);
+        if (!graph.files.has(resolved)) {
+            return res.status(404).json({ error: `File not found: ${fileParam}` });
+        }
+        try {
+            const content = fs.readFileSync(resolved, "utf-8");
+            const lines = content.split("\n");
+            res.json({
+                path: fileParam,
+                lineCount: lines.length,
+                content: lines.length > 500 ? lines.slice(0, 500).join("\n") + "\n// ... truncated ..." : content,
+                truncated: lines.length > 500,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/cycles — Detect circular dependencies
+    app.get("/api/cycles", (_req, res) => {
+        const graph = getGraphFn();
+        const toRel = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+        const cycles = [];
+        const visited = new Set();
+        const stack = new Set();
+        const parent = new Map();
+        function dfs(file, pathSoFar) {
+            if (cycles.length >= 50)
+                return; // cap
+            visited.add(file);
+            stack.add(file);
+            const deps = graph.forward.get(file) || [];
+            for (const dep of deps) {
+                if (stack.has(dep)) {
+                    // Found cycle — extract it
+                    const cycleStart = pathSoFar.indexOf(dep);
+                    if (cycleStart >= 0) {
+                        const cycle = pathSoFar.slice(cycleStart).map(toRel);
+                        cycle.push(toRel(dep)); // close the loop
+                        cycles.push(cycle);
+                    }
+                }
+                else if (!visited.has(dep)) {
+                    dfs(dep, [...pathSoFar, dep]);
+                }
+            }
+            stack.delete(file);
+        }
+        for (const file of graph.files) {
+            if (!visited.has(file)) {
+                dfs(file, [file]);
+            }
+        }
+        res.json({ cycles, count: cycles.length });
+    });
+    // GET /api/shortest-path?from=X&to=Y — BFS shortest path (follows forward edges)
+    app.get("/api/shortest-path", (req, res) => {
+        const fromParam = req.query.from;
+        const toParam = req.query.to;
+        if (!fromParam || !toParam)
+            return res.status(400).json({ error: "from and to required" });
+        const graph = getGraphFn();
+        const toRel = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+        const fromAbs = resolveFilePath(fromParam, graph.projectRoot, graph.sourceDir);
+        const toAbs = resolveFilePath(toParam, graph.projectRoot, graph.sourceDir);
+        if (!graph.files.has(fromAbs) || !graph.files.has(toAbs)) {
+            return res.status(404).json({ error: "File not found in graph" });
+        }
+        // BFS on combined forward + reverse (undirected shortest path)
+        const prev = new Map();
+        const visited = new Set();
+        const queue = [fromAbs];
+        visited.add(fromAbs);
+        let found = false;
+        while (queue.length > 0 && !found) {
+            const cur = queue.shift();
+            const neighbors = new Set();
+            (graph.forward.get(cur) || []).forEach(n => neighbors.add(n));
+            (graph.reverse.get(cur) || []).forEach(n => neighbors.add(n));
+            for (const nb of neighbors) {
+                if (!visited.has(nb)) {
+                    visited.add(nb);
+                    prev.set(nb, cur);
+                    if (nb === toAbs) {
+                        found = true;
+                        break;
+                    }
+                    queue.push(nb);
+                }
+            }
+        }
+        if (!found)
+            return res.json({ path: [], distance: -1 });
+        // Reconstruct path
+        const pathResult = [];
+        let cur = toAbs;
+        while (cur) {
+            pathResult.unshift(toRel(cur));
+            cur = prev.get(cur);
+        }
+        res.json({ path: pathResult, distance: pathResult.length - 1 });
+    });
+    // GET /api/simulate-delete/:file — Simulate file removal
+    app.get("/api/simulate-delete/*splat", (req, res) => {
+        const splat = req.params.splat;
+        const fileParam = Array.isArray(splat) ? splat.join("/") : splat;
+        if (!fileParam)
+            return res.status(400).json({ error: "File path required" });
+        const graph = getGraphFn();
+        const resolved = resolveFilePath(fileParam, graph.projectRoot, graph.sourceDir);
+        const toRel = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+        if (!graph.files.has(resolved)) {
+            return res.status(404).json({ error: `File not found: ${fileParam}` });
+        }
+        // Files that directly import the deleted file → will have broken imports
+        const brokenImports = (graph.reverse.get(resolved) || []).map(toRel);
+        // Full cascade: all transitively affected files
+        const cascadeSet = new Set();
+        const queue = [...(graph.reverse.get(resolved) || [])];
+        for (const q of queue)
+            cascadeSet.add(q);
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            for (const dep of (graph.reverse.get(cur) || [])) {
+                if (!cascadeSet.has(dep) && dep !== resolved) {
+                    cascadeSet.add(dep);
+                    queue.push(dep);
+                }
+            }
+        }
+        // Orphaned files: files that only had forward deps to the deleted file
+        const orphaned = [];
+        for (const dep of (graph.forward.get(resolved) || [])) {
+            const revDeps = graph.reverse.get(dep) || [];
+            // If the deleted file is the only one importing this dep
+            if (revDeps.length === 1 && revDeps[0] === resolved) {
+                orphaned.push(toRel(dep));
+            }
+        }
+        res.json({
+            deletedFile: fileParam,
+            brokenImports,
+            brokenCount: brokenImports.length,
+            cascadeFiles: [...cascadeSet].map(toRel),
+            cascadeCount: cascadeSet.size,
+            orphanedFiles: orphaned,
+            orphanedCount: orphaned.length,
+            severity: cascadeSet.size >= 20 ? "CRITICAL" : cascadeSet.size >= 10 ? "HIGH" : cascadeSet.size >= 5 ? "MEDIUM" : "LOW",
+        });
+    });
+    // GET /api/warnings — List unresolved warnings (for MCP/dashboard)
+    app.get("/api/warnings", (_req, res) => {
+        const unacked = getUnacknowledgedWarnings();
+        const all = getAllWarnings();
+        res.json({
+            unresolved: unacked,
+            unresolvedCount: unacked.length,
+            totalCount: all.length,
+        });
+    });
+    // POST /api/warnings/acknowledge — Mark all warnings as acknowledged
+    app.post("/api/warnings/acknowledge", (_req, res) => {
+        const count = acknowledgeWarnings();
+        res.json({ acknowledged: count });
+    });
+    // GET /api/project-info — Current project metadata
+    app.get("/api/project-info", (_req, res) => {
+        const graph = getGraphFn();
+        let edgeCount = 0;
+        for (const deps of graph.forward.values())
+            edgeCount += deps.length;
+        const license = getLicenseStatus?.();
+        res.json({
+            projectRoot: getProjectRoot ? getProjectRoot() : graph.projectRoot,
+            packageName: getPackageName ? getPackageName() : "",
+            languages: graph.languages,
+            fileCount: graph.files.size,
+            edgeCount,
+            plan: license?.plan || "free",
+            freeFileLimit: 50,
+        });
+    });
+    // GET /api/browse-dirs — List subdirectories for folder browser
+    app.get("/api/browse-dirs", (req, res) => {
+        const dirPath = req.query.path || (process.platform === "win32" ? "C:\\" : "/");
+        const normalized = path.normalize(dirPath);
+        if (!fs.existsSync(normalized) || !fs.statSync(normalized).isDirectory()) {
+            return res.status(400).json({ error: `Not a directory: ${normalized}` });
+        }
+        try {
+            const entries = fs.readdirSync(normalized, { withFileTypes: true });
+            const dirs = entries
+                .filter(e => {
+                if (!e.isDirectory())
+                    return false;
+                const name = e.name;
+                // Hide system/hidden dirs
+                if (name.startsWith(".") || name === "node_modules" || name === "$RECYCLE.BIN" || name === "System Volume Information")
+                    return false;
+                return true;
+            })
+                .map(e => e.name)
+                .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            // Check if this looks like a project root (has package.json, pubspec.yaml, etc.)
+            const markers = ["package.json", "pubspec.yaml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle", "CMakeLists.txt", "Makefile", "pyproject.toml", "setup.py"];
+            const isProject = markers.some(m => fs.existsSync(path.join(normalized, m)));
+            const detectedMarker = markers.find(m => fs.existsSync(path.join(normalized, m))) || null;
+            res.json({
+                current: normalized,
+                parent: path.dirname(normalized) !== normalized ? path.dirname(normalized) : null,
+                dirs,
+                isProject,
+                detectedMarker,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/switch-project — Switch to a different project folder
+    app.post("/api/switch-project", (req, res) => {
+        const { projectRoot } = req.body;
+        if (!projectRoot || typeof projectRoot !== "string") {
+            return res.status(400).json({ error: "projectRoot is required" });
+        }
+        const normalized = path.normalize(projectRoot);
+        if (!fs.existsSync(normalized) || !fs.statSync(normalized).isDirectory()) {
+            return res.status(400).json({ error: `Directory not found: ${normalized}` });
+        }
+        if (!switchProjectFn) {
+            return res.status(500).json({ error: "Switch project not supported" });
+        }
+        try {
+            const result = switchProjectFn(normalized);
+            broadcastSSE("project-switched", result);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || "Failed to switch project" });
+        }
+    });
+    return app;
+}