@ebowwa/dependency-graph-mcp 1.0.1 → 1.1.1

package/bun.lock

@@ -5,6 +5,7 @@
     "": {
       "name": "@ebowwa/dependency-graph-mcp",
       "dependencies": {
+        "@ebowwa/dependency-graph": "^1.0.2",
         "@modelcontextprotocol/sdk": "^1.0.4",
         "zod": "^3.24.1",
       },
@@ -19,6 +20,8 @@
     },
   },
   "packages": {
+    "@ebowwa/dependency-graph": ["@ebowwa/dependency-graph@1.0.2", "", { "bin": { "dependency-graph": "dist/cli.js" } }, "sha512-r9wggNgQ3t+oFg/1hd4wTs29uJ8ckVa9l1mHWQXBHnrHsgvPI+fhwJOHJLbGrU0vsOpv5q8H3ikThiQDMtPFxA=="],
+
     "@hono/node-server": ["@hono/node-server@1.19.9", "", { "peerDependencies": { "hono": "^4" } }, "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw=="],
 
     "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.26.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg=="],

package/dist/index.js

@@ -13267,11 +13267,9 @@ var ServerResultSchema2 = union([
   CreateTaskResultSchema2
 ]);
 
-// src/index.ts
-import { readdirSync, readFileSync, existsSync } from "fs";
-import { join, dirname, relative } from "path";
-import { fileURLToPath } from "url";
-var TOOLING_DIR = dirname(fileURLToPath(import.meta.url.replace("/MCP/packages/dependency-graph", "/packages/src/tooling")));
+// ../../src/dependency-graph/dist/builder.js
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
 
 class DependencyGraphBuilder {
   monorepoRoot;
@@ -13461,105 +13459,111 @@ class DependencyGraphBuilder {
   getGraph() {
     return this.graph;
   }
+  getMonorepoRoot() {
+    return this.monorepoRoot;
+  }
 }
-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"
+// ../../src/dependency-graph/dist/analysis.js
+function findCircularDependencies(graph, maxDepth = 10) {
+  const cycles = [];
+  const visited = new Set;
+  const recursionStack = new Set;
+  function dfs(node, path) {
+    if (path.length > maxDepth)
+      return;
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+    for (const edge of graph.edges) {
+      if (edge.from === node) {
+        if (recursionStack.has(edge.to)) {
+          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);
   }
-};
-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"]
+  for (const [name, node] of graph.nodes) {
+    if (node.type === "workspace" && !visited.has(name)) {
+      dfs(name, []);
+    }
   }
-};
-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
-      }
+  return cycles;
+}
+function analyzeImpact(graph, packageName, includeTransitive = true) {
+  const direct = [];
+  const transitive = [];
+  const visited = new Set;
+  const directDependents = graph.reverseEdges.get(packageName);
+  if (directDependents) {
+    for (const dep of directDependents) {
+      direct.push(dep);
+      visited.add(dep);
     }
   }
-};
-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
-      }
+  if (includeTransitive) {
+    for (const dep of direct) {
+      collectTransitive(graph, dep, visited, transitive);
     }
   }
-};
-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"
+  return {
+    direct,
+    transitive,
+    all: Array.from(visited)
+  };
+}
+function collectTransitive(graph, packageName, visited, result) {
+  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);
+    }
+  }
+}
+function findUnusedPackages(graph, includeExternal = false) {
+  const unused = [];
+  for (const [name, node] of graph.nodes) {
+    if (node.type === "workspace" || includeExternal) {
+      const dependents = graph.reverseEdges.get(name);
+      if (!dependents || dependents.size === 0) {
+        unused.push(name);
       }
-    },
-    required: ["package"]
+    }
   }
