@ebowwa/dependency-graph-mcp 1.0.0

package/src/index.ts

@@ -0,0 +1,929 @@
+#!/usr/bin/env bun
+/**
+ * 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
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const TOOLING_DIR = dirname(fileURLToPath(
+  import.meta.url.replace("/MCP/packages/dependency-graph", "/packages/src/tooling")
+));
+
+// ==============
+// Types
+// ==============
+
+interface DependencyNode {
+  name: string;
+  path: string;
+  type: "package" | "workspace" | "external";
+  version?: string;
+}
+
+interface DependencyEdge {
+  from: string;
+  to: string;
+  type: "workspace" | "external" | "import";
+  importPath?: string;
+}
+
+interface DependencyGraph {
+  nodes: Map<string, DependencyNode>;
+  edges: DependencyEdge[];
+  reverseEdges: Map<string, Set<string>>;
+}
+
+interface ImportInfo {
+  from: string;
+  imports: string[];
+  file: string;
+}
+
+// ==============
+// Graph Builder
+// ==============
+
+class DependencyGraphBuilder {
+  private monorepoRoot: string;
+  private graph: DependencyGraph;
+  private packageCache: Map<string, any> = new Map();
+
+  constructor(monorepoRoot: string) {
+    this.monorepoRoot = monorepoRoot;
+    this.graph = {
+      nodes: new Map(),
+      edges: [],
+      reverseEdges: new Map(),
+    };
+  }
+
+  /**
+   * Build the complete dependency graph
+   */
+  async build(options: {
+    includeDevDependencies?: boolean;
+    analyzeImports?: boolean;
+    excludePatterns?: string[];
+  } = {}): Promise<DependencyGraph> {
+    const { includeDevDependencies = false, analyzeImports = true, excludePatterns = [] } = options;
+
+    // Discover all packages in the monorepo
+    const packages = await this.discoverPackages();
+
+    // Add nodes for all packages
+    for (const pkg of packages) {
+      this.addNode(pkg.name, pkg.path, "workspace", pkg.version);
+    }
+
+    // Analyze dependencies for each package
+    for (const pkg of packages) {
+      await this.analyzePackageDependencies(pkg, includeDevDependencies, excludePatterns);
+
+      if (analyzeImports) {
+        await this.analyzeImports(pkg);
+      }
+    }
+
+    // Build reverse edges for impact analysis
+    this.buildReverseEdges();
+
+    return this.graph;
+  }
+
+  /**
+   * Discover all package.json files in the monorepo
+   */
+  private async discoverPackages(): Promise<Array<{ name: string; path: string; version: string }>> {
+    const packages: Array<{ name: string; path: string; version: string }> = [];
+    const seen = new Set<string>();
+
+    // Search in common locations
+    const searchPaths = [
+      this.monorepoRoot,
+      join(this.monorepoRoot, "packages"),
+      join(this.monorepoRoot, "packages/src"),
+      join(this.monorepoRoot, "apps"),
+      join(this.monorepoRoot, "MCP/packages"),
+    ];
+
+    for (const searchPath of searchPaths) {
+      if (!existsSync(searchPath)) continue;
+
+      await this.searchDirectory(searchPath, packages, seen, 0, 4);
+    }
+
+    return packages;
+  }
+
+  /**
+   * Recursively search for package.json files
+   */
+  private async searchDirectory(
+    dir: string,
+    packages: Array<{ name: string; path: string; version: string }>,
+    seen: Set<string>,
+    depth: number,
+    maxDepth: number
+  ): Promise<void> {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        // Skip node_modules and hidden dirs
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        if (entry.name === "dist" || entry.name === "build") continue;
+
+        const fullPath = join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          await this.searchDirectory(fullPath, packages, seen, depth + 1, maxDepth);
+        } else if (entry.name === "package.json") {
+          const packageDir = dirname(fullPath);
+          const relativePath = relative(this.monorepoRoot, packageDir);
+
+          if (seen.has(relativePath)) continue;
+          seen.add(relativePath);
+
+          try {
+            const pkg = JSON.parse(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 });
+            }
+          } catch {
+            // Invalid package.json, skip
+          }
+        }
+      }
+    } catch {
+      // Directory not accessible, skip
+    }
+  }
+
+  /**
+   * Analyze package.json dependencies
+   */
+  private async analyzePackageDependencies(
+    pkg: { name: string; path: string; version: string },
+    includeDev: boolean,
+    excludePatterns: string[]
+  ): Promise<void> {
+    const pkgPath = join(this.monorepoRoot, pkg.path, "package.json");
+    if (!existsSync(pkgPath)) return;
+
+    const packageJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+
+    const depTypes = ["dependencies"];
+    if (includeDev) depTypes.push("devDependencies", "peerDependencies", "optionalDependencies");
+
+    for (const depType of depTypes) {
+      const deps = packageJson[depType];
+      if (!deps) continue;
+
+      for (const [depName, depVersion] of Object.entries(deps as Record<string, string>)) {
+        // Check if this matches any exclude pattern
+        if (excludePatterns.some(pattern => depName.match(pattern))) continue;
+
+        const isWorkspace = depVersion === "workspace:*" || depVersion === "workspace:^" || depVersion === "workspace:~";
+
+        if (isWorkspace) {
+          // This is a workspace dependency
+          // Find the actual package in our cache
+          const targetPkg = this.packageCache.get(depName);
+          if (targetPkg) {
+            this.addEdge(pkg.name, depName, "workspace");
+          }
+        } else if (this.packageCache.has(depName)) {
+          // It's a local package but not using workspace: protocol
+          this.addEdge(pkg.name, depName, "workspace");
+        } else {
+          // External dependency
+          this.addNode(depName, "", "external", depVersion as string);
+          this.addEdge(pkg.name, depName, "external");
+        }
+      }
+    }
+  }
+
+  /**
+   * Analyze TypeScript/JavaScript imports
+   */
+  private async analyzeImports(pkg: { name: string; path: string; version: string }): Promise<void> {
+    const pkgDir = join(this.monorepoRoot, pkg.path);
+
+    // Common source directories
+    const sourceDirs = ["src", "lib", ""];
+
+    for (const sourceDir of sourceDirs) {
+      const searchPath = sourceDir ? join(pkgDir, sourceDir) : pkgDir;
+      if (!existsSync(searchPath)) continue;
+
+      await this.analyzeImportsInDirectory(pkg.name, searchPath);
+    }
+  }
+
+  /**
+   * Recursively analyze imports in a directory
+   */
+  private async analyzeImportsInDirectory(packageName: string, dir: string): Promise<void> {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        if (entry.name === "dist" || entry.name === "build") continue;
+
+        const fullPath = join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          await this.analyzeImportsInDirectory(packageName, fullPath);
+        } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".js") || entry.name.endsWith(".jsx") || entry.name.endsWith(".mjs")) {
+          await this.analyzeImportsInFile(packageName, fullPath);
+        }
+      }
+    } catch {
+      // Directory not accessible
+    }
+  }
+
+  /**
+   * Analyze imports in a single file
+   */
+  private async analyzeImportsInFile(packageName: string, filePath: string): Promise<void> {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+
+      // Match various import patterns
+      const 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 (const pattern of importPatterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+          const importPath = match[1];
+
+          // Skip relative imports
+          if (importPath.startsWith(".") || importPath.startsWith("/")) continue;
+
+          // Check if this is a known workspace package
+          for (const [pkgName, pkgData] of this.packageCache) {
+            if (importPath === pkgName || importPath.startsWith(pkgName + "/")) {
+              this.addEdge(packageName, pkgName, "import", importPath);
+              break;
+            }
+          }
+        }
+      }
+    } catch {
+      // File not readable
+    }
+  }
+
+  /**
+   * Add a node to the graph
+   */
+  private addNode(name: string, path: string, type: "package" | "workspace" | "external", version?: string): void {
+    if (!this.graph.nodes.has(name)) {
+      this.graph.nodes.set(name, { name, path, type, version });
+      this.graph.reverseEdges.set(name, new Set());
+    }
+  }
+
+  /**
+   * Add an edge to the graph
+   */
+  private addEdge(from: string, to: string, type: "workspace" | "external" | "import", importPath?: string): void {
+    // Skip self-references
+    if (from === to) return;
+
+    // Check if edge already exists
+    const existing = this.graph.edges.find(e => e.from === from && e.to === to);
+    if (existing) return;
+
+    this.graph.edges.push({ from, to, type, 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
+   */
+  private buildReverseEdges(): void {
+    for (const [to, dependents] of this.graph.reverseEdges) {
+      // Ensure node exists
+      if (!this.graph.nodes.has(to)) {
+        this.graph.nodes.set(to, { name: to, path: "", type: "external" });
+      }
+    }
+  }
+
+  /**
+   * Get the built graph
+   */
+  getGraph(): DependencyGraph {
+    return this.graph;
+  }
+}
+
+// ==============
+// MCP Server
+// ==============
+
+const DEPENDENCY_GRAPH_SCHEMA = {
+  name: "dependency_graph",
+  description: "Build a complete dependency graph of the monorepo",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      includeDevDependencies: {
+        type: "boolean" as const,
+        description: "Include devDependencies in the graph",
+        default: false,
+      },
+      analyzeImports: {
+        type: "boolean" as const,
+        description: "Analyze TypeScript/JavaScript imports",
+        default: true,
+      },
+      excludePatterns: {
+        type: "array" as const,
+        items: { type: "string" as const },
+        description: "Regex patterns to exclude from dependency analysis",
+        default: [],
+      },
+      format: {
+        type: "string" as const,
+        enum: ["json", "mermaid", "dot", "tree"] as const,
+        description: "Output format for the graph",
+        default: "json",
+      },
+    },
+  },
+};
+
+const IMPACT_ANALYSIS_SCHEMA = {
+  name: "impact_analysis",
+  description: "Analyze the impact of changing a specific package",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      package: {
+        type: "string" as const,
+        description: "Package name to analyze",
+      },
+      includeTransitive: {
+        type: "boolean" as const,
+        description: "Include transitive dependents",
+        default: true,
+      },
+      format: {
+        type: "string" as const,
+        enum: ["json", "tree"] as const,
+        description: "Output format",
+        default: "tree",
+      },
+    },
+    required: ["package"],
+  },
+};
+
+const FIND_CIRCULAR_SCHEMA = {
+  name: "find_circular",
+  description: "Find circular dependencies in the monorepo",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      maxDepth: {
+        type: "number" as const,
+        description: "Maximum depth to search for cycles",
+        default: 10,
+      },
+    },
+  },
+};
+
+const UNUSED_CODE_SCHEMA = {
+  name: "unused_code",
+  description: "Find potentially unused packages (no dependents)",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      includeExternal: {
+        type: "boolean" as const,
+        description: "Include external dependencies",
+        default: false,
+      },
+    },
+  },
+};
+
+const PACKAGE_INFO_SCHEMA = {
+  name: "package_info",
+  description: "Get detailed information about a specific package",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      package: {
+        type: "string" as const,
+        description: "Package name",
+      },
+    },
+    required: ["package"],
+  },
+};
+
+// Format the graph for output
+function formatGraph(graph: DependencyGraph, format: string): string {
+  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: DependencyGraph): string {
+  const lines = ["graph TD"];
+
+  // Add nodes
+  for (const [name, node] of graph.nodes) {
+    const label = node.type === "workspace" ? `📦 ${name}` : `📚 ${name}`;
+    lines.push(`  ${name.replace(/[^a-zA-Z0-9]/g, "_")}["${label}"]`);
+  }
+
+  // Add edges
+  for (const edge of graph.edges) {
+    const from = edge.from.replace(/[^a-zA-Z0-9]/g, "_");
+    const to = edge.to.replace(/[^a-zA-Z0-9]/g, "_");
+    const label = edge.type === "workspace" ? "workspace" : edge.type === "import" ? "imports" : "external";
+    lines.push(`  ${from} -->|${label}| ${to}`);
+  }
+
+  // Add styles
+  lines.push('  classDef workspace fill:#e1f5fe');
+  lines.push('  classDef external fill:#f5f5f5');
+  lines.push('  classDef import fill:#fff3e0');
+
+  for (const [name, node] of graph.nodes) {
+    const id = name.replace(/[^a-zA-Z0-9]/g, "_");
+    if (node.type === "workspace") {
+      lines.push(`  class ${id} workspace`);
+    } else if (node.type === "external") {
+      lines.push(`  class ${id} external`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function formatAsDot(graph: DependencyGraph): string {
+  const lines = ["digraph dependencies {"];
+  lines.push('  rankdir=LR;');
+  lines.push('  node [shape=box];');
+
+  // Add nodes
+  for (const [name, node] of graph.nodes) {
+    const color = node.type === "workspace" ? "lightblue" : "lightgray";
+    lines.push(`  "${name}" [fillcolor=${color}, style=filled];`);
+  }
+
+  // Add edges
+  for (const edge of graph.edges) {
+    const style = edge.type === "workspace" ? "solid" : "dashed";
+    lines.push(`  "${edge.from}" -> "${edge.to}" [style=${style}, label="${edge.type}"];`);
+  }
+
+  lines.push("}");
+  return lines.join("\n");
+}
+
+function formatAsTree(graph: DependencyGraph): string {
+  const lines: string[] = [];
+  const seen = new Set<string>();
+
+  // Find root nodes (no incoming edges from other workspace packages)
+  const workspaceNodes = Array.from(graph.nodes.values()).filter(n => n.type === "workspace");
+  const incomingEdges = new Map<string, number>();
+
+  for (const node of workspaceNodes) {
+    incomingEdges.set(node.name, 0);
+  }
+
+  for (const edge of graph.edges) {
+    if (graph.nodes.get(edge.to)?.type === "workspace") {
+      incomingEdges.set(edge.to, (incomingEdges.get(edge.to) || 0) + 1);
+    }
+  }
+
+  // Start from roots
+  for (const [name, node] of graph.nodes) {
+    if (node.type === "workspace" && (incomingEdges.get(name) || 0) === 0) {
+      lines.push(`📦 ${name}`);
+      printTree(graph, name, "", seen, lines);
+    }
+  }
+
+  // Add any disconnected nodes
+  for (const [name, node] of graph.nodes) {
+    if (!seen.has(name) && node.type === "workspace") {
+      lines.push(`📦 ${name} (disconnected)`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function printTree(
+  graph: DependencyGraph,
+  nodeName: string,
+  prefix: string,
+  seen: Set<string>,
+  lines: string[]
+): void {
+  seen.add(nodeName);
+
+  // Find outgoing edges to other workspace packages
+  const outgoing = graph.edges.filter(e => e.from === nodeName && graph.nodes.get(e.to)?.type === "workspace");
+
+  for (let i = 0; i < outgoing.length; i++) {
+    const edge = outgoing[i];
+    const isLast = i === outgoing.length - 1;
+    const connector = isLast ? "└──" : "├──";
+    const childPrefix = prefix + (isLast ? "    " : "│   ");
+
+    lines.push(`${prefix}${connector} 📦 ${edge.to} [${edge.type}]`);
+    if (!seen.has(edge.to)) {
+      printTree(graph, edge.to, childPrefix, seen, lines);
+    }
+  }
+
+  // Show external dependencies count
+  const externals = graph.edges.filter(e => e.from === nodeName && graph.nodes.get(e.to)?.type === "external");
+  if (externals.length > 0) {
+    lines.push(`${prefix}└── 📚 ${externals.length} external dependencies`);
+  }
+}
+
+// Find circular dependencies using DFS
+function findCircularDependencies(graph: DependencyGraph, maxDepth: number = 10): string[][] {
+  const cycles: string[][] = [];
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+
+  function dfs(node: string, path: string[]): void {
+    if (path.length > maxDepth) return;
+
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+
+    // Check all outgoing edges
+    for (const edge of graph.edges) {
+      if (edge.from === node) {
+        if (recursionStack.has(edge.to)) {
+          // Found a cycle
+          const cycleStart = path.indexOf(edge.to);
+          if (cycleStart >= 0) {
+            cycles.push([...path.slice(cycleStart), edge.to]);
+          }
+        } else if (!visited.has(edge.to)) {
+          dfs(edge.to, [...path]);
+        }
+      }
+    }
+
+    recursionStack.delete(node);
+  }
+
+  // Start DFS from each workspace node
+  for (const [name, node] of graph.nodes) {
+    if (node.type === "workspace" && !visited.has(name)) {
+      dfs(name, []);
+    }
+  }
+
+  return cycles;
+}
+
+// Impact analysis
+function analyzeImpact(graph: DependencyGraph, packageName: string, includeTransitive: boolean = true): {
+  direct: string[];
+  transitive: string[];
+  all: string[];
+} {
+  const direct: string[] = [];
+  const transitive: string[] = [];
+  const visited = new Set<string>();
+
+  // Get direct dependents
+  const directDependents = graph.reverseEdges.get(packageName);
+  if (directDependents) {
+    for (const dep of directDependents) {
+      direct.push(dep);
+      visited.add(dep);
+    }
+  }
+
+  // Get transitive dependents
+  if (includeTransitive) {
+    for (const dep of direct) {
+      collectTransitive(graph, dep, visited, transitive);
+    }
+  }
+
+  return {
+    direct,
+    transitive,
+    all: Array.from(visited),
+  };
+}
+
+function collectTransitive(graph: DependencyGraph, packageName: string, visited: Set<string>, result: string[]): void {
+  const dependents = graph.reverseEdges.get(packageName);
+  if (!dependents) return;
+
+  for (const dep of dependents) {
+    if (!visited.has(dep)) {
+      visited.add(dep);
+      result.push(dep);
+      collectTransitive(graph, dep, visited, result);
+    }
+  }
+}
+
+// Start the MCP server
+const server = new Server(
+  {
+    name: "@mcp/dependency-graph",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+let cachedGraph: DependencyGraph | null = null;
+let cachedBuilder: DependencyGraphBuilder | null = null;
+
+// List tools
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    DEPENDENCY_GRAPH_SCHEMA,
+    IMPACT_ANALYSIS_SCHEMA,
+    FIND_CIRCULAR_SCHEMA,
+    UNUSED_CODE_SCHEMA,
+    PACKAGE_INFO_SCHEMA,
+  ],
+}));
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  // Initialize graph builder if needed
+  if (!cachedBuilder) {
+    const monorepoRoot = process.cwd();
+    cachedBuilder = new DependencyGraphBuilder(monorepoRoot);
+  }
+
+  // Auto-build graph if not cached
+  if (!cachedGraph) {
+    await cachedBuilder.build();
+    cachedGraph = cachedBuilder.getGraph();
+  }
+
+  try {
+    switch (name) {
+      case "dependency_graph": {
+        const {
+          includeDevDependencies = false,
+          analyzeImports = true,
+          excludePatterns = [],
+          format = "json",
+        } = args as {
+          includeDevDependencies?: boolean;
+          analyzeImports?: boolean;
+          excludePatterns?: string[];
+          format?: "json" | "mermaid" | "dot" | "tree";
+        };
+
+        await cachedBuilder.build({ includeDevDependencies, analyzeImports, excludePatterns });
+        const graph = cachedBuilder.getGraph();
+        cachedGraph = graph;
+
+        return {
+          content: [{ type: "text", text: formatGraph(graph, format) }],
+        };
+      }
+
+      case "impact_analysis": {
+        const { package: packageName, includeTransitive = true, format = "tree" } = args as {
+          package: string;
+          includeTransitive?: boolean;
+          format?: "json" | "tree";
+        };
+
+        const impact = analyzeImpact(cachedGraph, packageName, includeTransitive);
+
+        if (format === "json") {
+          return {
+            content: [{ type: "text", text: JSON.stringify(impact, null, 2) }],
+          };
+        } else {
+          const lines = [`Impact analysis for: ${packageName}`];
+          lines.push(`\nDirect dependents (${impact.direct.length}):`);
+          for (const dep of impact.direct) {
+            lines.push(`  └── ${dep}`);
+          }
+          if (includeTransitive && impact.transitive.length > 0) {
+            lines.push(`\nTransitive dependents (${impact.transitive.length}):`);
+            for (const dep of impact.transitive) {
+              lines.push(`  └── ${dep}`);
+            }
+          }
+          lines.push(`\nTotal affected: ${impact.all.length} packages`);
+          return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+      }
+
+      case "find_circular": {
+        const { maxDepth = 10 } = args as { maxDepth?: number };
+
+        const cycles = findCircularDependencies(cachedGraph, maxDepth);
+
+        if (cycles.length === 0) {
+          return {
+            content: [{ type: "text", text: "No circular dependencies found!" }],
+          };
+        }
+
+        const lines = [`Found ${cycles.length} circular dependencies:\n`];
+        for (let i = 0; i < cycles.length; i++) {
+          lines.push(`Cycle ${i + 1}:`);
+          lines.push(`  ${cycles[i].join(" → ")}`);
+          lines.push("");
+        }
+
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+
+      case "unused_code": {
+        const { includeExternal = false } = args as { includeExternal?: boolean };
+
+        const unused: string[] = [];
+
+        for (const [name, node] of cachedGraph.nodes) {
+          if (node.type === "workspace" || includeExternal) {
+            const dependents = cachedGraph.reverseEdges.get(name);
+            if (!dependents || dependents.size === 0) {
+              unused.push(name);
+            }
+          }
+        }
+
+        if (unused.length === 0) {
+          return {
+            content: [{ type: "text", text: "No unused packages found!" }],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${unused.length} potentially unused packages:\n\n${unused.map(n => `  └── ${n}`).join("\n")}`,
+            },
+          ],
+        };
+      }
+
+      case "package_info": {
+        const { package: packageName } = args as { package: string };
+
+        const node = cachedGraph.nodes.get(packageName);
+        if (!node) {
+          return {
+            content: [{ type: "text", text: `Package "${packageName}" not found in dependency graph.` }],
+          };
+        }
+
+        // Get dependencies
+        const dependencies = cachedGraph.edges.filter(e => e.from === packageName);
+        // Get dependents
+        const dependents = Array.from(cachedGraph.reverseEdges.get(packageName) || []);
+
+        const lines = [
+          `Package: ${packageName}`,
+          `Type: ${node.type}`,
+          `Path: ${node.path || "N/A"}`,
+          node.version ? `Version: ${node.version}` : "",
+          "",
+          `Dependencies (${dependencies.length}):`,
+        ];
+
+        for (const dep of dependencies) {
+          const depNode = cachedGraph.nodes.get(dep.to);
+          lines.push(`  └── ${dep.to} [${dep.type}]${depNode?.version ? ` @ ${depNode.version}` : ""}`);
+        }
+
+        lines.push(``, `Dependents (${dependents.length}):`);
+        for (const dep of dependents) {
+          lines.push(`  └── ${dep}`);
+        }
+
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  // Set up error handling
+  server.onerror = (error) => console.error('[MCP] Error:', error);
+
+  // Signal handlers for graceful shutdown
+  process.on('SIGINT', async () => {
+    console.error('[MCP] Shutting down...');
+    await server.close();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', async () => {
+    console.error('[MCP] Shutting down...');
+    await server.close();
+    process.exit(0);
+  });
+
+  // Connect transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // 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();
+}
+
+main().catch((error) => {
+  console.error('[MCP] Fatal error:', error);
+  process.exit(1);
+});