@ebowwa/dependency-graph-mcp 1.0.0 → 1.1.0

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: "@mcp/dependency-graph",
-    version: "0.1.0",
+    name: "@ebowwa/dependency-graph-mcp",
+    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] @mcp/dependency-graph 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);
 });