-};
+  return unused;
+}
+function getPackageInfo(graph, packageName) {
+  const node = graph.nodes.get(packageName);
+  if (!node)
+    return null;
+  const dependencies = graph.edges.filter((e) => e.from === packageName).map((edge) => {
+    const depNode = graph.nodes.get(edge.to);
+    return {
+      name: edge.to,
+      type: edge.type,
+      version: depNode?.version
+    };
+  });
+  const dependents = Array.from(graph.reverseEdges.get(packageName) || []);
+  return {
+    name: packageName,
+    type: node.type,
+    path: node.path || "N/A",
+    version: node.version,
+    dependencies,
+    dependents
+  };
+}
+// ../../src/dependency-graph/dist/formatters.js
 function formatGraph(graph, format) {
   switch (format) {
     case "mermaid":
@@ -13570,21 +13574,24 @@ function formatGraph(graph, format) {
       return formatAsTree(graph);
     case "json":
     default:
-      return JSON.stringify({
-        nodes: Array.from(graph.nodes.values()),
-        edges: graph.edges
-      }, null, 2);
+      return formatAsJson(graph);
   }
 }
+function formatAsJson(graph) {
+  return JSON.stringify({
+    nodes: Array.from(graph.nodes.values()),
+    edges: graph.edges
+  }, null, 2);
+}
 function formatAsMermaid(graph) {
   const lines = ["graph TD"];
   for (const [name, node] of graph.nodes) {
     const label = node.type === "workspace" ? `\uD83D\uDCE6 ${name}` : `\uD83D\uDCDA ${name}`;
-    lines.push(`  ${name.replace(/[^a-zA-Z0-9]/g, "_")}["${label}"]`);
+    lines.push(`  ${sanitizeId(name)}["${label}"]`);
   }
   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 from = sanitizeId(edge.from);
+    const to = sanitizeId(edge.to);
     const label = edge.type === "workspace" ? "workspace" : edge.type === "import" ? "imports" : "external";
     lines.push(`  ${from} -->|${label}| ${to}`);
   }
@@ -13592,7 +13599,7 @@ function formatAsMermaid(graph) {
   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, "_");
+    const id = sanitizeId(name);
     if (node.type === "workspace") {
       lines.push(`  class ${id} workspace`);
     } else if (node.type === "external") {
@@ -13651,8 +13658,8 @@ function printTree(graph, nodeName, prefix, seen, lines) {
   for (let i = 0;i < outgoing.length; i++) {
     const edge = outgoing[i];
     const isLast = i === outgoing.length - 1;
-    const connector = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-    const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    const connector = isLast ? "└──" : "├──";
+    const childPrefix = prefix + (isLast ? "    " : "│   ");
     lines.push(`${prefix}${connector} \uD83D\uDCE6 ${edge.to} [${edge.type}]`);
     if (!seen.has(edge.to)) {
       printTree(graph, edge.to, childPrefix, seen, lines);
@@ -13660,77 +13667,114 @@ function printTree(graph, nodeName, prefix, seen, lines) {
   }
   const externals = graph.edges.filter((e) => e.from === nodeName && graph.nodes.get(e.to)?.type === "external");
   if (externals.length > 0) {
-    lines.push(`${prefix}\u2514\u2500\u2500 \uD83D\uDCDA ${externals.length} external dependencies`);
+    lines.push(`${prefix}└── \uD83D\uDCDA ${externals.length} external dependencies`);
   }
 }
-function findCircularDependencies(graph, maxDepth = 10) {
-  const cycles = [];
-  const visited = new Set;
-  const recursionStack = new Set;
-  function dfs(node, path) {
-    if (path.length > maxDepth)
-      return;
-    visited.add(node);
-    recursionStack.add(node);
-    path.push(node);
-    for (const edge of graph.edges) {
-      if (edge.from === node) {
-        if (recursionStack.has(edge.to)) {
-          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]);
-        }
+function sanitizeId(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "_");
+}
+// src/index.ts
+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"
       }
     }
-    recursionStack.delete(node);
   }
-  for (const [name, node] of graph.nodes) {
-    if (node.type === "workspace" && !visited.has(name)) {
-      dfs(name, []);
-    }
+};
+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"]
   }
-  return cycles;
-}
-function analyzeImpact(graph, packageName, includeTransitive = true) {
-  const direct = [];
-  const transitive = [];
-  const visited = new Set;
-  const directDependents = graph.reverseEdges.get(packageName);
-  if (directDependents) {
-    for (const dep of directDependents) {
-      direct.push(dep);
-      visited.add(dep);
+};
+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
+      }
     }
   }
-  if (includeTransitive) {
-    for (const dep of direct) {
-      collectTransitive(graph, dep, visited, transitive);
+};
+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
+      }
     }
   }
-  return {
-    direct,
-    transitive,
-    all: Array.from(visited)
-  };
-}
-function collectTransitive(graph, packageName, visited, result) {
-  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);
-    }
+};
+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"]
   }
