@ebowwa/dependency-graph-mcp 1.0.0

package/src/index.js

@@ -0,0 +1,983 @@
+#!/usr/bin/env bun
+"use strict";
+/**
+ * Dependency Graph MCP Server
+ *
+ * Analyzes and visualizes dependency relationships in monorepos.
+ * Provides tools for:
+ * - Building dependency graphs from package.json and imports
+ * - Visualizing dependency relationships
+ * - Impact analysis for refactoring decisions
+ * - Finding circular dependencies
+ * - Identifying unused code
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+var stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+var types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+var node_fs_1 = require("node:fs");
+var node_path_1 = require("node:path");
+var node_url_1 = require("node:url");
+var TOOLING_DIR = (0, node_path_1.dirname)((0, node_url_1.fileURLToPath)(import.meta.url.replace("/MCP/packages/dependency-graph", "/packages/src/tooling")));
+// ==============
+// Graph Builder
+// ==============
+var DependencyGraphBuilder = /** @class */ (function () {
+    function DependencyGraphBuilder(monorepoRoot) {
+        this.packageCache = new Map();
+        this.monorepoRoot = monorepoRoot;
+        this.graph = {
+            nodes: new Map(),
+            edges: [],
+            reverseEdges: new Map(),
+        };
+    }
+    /**
+     * Build the complete dependency graph
+     */
+    DependencyGraphBuilder.prototype.build = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var _a, includeDevDependencies, _b, analyzeImports, _c, excludePatterns, packages, _i, packages_1, pkg, _d, packages_2, pkg;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = options.includeDevDependencies, includeDevDependencies = _a === void 0 ? false : _a, _b = options.analyzeImports, analyzeImports = _b === void 0 ? true : _b, _c = options.excludePatterns, excludePatterns = _c === void 0 ? [] : _c;
+                        return [4 /*yield*/, this.discoverPackages()];
+                    case 1:
+                        packages = _e.sent();
+                        // Add nodes for all packages
+                        for (_i = 0, packages_1 = packages; _i < packages_1.length; _i++) {
+                            pkg = packages_1[_i];
+                            this.addNode(pkg.name, pkg.path, "workspace", pkg.version);
+                        }
+                        _d = 0, packages_2 = packages;
+                        _e.label = 2;
+                    case 2:
+                        if (!(_d < packages_2.length)) return [3 /*break*/, 6];
+                        pkg = packages_2[_d];
+                        return [4 /*yield*/, this.analyzePackageDependencies(pkg, includeDevDependencies, excludePatterns)];
+                    case 3:
+                        _e.sent();
+                        if (!analyzeImports) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.analyzeImports(pkg)];
+                    case 4:
+                        _e.sent();
+                        _e.label = 5;
+                    case 5:
+                        _d++;
+                        return [3 /*break*/, 2];
+                    case 6:
+                        // Build reverse edges for impact analysis
+                        this.buildReverseEdges();
+                        return [2 /*return*/, this.graph];
+                }
+            });
+        });
+    };
+    /**
+     * Discover all package.json files in the monorepo
+     */
+    DependencyGraphBuilder.prototype.discoverPackages = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var packages, seen, searchPaths, _i, searchPaths_1, searchPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        packages = [];
+                        seen = new Set();
+                        searchPaths = [
+                            this.monorepoRoot,
+                            (0, node_path_1.join)(this.monorepoRoot, "packages"),
+                            (0, node_path_1.join)(this.monorepoRoot, "packages/src"),
+                            (0, node_path_1.join)(this.monorepoRoot, "apps"),
+                            (0, node_path_1.join)(this.monorepoRoot, "MCP/packages"),
+                        ];
+                        _i = 0, searchPaths_1 = searchPaths;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < searchPaths_1.length)) return [3 /*break*/, 4];
+                        searchPath = searchPaths_1[_i];
+                        if (!(0, node_fs_1.existsSync)(searchPath))
+                            return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.searchDirectory(searchPath, packages, seen, 0, 4)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, packages];
+                }
+            });
+        });
+    };
+    /**
+     * Recursively search for package.json files
+     */
+    DependencyGraphBuilder.prototype.searchDirectory = function (dir, packages, seen, depth, maxDepth) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entries, _i, entries_1, entry, fullPath, packageDir, relativePath, pkg, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (depth > maxDepth)
+                            return [2 /*return*/];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 7, , 8]);
+                        entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+                        _i = 0, entries_1 = entries;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_i < entries_1.length)) return [3 /*break*/, 6];
+                        entry = entries_1[_i];
+                        // Skip node_modules and hidden dirs
+                        if (entry.name === "node_modules" || entry.name.startsWith("."))
+                            return [3 /*break*/, 5];
+                        if (entry.name === "dist" || entry.name === "build")
+                            return [3 /*break*/, 5];
+                        fullPath = (0, node_path_1.join)(dir, entry.name);
+                        if (!entry.isDirectory()) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.searchDirectory(fullPath, packages, seen, depth + 1, maxDepth)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        if (entry.name === "package.json") {
+                            packageDir = (0, node_path_1.dirname)(fullPath);
+                            relativePath = (0, node_path_1.relative)(this.monorepoRoot, packageDir);
+                            if (seen.has(relativePath))
+                                return [3 /*break*/, 5];
+                            seen.add(relativePath);
+                            try {
+                                pkg = JSON.parse((0, node_fs_1.readFileSync)(fullPath, "utf-8"));
+                                if (pkg.name && !pkg.private) {
+                                    packages.push({
+                                        name: pkg.name,
+                                        path: relativePath,
+                                        version: pkg.version || "0.0.0",
+                                    });
+                                    this.packageCache.set(pkg.name, { path: relativePath, pkg: pkg });
+                                }
+                            }
+                            catch (_c) {
+                                // Invalid package.json, skip
+                            }
+                        }
+                        _b.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        _a = _b.sent();
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Analyze package.json dependencies
+     */
+    DependencyGraphBuilder.prototype.analyzePackageDependencies = function (pkg, includeDev, excludePatterns) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pkgPath, packageJson, depTypes, _i, depTypes_1, depType, deps, _loop_1, this_1, _a, _b, _c, depName, depVersion;
+            return __generator(this, function (_d) {
+                pkgPath = (0, node_path_1.join)(this.monorepoRoot, pkg.path, "package.json");
+                if (!(0, node_fs_1.existsSync)(pkgPath))
+                    return [2 /*return*/];
+                packageJson = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+                depTypes = ["dependencies"];
+                if (includeDev)
+                    depTypes.push("devDependencies", "peerDependencies", "optionalDependencies");
+                for (_i = 0, depTypes_1 = depTypes; _i < depTypes_1.length; _i++) {
+                    depType = depTypes_1[_i];
+                    deps = packageJson[depType];
+                    if (!deps)
+                        continue;
+                    _loop_1 = function (depName, depVersion) {
+                        // Check if this matches any exclude pattern
+                        if (excludePatterns.some(function (pattern) { return depName.match(pattern); }))
+                            return "continue";
+                        var isWorkspace = depVersion === "workspace:*" || depVersion === "workspace:^" || depVersion === "workspace:~";
+                        if (isWorkspace) {
+                            // This is a workspace dependency
+                            // Find the actual package in our cache
+                            var targetPkg = this_1.packageCache.get(depName);
+                            if (targetPkg) {
+                                this_1.addEdge(pkg.name, depName, "workspace");
+                            }
+                        }
+                        else if (this_1.packageCache.has(depName)) {
+                            // It's a local package but not using workspace: protocol
+                            this_1.addEdge(pkg.name, depName, "workspace");
+                        }
+                        else {
+                            // External dependency
+                            this_1.addNode(depName, "", "external", depVersion);
+                            this_1.addEdge(pkg.name, depName, "external");
+                        }
+                    };
+                    this_1 = this;
+                    for (_a = 0, _b = Object.entries(deps); _a < _b.length; _a++) {
+                        _c = _b[_a], depName = _c[0], depVersion = _c[1];
+                        _loop_1(depName, depVersion);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Analyze TypeScript/JavaScript imports
+     */
+    DependencyGraphBuilder.prototype.analyzeImports = function (pkg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pkgDir, sourceDirs, _i, sourceDirs_1, sourceDir, searchPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pkgDir = (0, node_path_1.join)(this.monorepoRoot, pkg.path);
+                        sourceDirs = ["src", "lib", ""];
+                        _i = 0, sourceDirs_1 = sourceDirs;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < sourceDirs_1.length)) return [3 /*break*/, 4];
+                        sourceDir = sourceDirs_1[_i];
+                        searchPath = sourceDir ? (0, node_path_1.join)(pkgDir, sourceDir) : pkgDir;
+                        if (!(0, node_fs_1.existsSync)(searchPath))
+                            return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.analyzeImportsInDirectory(pkg.name, searchPath)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Recursively analyze imports in a directory
+     */
+    DependencyGraphBuilder.prototype.analyzeImportsInDirectory = function (packageName, dir) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entries, _i, entries_2, entry, fullPath, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 7, , 8]);
+                        entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+                        _i = 0, entries_2 = entries;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < entries_2.length)) return [3 /*break*/, 6];
+                        entry = entries_2[_i];
+                        if (entry.name === "node_modules" || entry.name.startsWith("."))
+                            return [3 /*break*/, 5];
+                        if (entry.name === "dist" || entry.name === "build")
+                            return [3 /*break*/, 5];
+                        fullPath = (0, node_path_1.join)(dir, entry.name);
+                        if (!entry.isDirectory()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.analyzeImportsInDirectory(packageName, fullPath)];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        if (!(entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".js") || entry.name.endsWith(".jsx") || entry.name.endsWith(".mjs"))) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.analyzeImportsInFile(packageName, fullPath)];
+                    case 4:
+                        _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        _a = _b.sent();
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Analyze imports in a single file
+     */
+    DependencyGraphBuilder.prototype.analyzeImportsInFile = function (packageName, filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var content, importPatterns, _i, importPatterns_1, pattern, match, importPath, _a, _b, _c, pkgName, pkgData;
+            return __generator(this, function (_d) {
+                try {
+                    content = (0, node_fs_1.readFileSync)(filePath, "utf-8");
+                    importPatterns = [
+                        // ES imports: import ... from '...' | import ... from "..."
+                        /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s+from\s+['"]([^'"]+)['"]/g,
+                        // Dynamic imports: import('...')
+                        /import\(['"]([^'"]+)['"]\)/g,
+                        // require(): require('...') | require("...")
+                        /require\(['"]([^'"]+)['"]\)/g,
+                        // Export from: export ... from '...'
+                        /export\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+)?['"]([^'"]+)['"]/g,
+                    ];
+                    for (_i = 0, importPatterns_1 = importPatterns; _i < importPatterns_1.length; _i++) {
+                        pattern = importPatterns_1[_i];
+                        match = void 0;
+                        while ((match = pattern.exec(content)) !== null) {
+                            importPath = match[1];
+                            // Skip relative imports
+                            if (importPath.startsWith(".") || importPath.startsWith("/"))
+                                continue;
+                            // Check if this is a known workspace package
+                            for (_a = 0, _b = this.packageCache; _a < _b.length; _a++) {
+                                _c = _b[_a], pkgName = _c[0], pkgData = _c[1];
+                                if (importPath === pkgName || importPath.startsWith(pkgName + "/")) {
+                                    this.addEdge(packageName, pkgName, "import", importPath);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (_e) {
+                    // File not readable
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Add a node to the graph
+     */
+    DependencyGraphBuilder.prototype.addNode = function (name, path, type, version) {
+        if (!this.graph.nodes.has(name)) {
+            this.graph.nodes.set(name, { name: name, path: path, type: type, version: version });
+            this.graph.reverseEdges.set(name, new Set());
+        }
+    };
+    /**
+     * Add an edge to the graph
+     */
+    DependencyGraphBuilder.prototype.addEdge = function (from, to, type, importPath) {
+        // Skip self-references
+        if (from === to)
+            return;
+        // Check if edge already exists
+        var existing = this.graph.edges.find(function (e) { return e.from === from && e.to === to; });
+        if (existing)
+            return;
+        this.graph.edges.push({ from: from, to: to, type: type, importPath: importPath });
+        // Update reverse edges
+        if (!this.graph.reverseEdges.has(to)) {
+            this.graph.reverseEdges.set(to, new Set());
+        }
+        this.graph.reverseEdges.get(to).add(from);
+    };
+    /**
+     * Build reverse edges for impact analysis
+     */
+    DependencyGraphBuilder.prototype.buildReverseEdges = function () {
+        for (var _i = 0, _a = this.graph.reverseEdges; _i < _a.length; _i++) {
+            var _b = _a[_i], to = _b[0], dependents = _b[1];
+            // Ensure node exists
+            if (!this.graph.nodes.has(to)) {
+                this.graph.nodes.set(to, { name: to, path: "", type: "external" });
+            }
+        }
+    };
+    /**
+     * Get the built graph
+     */
+    DependencyGraphBuilder.prototype.getGraph = function () {
+        return this.graph;
+    };
+    return DependencyGraphBuilder;
+}());
+// ==============
+// MCP Server
+// ==============
+var DEPENDENCY_GRAPH_SCHEMA = {
+    name: "dependency_graph",
+    description: "Build a complete dependency graph of the monorepo",
+    inputSchema: {
+        type: "object",
+        properties: {
+            includeDevDependencies: {
+                type: "boolean",
+                description: "Include devDependencies in the graph",
+                default: false,
+            },
+            analyzeImports: {
+                type: "boolean",
+                description: "Analyze TypeScript/JavaScript imports",
+                default: true,
+            },
+            excludePatterns: {
+                type: "array",
+                items: { type: "string" },
+                description: "Regex patterns to exclude from dependency analysis",
+                default: [],
+            },
+            format: {
+                type: "string",
+                enum: ["json", "mermaid", "dot", "tree"],
+                description: "Output format for the graph",
+                default: "json",
+            },
+        },
+    },
+};
+var IMPACT_ANALYSIS_SCHEMA = {
+    name: "impact_analysis",
+    description: "Analyze the impact of changing a specific package",
+    inputSchema: {
+        type: "object",
+        properties: {
+            package: {
+                type: "string",
+                description: "Package name to analyze",
+            },
+            includeTransitive: {
+                type: "boolean",
+                description: "Include transitive dependents",
+                default: true,
+            },
+            format: {
+                type: "string",
+                enum: ["json", "tree"],
+                description: "Output format",
+                default: "tree",
+            },
+        },
+        required: ["package"],
+    },
+};
+var FIND_CIRCULAR_SCHEMA = {
+    name: "find_circular",
+    description: "Find circular dependencies in the monorepo",
+    inputSchema: {
+        type: "object",
+        properties: {
+            maxDepth: {
+                type: "number",
+                description: "Maximum depth to search for cycles",
+                default: 10,
+            },
+        },
+    },
+};
+var UNUSED_CODE_SCHEMA = {
+    name: "unused_code",
+    description: "Find potentially unused packages (no dependents)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            includeExternal: {
+                type: "boolean",
+                description: "Include external dependencies",
+                default: false,
+            },
+        },
+    },
+};
+var PACKAGE_INFO_SCHEMA = {
+    name: "package_info",
+    description: "Get detailed information about a specific package",
+    inputSchema: {
+        type: "object",
+        properties: {
+            package: {
+                type: "string",
+                description: "Package name",
+            },
+        },
+        required: ["package"],
+    },
+};
+// Format the graph for output
+function formatGraph(graph, format) {
+    switch (format) {
+        case "mermaid":
+            return formatAsMermaid(graph);
+        case "dot":
+            return formatAsDot(graph);
+        case "tree":
+            return formatAsTree(graph);
+        case "json":
+        default:
+            return JSON.stringify({
+                nodes: Array.from(graph.nodes.values()),
+                edges: graph.edges,
+            }, null, 2);
+    }
+}
+function formatAsMermaid(graph) {
+    var lines = ["graph TD"];
+    // Add nodes
+    for (var _i = 0, _a = graph.nodes; _i < _a.length; _i++) {
+        var _b = _a[_i], name_1 = _b[0], node = _b[1];
+        var label = node.type === "workspace" ? "\uD83D\uDCE6 ".concat(name_1) : "\uD83D\uDCDA ".concat(name_1);
+        lines.push("  ".concat(name_1.replace(/[^a-zA-Z0-9]/g, "_"), "[\"").concat(label, "\"]"));
+    }
+    // Add edges
+    for (var _c = 0, _d = graph.edges; _c < _d.length; _c++) {
+        var edge = _d[_c];
+        var from = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
+        var to = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
+        var label = edge.type === "workspace" ? "workspace" : edge.type === "import" ? "imports" : "external";
+        lines.push("  ".concat(from, " -->|").concat(label, "| ").concat(to));
+    }
+    // Add styles
+    lines.push('  classDef workspace fill:#e1f5fe');
+    lines.push('  classDef external fill:#f5f5f5');
+    lines.push('  classDef import fill:#fff3e0');
+    for (var _e = 0, _f = graph.nodes; _e < _f.length; _e++) {
+        var _g = _f[_e], name_2 = _g[0], node = _g[1];
+        var id = name_2.replace(/[^a-zA-Z0-9]/g, "_");
+        if (node.type === "workspace") {
+            lines.push("  class ".concat(id, " workspace"));
+        }
+        else if (node.type === "external") {
+            lines.push("  class ".concat(id, " external"));
+        }
+    }
+    return lines.join("\n");
+}
+function formatAsDot(graph) {
+    var lines = ["digraph dependencies {"];
+    lines.push('  rankdir=LR;');
+    lines.push('  node [shape=box];');
+    // Add nodes
+    for (var _i = 0, _a = graph.nodes; _i < _a.length; _i++) {
+        var _b = _a[_i], name_3 = _b[0], node = _b[1];
+        var color = node.type === "workspace" ? "lightblue" : "lightgray";
+        lines.push("  \"".concat(name_3, "\" [fillcolor=").concat(color, ", style=filled];"));
+    }
+    // Add edges
+    for (var _c = 0, _d = graph.edges; _c < _d.length; _c++) {
+        var edge = _d[_c];
+        var style = edge.type === "workspace" ? "solid" : "dashed";
+        lines.push("  \"".concat(edge.from, "\" -> \"").concat(edge.to, "\" [style=").concat(style, ", label=\"").concat(edge.type, "\"];"));
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function formatAsTree(graph) {
+    var _a;
+    var lines = [];
+    var seen = new Set();
+    // Find root nodes (no incoming edges from other workspace packages)
+    var workspaceNodes = Array.from(graph.nodes.values()).filter(function (n) { return n.type === "workspace"; });
+    var incomingEdges = new Map();
+    for (var _i = 0, workspaceNodes_1 = workspaceNodes; _i < workspaceNodes_1.length; _i++) {
+        var node = workspaceNodes_1[_i];
+        incomingEdges.set(node.name, 0);
+    }
+    for (var _b = 0, _c = graph.edges; _b < _c.length; _b++) {
+        var edge = _c[_b];
+        if (((_a = graph.nodes.get(edge.to)) === null || _a === void 0 ? void 0 : _a.type) === "workspace") {
+            incomingEdges.set(edge.to, (incomingEdges.get(edge.to) || 0) + 1);
+        }
+    }
+    // Start from roots
+    for (var _d = 0, _e = graph.nodes; _d < _e.length; _d++) {
+        var _f = _e[_d], name_4 = _f[0], node = _f[1];
+        if (node.type === "workspace" && (incomingEdges.get(name_4) || 0) === 0) {
+            lines.push("\uD83D\uDCE6 ".concat(name_4));
+            printTree(graph, name_4, "", seen, lines);
+        }
+    }
+    // Add any disconnected nodes
+    for (var _g = 0, _h = graph.nodes; _g < _h.length; _g++) {
+        var _j = _h[_g], name_5 = _j[0], node = _j[1];
+        if (!seen.has(name_5) && node.type === "workspace") {
+            lines.push("\uD83D\uDCE6 ".concat(name_5, " (disconnected)"));
+        }
+    }
+    return lines.join("\n");
+}
+function printTree(graph, nodeName, prefix, seen, lines) {
+    seen.add(nodeName);
+    // Find outgoing edges to other workspace packages
+    var outgoing = graph.edges.filter(function (e) { var _a; return e.from === nodeName && ((_a = graph.nodes.get(e.to)) === null || _a === void 0 ? void 0 : _a.type) === "workspace"; });
+    for (var i = 0; i < outgoing.length; i++) {
+        var edge = outgoing[i];
+        var isLast = i === outgoing.length - 1;
+        var connector = isLast ? "└──" : "├──";
+        var childPrefix = prefix + (isLast ? "    " : "│   ");
+        lines.push("".concat(prefix).concat(connector, " \uD83D\uDCE6 ").concat(edge.to, " [").concat(edge.type, "]"));
+        if (!seen.has(edge.to)) {
+            printTree(graph, edge.to, childPrefix, seen, lines);
+        }
+    }
+    // Show external dependencies count
+    var externals = graph.edges.filter(function (e) { var _a; return e.from === nodeName && ((_a = graph.nodes.get(e.to)) === null || _a === void 0 ? void 0 : _a.type) === "external"; });
+    if (externals.length > 0) {
+        lines.push("".concat(prefix, "\u2514\u2500\u2500 \uD83D\uDCDA ").concat(externals.length, " external dependencies"));
+    }
+}
+// Find circular dependencies using DFS
+function findCircularDependencies(graph, maxDepth) {
+    if (maxDepth === void 0) { maxDepth = 10; }
+    var cycles = [];
+    var visited = new Set();
+    var recursionStack = new Set();
+    function dfs(node, path) {
+        if (path.length > maxDepth)
+            return;
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+        // Check all outgoing edges
+        for (var _i = 0, _a = graph.edges; _i < _a.length; _i++) {
+            var edge = _a[_i];
+            if (edge.from === node) {
+                if (recursionStack.has(edge.to)) {
+                    // Found a cycle
+                    var cycleStart = path.indexOf(edge.to);
+                    if (cycleStart >= 0) {
+                        cycles.push(__spreadArray(__spreadArray([], path.slice(cycleStart), true), [edge.to], false));
+                    }
+                }
+                else if (!visited.has(edge.to)) {
+                    dfs(edge.to, __spreadArray([], path, true));
+                }
+            }
+        }
+        recursionStack.delete(node);
+    }
+    // Start DFS from each workspace node
+    for (var _i = 0, _a = graph.nodes; _i < _a.length; _i++) {
+        var _b = _a[_i], name_6 = _b[0], node = _b[1];
+        if (node.type === "workspace" && !visited.has(name_6)) {
+            dfs(name_6, []);
+        }
+    }
+    return cycles;
+}
+// Impact analysis
+function analyzeImpact(graph, packageName, includeTransitive) {
+    if (includeTransitive === void 0) { includeTransitive = true; }
+    var direct = [];
+    var transitive = [];
+    var visited = new Set();
+    // Get direct dependents
+    var directDependents = graph.reverseEdges.get(packageName);
+    if (directDependents) {
+        for (var _i = 0, directDependents_1 = directDependents; _i < directDependents_1.length; _i++) {
+            var dep = directDependents_1[_i];
+            direct.push(dep);
+            visited.add(dep);
+        }
+    }
+    // Get transitive dependents
+    if (includeTransitive) {
+        for (var _a = 0, direct_1 = direct; _a < direct_1.length; _a++) {
+            var dep = direct_1[_a];
+            collectTransitive(graph, dep, visited, transitive);
+        }
+    }
+    return {
+        direct: direct,
+        transitive: transitive,
+        all: Array.from(visited),
+    };
+}
+function collectTransitive(graph, packageName, visited, result) {
+    var dependents = graph.reverseEdges.get(packageName);
+    if (!dependents)
+        return;
+    for (var _i = 0, dependents_1 = dependents; _i < dependents_1.length; _i++) {
+        var dep = dependents_1[_i];
+        if (!visited.has(dep)) {
+            visited.add(dep);
+            result.push(dep);
+            collectTransitive(graph, dep, visited, result);
+        }
+    }
+}
+// Start the MCP server
+var server = new index_js_1.Server({
+    name: "@mcp/dependency-graph",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+var cachedGraph = null;
+var cachedBuilder = null;
+// List tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, ({
+                tools: [
+                    DEPENDENCY_GRAPH_SCHEMA,
+                    IMPACT_ANALYSIS_SCHEMA,
+                    FIND_CIRCULAR_SCHEMA,
+                    UNUSED_CODE_SCHEMA,
+                    PACKAGE_INFO_SCHEMA,
+                ],
+            })];
+    });
+}); });
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, name, args, monorepoRoot, _b, _c, _d, includeDevDependencies, _e, analyzeImports, _f, excludePatterns, _g, format, graph, _h, packageName, _j, includeTransitive, _k, format, impact, lines, _i, _l, dep, _m, _o, dep, _p, maxDepth, cycles, lines, i, _q, includeExternal, unused, _r, _s, _t, name_7, node, dependents, packageName_1, node, dependencies, dependents, lines, _u, dependencies_1, dep, depNode, _v, dependents_2, dep, error_1;
+    return __generator(this, function (_w) {
+        switch (_w.label) {
+            case 0:
+                _a = request.params, name = _a.name, args = _a.arguments;
+                // Initialize graph builder if needed
+                if (!cachedBuilder) {
+                    monorepoRoot = process.cwd();
+                    cachedBuilder = new DependencyGraphBuilder(monorepoRoot);
+                }
+                if (!!cachedGraph) return [3 /*break*/, 2];
+                return [4 /*yield*/, cachedBuilder.build()];
+            case 1:
+                _w.sent();
+                cachedGraph = cachedBuilder.getGraph();
+                _w.label = 2;
+            case 2:
+                _w.trys.push([2, 11, , 12]);
+                _b = name;
+                switch (_b) {
+                    case "dependency_graph": return [3 /*break*/, 3];
+                    case "impact_analysis": return [3 /*break*/, 5];
+                    case "find_circular": return [3 /*break*/, 6];
+                    case "unused_code": return [3 /*break*/, 7];
+                    case "package_info": return [3 /*break*/, 8];
+                }
+                return [3 /*break*/, 9];
+            case 3:
+                _c = args, _d = _c.includeDevDependencies, includeDevDependencies = _d === void 0 ? false : _d, _e = _c.analyzeImports, analyzeImports = _e === void 0 ? true : _e, _f = _c.excludePatterns, excludePatterns = _f === void 0 ? [] : _f, _g = _c.format, format = _g === void 0 ? "json" : _g;
+                return [4 /*yield*/, cachedBuilder.build({ includeDevDependencies: includeDevDependencies, analyzeImports: analyzeImports, excludePatterns: excludePatterns })];
+            case 4:
+                _w.sent();
+                graph = cachedBuilder.getGraph();
+                cachedGraph = graph;
+                return [2 /*return*/, {
+                        content: [{ type: "text", text: formatGraph(graph, format) }],
+                    }];
+            case 5:
+                {
+                    _h = args, packageName = _h.package, _j = _h.includeTransitive, includeTransitive = _j === void 0 ? true : _j, _k = _h.format, format = _k === void 0 ? "tree" : _k;
+                    impact = analyzeImpact(cachedGraph, packageName, includeTransitive);
+                    if (format === "json") {
+                        return [2 /*return*/, {
+                                content: [{ type: "text", text: JSON.stringify(impact, null, 2) }],
+                            }];
+                    }
+                    else {
+                        lines = ["Impact analysis for: ".concat(packageName)];
+                        lines.push("\nDirect dependents (".concat(impact.direct.length, "):"));
+                        for (_i = 0, _l = impact.direct; _i < _l.length; _i++) {
+                            dep = _l[_i];
+                            lines.push("  \u2514\u2500\u2500 ".concat(dep));
+                        }
+                        if (includeTransitive && impact.transitive.length > 0) {
+                            lines.push("\nTransitive dependents (".concat(impact.transitive.length, "):"));
+                            for (_m = 0, _o = impact.transitive; _m < _o.length; _m++) {
+                                dep = _o[_m];
+                                lines.push("  \u2514\u2500\u2500 ".concat(dep));
+                            }
+                        }
+                        lines.push("\nTotal affected: ".concat(impact.all.length, " packages"));
+                        return [2 /*return*/, { content: [{ type: "text", text: lines.join("\n") }] }];
+                    }
+                }
+                _w.label = 6;
+            case 6:
+                {
+                    _p = args.maxDepth, maxDepth = _p === void 0 ? 10 : _p;
+                    cycles = findCircularDependencies(cachedGraph, maxDepth);
+                    if (cycles.length === 0) {
+                        return [2 /*return*/, {
+                                content: [{ type: "text", text: "No circular dependencies found!" }],
+                            }];
+                    }
+                    lines = ["Found ".concat(cycles.length, " circular dependencies:\n")];
+                    for (i = 0; i < cycles.length; i++) {
+                        lines.push("Cycle ".concat(i + 1, ":"));
+                        lines.push("  ".concat(cycles[i].join(" → ")));
+                        lines.push("");
+                    }
+                    return [2 /*return*/, { content: [{ type: "text", text: lines.join("\n") }] }];
+                }
+                _w.label = 7;
+            case 7:
+                {
+                    _q = args.includeExternal, includeExternal = _q === void 0 ? false : _q;
+                    unused = [];
+                    for (_r = 0, _s = cachedGraph.nodes; _r < _s.length; _r++) {
+                        _t = _s[_r], name_7 = _t[0], node = _t[1];
+                        if (node.type === "workspace" || includeExternal) {
+                            dependents = cachedGraph.reverseEdges.get(name_7);
+                            if (!dependents || dependents.size === 0) {
+                                unused.push(name_7);
+                            }
+                        }
+                    }
+                    if (unused.length === 0) {
+                        return [2 /*return*/, {
+                                content: [{ type: "text", text: "No unused packages found!" }],
+                            }];
+                    }
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Found ".concat(unused.length, " potentially unused packages:\n\n").concat(unused.map(function (n) { return "  \u2514\u2500\u2500 ".concat(n); }).join("\n")),
+                                },
+                            ],
+                        }];
+                }
+                _w.label = 8;
+            case 8:
+                {
+                    packageName_1 = args.package;
+                    node = cachedGraph.nodes.get(packageName_1);
+                    if (!node) {
+                        return [2 /*return*/, {
+                                content: [{ type: "text", text: "Package \"".concat(packageName_1, "\" not found in dependency graph.") }],
+                            }];
+                    }
+                    dependencies = cachedGraph.edges.filter(function (e) { return e.from === packageName_1; });
+                    dependents = Array.from(cachedGraph.reverseEdges.get(packageName_1) || []);
+                    lines = [
+                        "Package: ".concat(packageName_1),
+                        "Type: ".concat(node.type),
+                        "Path: ".concat(node.path || "N/A"),
+                        node.version ? "Version: ".concat(node.version) : "",
+                        "",
+                        "Dependencies (".concat(dependencies.length, "):"),
+                    ];
+                    for (_u = 0, dependencies_1 = dependencies; _u < dependencies_1.length; _u++) {
+                        dep = dependencies_1[_u];
+                        depNode = cachedGraph.nodes.get(dep.to);
+                        lines.push("  \u2514\u2500\u2500 ".concat(dep.to, " [").concat(dep.type, "]").concat((depNode === null || depNode === void 0 ? void 0 : depNode.version) ? " @ ".concat(depNode.version) : ""));
+                    }
+                    lines.push("", "Dependents (".concat(dependents.length, "):"));
+                    for (_v = 0, dependents_2 = dependents; _v < dependents_2.length; _v++) {
+                        dep = dependents_2[_v];
+                        lines.push("  \u2514\u2500\u2500 ".concat(dep));
+                    }
+                    return [2 /*return*/, { content: [{ type: "text", text: lines.join("\n") }] }];
+                }
+                _w.label = 9;
+            case 9: throw new Error("Unknown tool: ".concat(name));
+            case 10: return [3 /*break*/, 12];
+            case 11:
+                error_1 = _w.sent();
+                return [2 /*return*/, {
+                        content: [{ type: "text", text: "Error: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)) }],
+                        isError: true,
+                    }];
+            case 12: return [2 /*return*/];
+        }
+    });
+}); });
+// Start server
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var transport;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // Set up error handling
+                    server.onerror = function (error) { return console.error('[MCP] Error:', error); };
+                    // Signal handlers for graceful shutdown
+                    process.on('SIGINT', function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    console.error('[MCP] Shutting down...');
+                                    return [4 /*yield*/, server.close()];
+                                case 1:
+                                    _a.sent();
+                                    process.exit(0);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    process.on('SIGTERM', function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    console.error('[MCP] Shutting down...');
+                                    return [4 /*yield*/, server.close()];
+                                case 1:
+                                    _a.sent();
+                                    process.exit(0);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    transport = new stdio_js_1.StdioServerTransport();
+                    return [4 /*yield*/, server.connect(transport)];
+                case 1:
+                    _a.sent();
+                    // Log to stderr (doesn't interfere with JSON-RPC)
+                    console.error('[MCP] @mcp/dependency-graph server running on stdio');
+                    // Keep stdin open for requests
+                    process.stdin.resume();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main().catch(function (error) {
+    console.error('[MCP] Fatal error:', error);
+    process.exit(1);
+});