-}
+};
 var server = new Server({
   name: "@ebowwa/dependency-graph-mcp",
-  version: "1.0.0"
+  version: "1.0.1"
 }, {
   capabilities: {
     tools: {}
@@ -13766,7 +13810,11 @@ server.setRequestHandler(CallToolRequestSchema2, async (request) => {
           excludePatterns = [],
           format = "json"
         } = args;
-        await cachedBuilder.build({ includeDevDependencies, analyzeImports, excludePatterns });
+        await cachedBuilder.build({
+          includeDevDependencies,
+          analyzeImports,
+          excludePatterns
+        });
         const graph = cachedBuilder.getGraph();
         cachedGraph = graph;
         return {
@@ -13820,15 +13868,7 @@ Total affected: ${impact.all.length} packages`);
       }
       case "unused_code": {
         const { includeExternal = false } = args;
-        const unused = [];
-        for (const [name2, node] of cachedGraph.nodes) {
-          if (node.type === "workspace" || includeExternal) {
-            const dependents = cachedGraph.reverseEdges.get(name2);
-            if (!dependents || dependents.size === 0) {
-              unused.push(name2);
-            }
-          }
-        }
+        const unused = findUnusedPackages(cachedGraph, includeExternal);
         if (unused.length === 0) {
           return {
             content: [{ type: "text", text: "No unused packages found!" }]
@@ -13848,28 +13888,30 @@ ${unused.map((n) => `  \u2514\u2500\u2500 ${n}`).join(`
       }
       case "package_info": {
         const { package: packageName } = args;
-        const node = cachedGraph.nodes.get(packageName);
-        if (!node) {
+        const info = getPackageInfo(cachedGraph, packageName);
+        if (!info) {
           return {
-            content: [{ type: "text", text: `Package "${packageName}" not found in dependency graph.` }]
+            content: [
+              {
+                type: "text",
+                text: `Package "${packageName}" not found in dependency graph.`
+              }
+            ]
           };
         }
-        const dependencies = cachedGraph.edges.filter((e) => e.from === packageName);
-        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}` : "",
+          `Package: ${info.name}`,
+          `Type: ${info.type}`,
+          `Path: ${info.path}`,
+          info.version ? `Version: ${info.version}` : "",
           "",
-          `Dependencies (${dependencies.length}):`
+          `Dependencies (${info.dependencies.length}):`
         ];
-        for (const dep of dependencies) {
-          const depNode = cachedGraph.nodes.get(dep.to);
-          lines.push(`  \u2514\u2500\u2500 ${dep.to} [${dep.type}]${depNode?.version ? ` @ ${depNode.version}` : ""}`);
+        for (const dep of info.dependencies) {
+          lines.push(`  \u2514\u2500\u2500 ${dep.name} [${dep.type}]${dep.version ? ` @ ${dep.version}` : ""}`);
         }
-        lines.push(``, `Dependents (${dependents.length}):`);
-        for (const dep of dependents) {
+        lines.push(``, `Dependents (${info.dependents.length}):`);
+        for (const dep of info.dependents) {
           lines.push(`  \u2514\u2500\u2500 ${dep}`);
         }
         return { content: [{ type: "text", text: lines.join(`
@@ -13880,7 +13922,12 @@ ${unused.map((n) => `  \u2514\u2500\u2500 ${n}`).join(`
     }
   } catch (error2) {
     return {
-      content: [{ type: "text", text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}` }],
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+        }
+      ],
       isError: true
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/dependency-graph-mcp",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "MCP server for dependency graph analysis and visualization in monorepos",
   "type": "module",
   "main": "dist/index.js",
@@ -11,9 +11,14 @@
   "scripts": {
     "build": "bun build src/cli.ts --outdir dist --target node && bun build src/index.ts --outdir dist --target node && chmod +x dist/cli.js",
     "dev": "bun run src/index.ts",
-    "mcp-dev": "MCP_DEV=true bun run src/index.ts"
+    "mcp-dev": "MCP_DEV=true bun run src/index.ts",
+    "bump:patch": "npm version patch --no-git-tag-version && bun run build",
+    "bump:minor": "npm version minor --no-git-tag-version && bun run build",
+    "bump:major": "npm version major --no-git-tag-version && bun run build",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "@ebowwa/dependency-graph": "^1.0.2",
     "@modelcontextprotocol/sdk": "^1.0.4",
     "zod": "^3.24.1"
   },

package/src/index.ts

@@ -1,14 +1,9 @@
 #!/usr/bin/env bun
 /**
- * Dependency Graph MCP Server
+ * @ebowwa/dependency-graph-mcp
  *
- * 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
+ * MCP interface layer for dependency graph analysis.
+ * Uses @ebowwa/dependency-graph for core logic.
  */
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -17,351 +12,21 @@ 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;
-  }
-}
+// Import from core package
+import {
+  DependencyGraphBuilder,
+  formatGraph,
+  findCircularDependencies,
+  analyzeImpact,
+  findUnusedPackages,
+  getPackageInfo,
+  type DependencyGraph,
+  type OutputFormat,
+} from "@ebowwa/dependency-graph";
 
 // ==============
-// MCP Server
+// MCP Tool Schemas
 // ==============
 
 const DEPENDENCY_GRAPH_SCHEMA = {
@@ -467,242 +132,14 @@ const PACKAGE_INFO_SCHEMA = {
   },
 };
 
-// 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);
-    }
-  }
-}
+// ==============
+// MCP Server
+// ==============
 
-// Start the MCP server
 const server = new Server(
   {
     name: "@ebowwa/dependency-graph-mcp",
-    version: "1.0.0",
+    version: "1.0.1",
   },
   {
     capabilities: {
@@ -753,10 +190,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           includeDevDependencies?: boolean;
           analyzeImports?: boolean;
           excludePatterns?: string[];
-          format?: "json" | "mermaid" | "dot" | "tree";
+          format?: OutputFormat;
         };
 
-        await cachedBuilder.build({ includeDevDependencies, analyzeImports, excludePatterns });
+        await cachedBuilder.build({
+          includeDevDependencies,
+          analyzeImports,
+          excludePatterns,
+        });
         const graph = cachedBuilder.getGraph();
         cachedGraph = graph;
 
@@ -766,11 +207,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case "impact_analysis": {
-        const { package: packageName, includeTransitive = true, format = "tree" } = args as {
-          package: string;
-          includeTransitive?: boolean;
-          format?: "json" | "tree";
-        };
+        const { package: packageName, includeTransitive = true, format = "tree" } =
+          args as {
+            package: string;
+            includeTransitive?: boolean;
+            format?: "json" | "tree";
+          };
 
         const impact = analyzeImpact(cachedGraph, packageName, includeTransitive);
 
@@ -819,16 +261,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       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);
-            }
-          }
-        }
+        const unused = findUnusedPackages(cachedGraph, includeExternal);
 
         if (unused.length === 0) {
           return {
@@ -840,7 +273,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           content: [
             {
               type: "text",
-              text: `Found ${unused.length} potentially unused packages:\n\n${unused.map(n => `  └── ${n}`).join("\n")}`,
+              text: `Found ${unused.length} potentially unused packages:\n\n${unused.map((n) => `  └── ${n}`).join("\n")}`,
             },
           ],
         };
@@ -849,34 +282,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "package_info": {
         const { package: packageName } = args as { package: string };
 
-        const node = cachedGraph.nodes.get(packageName);
-        if (!node) {
+        const info = getPackageInfo(cachedGraph, packageName);
+        if (!info) {
           return {
-            content: [{ type: "text", text: `Package "${packageName}" not found in dependency graph.` }],
+            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}` : "",
+          `Package: ${info.name}`,
+          `Type: ${info.type}`,
+          `Path: ${info.path}`,
+          info.version ? `Version: ${info.version}` : "",
           "",
-          `Dependencies (${dependencies.length}):`,
+          `Dependencies (${info.dependencies.length}):`,
         ];
 
-        for (const dep of dependencies) {
-          const depNode = cachedGraph.nodes.get(dep.to);
-          lines.push(`  └── ${dep.to} [${dep.type}]${depNode?.version ? ` @ ${depNode.version}` : ""}`);
+        for (const dep of info.dependencies) {
+          lines.push(
+            `  └── ${dep.name} [${dep.type}]${dep.version ? ` @ ${dep.version}` : ""}`
+          );
         }
 
-        lines.push(``, `Dependents (${dependents.length}):`);
-        for (const dep of dependents) {
+        lines.push(``, `Dependents (${info.dependents.length}):`);
+        for (const dep of info.dependents) {
           lines.push(`  └── ${dep}`);
         }
 
@@ -888,7 +322,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
   } catch (error) {
     return {
-      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
       isError: true,
     };
   }
@@ -897,17 +336,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Start server
 async function main() {
   // Set up error handling
-  server.onerror = (error) => console.error('[MCP] Error:', error);
+  server.onerror = (error) => console.error("[MCP] Error:", error);
 
   // Signal handlers for graceful shutdown
-  process.on('SIGINT', async () => {
-    console.error('[MCP] Shutting down...');
+  process.on("SIGINT", async () => {
+    console.error("[MCP] Shutting down...");
     await server.close();
     process.exit(0);
   });
 
-  process.on('SIGTERM', async () => {
-    console.error('[MCP] Shutting down...');
+  process.on("SIGTERM", async () => {
+    console.error("[MCP] Shutting down...");
     await server.close();
     process.exit(0);
   });
@@ -917,13 +356,13 @@ async function main() {
   await server.connect(transport);
 
   // Log to stderr (doesn't interfere with JSON-RPC)
-  console.error('[MCP] @ebowwa/dependency-graph-mcp server running on stdio');
+  console.error("[MCP] @ebowwa/dependency-graph-mcp server running on stdio");
 
   // Keep stdin open for requests
   process.stdin.resume();
 }
 
 main().catch((error) => {
-  console.error('[MCP] Fatal error:', error);
+  console.error("[MCP] Fatal error:", error);
   process.exit(1);
 });