depwire-cli 0.9.19 → 0.9.21

package/dist/{chunk-S3NZMIIU.js → chunk-QHVWDUSX.js}

@@ -121,13 +121,13 @@ var languages = /* @__PURE__ */ new Map();
 async function initParser() {
   if (initialized) return;
   await Parser.init();
-  const __dirname3 = path.dirname(fileURLToPath(import.meta.url));
-  let grammarsDir = path.join(__dirname3, "parser", "grammars");
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  let grammarsDir = path.join(__dirname, "parser", "grammars");
   if (!existsSync2(grammarsDir)) {
-    grammarsDir = path.join(path.dirname(__dirname3), "parser", "grammars");
+    grammarsDir = path.join(path.dirname(__dirname), "parser", "grammars");
   }
   if (!existsSync2(grammarsDir)) {
-    grammarsDir = path.join(__dirname3, "grammars");
+    grammarsDir = path.join(__dirname, "grammars");
   }
   const grammarFiles = {
     "typescript": "tree-sitter-typescript.wasm",
@@ -3142,362 +3142,8 @@ function getArchitectureSummary(graph) {
   };
 }
 
-// src/viz/data.ts
-import { basename } from "path";
-function prepareVizData(graph, projectRoot) {
-  const fileSummary = getFileSummary(graph);
-  const crossFileEdges = getCrossFileEdges(graph);
-  const files = fileSummary.map((f) => ({
-    path: f.filePath,
-    directory: f.filePath.includes("/") ? f.filePath.substring(0, f.filePath.lastIndexOf("/")) : ".",
-    symbolCount: f.symbolCount,
-    incomingCount: f.incomingRefs,
-    outgoingCount: f.outgoingRefs
-  }));
-  files.sort((a, b) => {
-    if (a.directory !== b.directory) {
-      return a.directory.localeCompare(b.directory);
-    }
-    return a.path.localeCompare(b.path);
-  });
-  const arcMap = /* @__PURE__ */ new Map();
-  for (const edge of crossFileEdges) {
-    const key = `${edge.sourceFile}::${edge.targetFile}`;
-    if (arcMap.has(key)) {
-      const arc = arcMap.get(key);
-      arc.edgeCount++;
-      if (!arc.edgeKinds.includes(edge.kind)) {
-        arc.edgeKinds.push(edge.kind);
-      }
-    } else {
-      arcMap.set(key, {
-        sourceFile: edge.sourceFile,
-        targetFile: edge.targetFile,
-        edgeCount: 1,
-        edgeKinds: [edge.kind]
-      });
-    }
-  }
-  const arcs = Array.from(arcMap.values());
-  const projectName = basename(projectRoot);
-  return {
-    files,
-    arcs,
-    stats: {
-      totalFiles: files.length,
-      totalSymbols: graph.order,
-      totalEdges: graph.size,
-      totalCrossFileEdges: arcs.reduce((sum, arc) => sum + arc.edgeCount, 0)
-    },
-    projectName
-  };
-}
-
-// src/watcher.ts
-import chokidar from "chokidar";
-function watchProject(projectRoot, callbacks) {
-  console.error(`[Watcher] Creating watcher for: ${projectRoot}`);
-  const watcherOptions = {
-    ignored: [
-      "**/node_modules/**",
-      "**/vendor/**",
-      // Go dependencies
-      "**/.git/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/coverage/**",
-      "**/.next/**",
-      "**/.turbo/**",
-      "**/.DS_Store",
-      // macOS metadata
-      "**/.env",
-      // Environment files
-      "**/.env.*",
-      // Environment variants
-      "**/.eslintcache",
-      // ESLint cache
-      "**/.vscode/**",
-      // VS Code settings
-      "**/.idea/**"
-      // IntelliJ IDEA settings
-    ],
-    ignoreInitial: true,
-    // Don't fire events for existing files
-    persistent: true,
-    followSymlinks: false,
-    usePolling: true,
-    // Use polling for macOS reliability
-    interval: 1e3,
-    // Poll every second
-    atomic: true,
-    // Handle atomic writes (VS Code, Sublime, etc.)
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      // Wait 300ms after last change before firing
-      pollInterval: 100
-    }
-  };
-  const watcher = chokidar.watch(projectRoot, watcherOptions);
-  console.error("[Watcher] Attaching event listeners...");
-  watcher.on("change", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
-    if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
-    if (absolutePath.endsWith("_test.go")) return;
-    const relativePath = absolutePath.replace(projectRoot + "/", "");
-    console.error(`[Watcher] Change event: ${relativePath}`);
-    callbacks.onFileChanged(relativePath);
-  });
-  watcher.on("add", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
-    if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
-    if (absolutePath.endsWith("_test.go")) return;
-    const relativePath = absolutePath.replace(projectRoot + "/", "");
-    console.error(`[Watcher] Add event: ${relativePath}`);
-    callbacks.onFileAdded(relativePath);
-  });
-  watcher.on("unlink", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
-    if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
-    if (absolutePath.endsWith("_test.go")) return;
-    const relativePath = absolutePath.replace(projectRoot + "/", "");
-    console.error(`[Watcher] Unlink event: ${relativePath}`);
-    callbacks.onFileDeleted(relativePath);
-  });
-  watcher.on("error", (error) => {
-    console.error("[Watcher] Error:", error);
-  });
-  watcher.on("ready", () => {
-    console.error("[Watcher] Ready \u2014 watching for changes");
-    const watched = watcher.getWatched();
-    const dirs = Object.keys(watched);
-    let fileCount = 0;
-    for (const dir of dirs) {
-      const files = watched[dir];
-      fileCount += files.filter(
-        (f) => f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx") || f.endsWith(".mjs") || f.endsWith(".cjs") || f.endsWith(".py") || f.endsWith(".go") && !f.endsWith("_test.go") || f.endsWith(".rs") || f.endsWith(".c") || f.endsWith(".h")
-      ).length;
-    }
-    console.error(`[Watcher] Watching ${fileCount} TypeScript/JavaScript/Python/Go/Rust/C files in ${dirs.length} directories`);
-  });
-  return watcher;
-}
-
-// src/viz/server.ts
-import express from "express";
-import open from "open";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, join as join9 } from "path";
-import { WebSocketServer } from "ws";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname7(__filename);
-var activeServer = null;
-async function findAvailablePort(startPort, maxAttempts = 10) {
-  const net = await import("net");
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const testPort = startPort + attempt;
-    const isAvailable = await new Promise((resolve3) => {
-      const server = net.createServer();
-      server.once("error", () => {
-        resolve3(false);
-      });
-      server.once("listening", () => {
-        server.close();
-        resolve3(true);
-      });
-      server.listen(testPort, "127.0.0.1");
-    });
-    if (isAvailable) {
-      if (attempt > 0) {
-        console.error(`Port ${startPort} in use, using port ${testPort} instead`);
-      }
-      return testPort;
-    }
-  }
-  throw new Error(`No available ports found between ${startPort} and ${startPort + maxAttempts - 1}`);
-}
-async function startVizServer(initialVizData, graph, projectRoot, port = 3333, shouldOpen = true, options) {
-  if (activeServer) {
-    console.error(`Visualization server already running at ${activeServer.url}`);
-    return {
-      server: activeServer.server,
-      url: activeServer.url,
-      alreadyRunning: true
-    };
-  }
-  const availablePort = await findAvailablePort(port);
-  const app = express();
-  let vizData = initialVizData;
-  const publicDir = join9(__dirname2, "viz", "public");
-  app.use(express.static(publicDir));
-  app.get("/api/graph", (req, res) => {
-    res.json(vizData);
-  });
-  const server = app.listen(availablePort, "127.0.0.1", () => {
-    const url2 = `http://127.0.0.1:${availablePort}`;
-    console.error(`
-Depwire visualization running at ${url2}`);
-    console.error("Press Ctrl+C to stop\n");
-    activeServer = { server, port: availablePort, url: url2 };
-    if (shouldOpen) {
-      open(url2);
-    }
-  });
-  const wss = new WebSocketServer({ server });
-  wss.on("connection", (ws) => {
-    console.error("Browser connected to WebSocket");
-    ws.on("close", () => {
-      console.error("Browser disconnected from WebSocket");
-    });
-  });
-  function broadcastRefresh() {
-    wss.clients.forEach((client) => {
-      if (client.readyState === 1) {
-        client.send(JSON.stringify({ type: "refresh" }));
-      }
-    });
-  }
-  console.error("Starting file watcher...");
-  const watcher = watchProject(projectRoot, {
-    onFileChanged: async (filePath) => {
-      console.error(`File changed: ${filePath} \u2014 re-parsing project...`);
-      try {
-        const parsedFiles = await parseProject(projectRoot, options);
-        const newGraph = buildGraph(parsedFiles);
-        graph.clear();
-        newGraph.forEachNode((node, attrs) => {
-          graph.addNode(node, attrs);
-        });
-        newGraph.forEachEdge((edge, attrs, source, target) => {
-          graph.addEdge(source, target, attrs);
-        });
-        vizData = prepareVizData(graph, projectRoot);
-        broadcastRefresh();
-        console.error(`Graph updated (${vizData.stats.totalSymbols} symbols, ${vizData.stats.totalCrossFileEdges} edges)`);
-      } catch (error) {
-        console.error(`Failed to update graph for ${filePath}:`, error);
-      }
-    },
-    onFileAdded: async (filePath) => {
-      console.error(`File added: ${filePath} \u2014 re-parsing project...`);
-      try {
-        const parsedFiles = await parseProject(projectRoot, options);
-        const newGraph = buildGraph(parsedFiles);
-        graph.clear();
-        newGraph.forEachNode((node, attrs) => {
-          graph.addNode(node, attrs);
-        });
-        newGraph.forEachEdge((edge, attrs, source, target) => {
-          graph.addEdge(source, target, attrs);
-        });
-        vizData = prepareVizData(graph, projectRoot);
-        broadcastRefresh();
-        console.error(`Graph updated (${vizData.stats.totalSymbols} symbols, ${vizData.stats.totalCrossFileEdges} edges)`);
-      } catch (error) {
-        console.error(`Failed to update graph for ${filePath}:`, error);
-      }
-    },
-    onFileDeleted: async (filePath) => {
-      console.error(`File deleted: ${filePath} \u2014 re-parsing project...`);
-      try {
-        const parsedFiles = await parseProject(projectRoot, options);
-        const newGraph = buildGraph(parsedFiles);
-        graph.clear();
-        newGraph.forEachNode((node, attrs) => {
-          graph.addNode(node, attrs);
-        });
-        newGraph.forEachEdge((edge, attrs, source, target) => {
-          graph.addEdge(source, target, attrs);
-        });
-        vizData = prepareVizData(graph, projectRoot);
-        broadcastRefresh();
-        console.error(`Graph updated (${vizData.stats.totalSymbols} symbols, ${vizData.stats.totalCrossFileEdges} edges)`);
-      } catch (error) {
-        console.error(`Failed to remove ${filePath} from graph:`, error);
-      }
-    }
-  });
-  process.on("SIGINT", () => {
-    console.error("\nShutting down visualization server...");
-    activeServer = null;
-    watcher.close();
-    wss.close();
-    server.close(() => {
-      process.exit(0);
-    });
-  });
-  const url = `http://127.0.0.1:${availablePort}`;
-  return { server, url, alreadyRunning: false };
-}
-
-// src/mcp/state.ts
-function createEmptyState() {
-  return {
-    graph: null,
-    projectRoot: null,
-    projectName: null,
-    watcher: null
-  };
-}
-function isProjectLoaded(state) {
-  return state.graph !== null && state.projectRoot !== null;
-}
-
-// src/graph/updater.ts
-import { join as join10 } from "path";
-function removeFileFromGraph(graph, filePath) {
-  const nodesToRemove = [];
-  graph.forEachNode((node, attrs) => {
-    if (attrs.filePath === filePath) {
-      nodesToRemove.push(node);
-    }
-  });
-  nodesToRemove.forEach((node) => {
-    try {
-      graph.dropNode(node);
-    } catch (error) {
-    }
-  });
-}
-function addFileToGraph(graph, parsedFile) {
-  for (const symbol of parsedFile.symbols) {
-    const nodeId = `${parsedFile.filePath}::${symbol.name}`;
-    try {
-      graph.addNode(nodeId, {
-        name: symbol.name,
-        kind: symbol.kind,
-        filePath: parsedFile.filePath,
-        startLine: symbol.location.startLine,
-        endLine: symbol.location.endLine,
-        exported: symbol.exported,
-        scope: symbol.scope
-      });
-    } catch (error) {
-    }
-  }
-  for (const edge of parsedFile.edges) {
-    try {
-      graph.mergeEdge(edge.source, edge.target, {
-        kind: edge.kind,
-        sourceFile: edge.sourceFile,
-        targetFile: edge.targetFile
-      });
-    } catch (error) {
-    }
-  }
-}
-async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
-  removeFileFromGraph(graph, relativeFilePath);
-  const absolutePath = join10(projectRoot, relativeFilePath);
-  try {
-    const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
-    addFileToGraph(graph, parsedFile);
-  } catch (error) {
-    console.error(`Failed to parse file ${relativeFilePath}:`, error);
-  }
-}
-
 // src/health/metrics.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname7 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -3530,8 +3176,8 @@ function calculateCouplingScore(graph) {
       totalEdges++;
       fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
       fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
-      const sourceDir = dirname8(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname8(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname7(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname7(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -3578,8 +3224,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname8(sourceAttrs.filePath);
-      const targetDir = dirname8(targetAttrs.filePath);
+      const sourceDir = dirname7(sourceAttrs.filePath);
+      const targetDir = dirname7(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -3862,7 +3508,7 @@ function calculateDepthScore(graph) {
 
 // src/health/index.ts
 import { readFileSync as readFileSync6, writeFileSync, existsSync as existsSync8, mkdirSync } from "fs";
-import { join as join11, dirname as dirname9 } from "path";
+import { join as join9, dirname as dirname8 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -3961,7 +3607,7 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const historyFile = join11(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
   const entry = {
     timestamp: report.timestamp,
     score: report.overall,
@@ -3984,11 +3630,11 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname9(historyFile), { recursive: true });
+  mkdirSync(dirname8(historyFile), { recursive: true });
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const historyFile = join11(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
   if (!existsSync8(historyFile)) {
     return [];
   }
@@ -4277,8 +3923,8 @@ function generateReason(symbol, confidence) {
   return "Potentially unused";
 }
 function isBarrelFile(filePath) {
-  const basename6 = path3.basename(filePath);
-  return basename6 === "index.ts" || basename6 === "index.js";
+  const basename4 = path3.basename(filePath);
+  return basename4 === "index.ts" || basename4 === "index.js";
 }
 function isTestFile2(filePath) {
   return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
@@ -4458,10 +4104,10 @@ function filterByConfidence(symbols, minConfidence) {
 
 // src/docs/generator.ts
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync12 } from "fs";
-import { join as join14 } from "path";
+import { join as join12 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -4612,7 +4258,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -4637,7 +4283,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4652,8 +4298,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname10(sourceAttrs.filePath);
-    const targetDir = dirname10(targetAttrs.filePath);
+    const sourceDir = dirname9(sourceAttrs.filePath);
+    const targetDir = dirname9(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4860,7 +4506,7 @@ function detectCycles(graph) {
 }
 
 // src/docs/conventions.ts
-import { basename as basename2, extname as extname4 } from "path";
+import { basename, extname as extname4 } from "path";
 function generateConventions(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4898,7 +4544,7 @@ function generateFileOrganization(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename2(attrs.filePath);
+      const fileName = basename(attrs.filePath);
       if (fileName === "index.ts" || fileName === "index.js" || fileName === "index.tsx" || fileName === "index.jsx") {
         barrelFileCount++;
       }
@@ -4957,7 +4603,7 @@ function generateNamingPatterns(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename2(attrs.filePath, extname4(attrs.filePath));
+      const fileName = basename(attrs.filePath, extname4(attrs.filePath));
       if (isCamelCase(fileName)) patterns.files.camelCase++;
       else if (isPascalCase(fileName)) patterns.files.PascalCase++;
       else if (isKebabCase(fileName)) patterns.files.kebabCase++;
@@ -5634,7 +5280,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname11 } from "path";
+import { dirname as dirname10 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5693,7 +5339,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -5797,7 +5443,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -5812,7 +5458,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5827,8 +5473,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname11(sourceAttrs.filePath);
-    const targetDir = dirname11(targetAttrs.filePath);
+    const sourceDir = dirname10(sourceAttrs.filePath);
+    const targetDir = dirname10(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -5909,7 +5555,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5963,8 +5609,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname11(files[0]);
-  if (files.every((f) => dirname11(f) === commonDir)) {
+  const commonDir = dirname10(files[0]);
+  if (files.every((f) => dirname10(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -6022,7 +5668,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname12, basename as basename3 } from "path";
+import { dirname as dirname11, basename as basename2 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6126,7 +5772,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname12(file.filePath);
+    const dir = dirname11(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -6141,7 +5787,7 @@ function generateDirectoryBreakdown(graph) {
     dirStats.symbolCount += file.symbolCount;
     if (file.totalConnections > dirStats.maxConnections) {
       dirStats.maxConnections = file.totalConnections;
-      dirStats.mostConnectedFile = basename3(file.filePath);
+      dirStats.mostConnectedFile = basename2(file.filePath);
     }
   }
   if (dirMap.size === 0) {
@@ -6769,7 +6415,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname13 } from "path";
+import { basename as basename3, dirname as dirname12 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6797,8 +6443,8 @@ function getFileCount8(graph) {
   return files.size;
 }
 function isTestFile3(filePath) {
-  const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname13(filePath).toLowerCase();
+  const fileName = basename3(filePath).toLowerCase();
+  const dirPath = dirname12(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -6856,13 +6502,13 @@ function generateTestFileInventory(graph) {
   return output;
 }
 function matchTestToSource(testFile) {
-  const testFileName = basename4(testFile);
-  const testDir = dirname13(testFile);
+  const testFileName = basename3(testFile);
+  const testDir = dirname12(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname13(testDir);
+    const parentDir = dirname12(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -7018,7 +6664,7 @@ function generateTestCoverageMap(graph) {
   const rows = mappings.slice(0, 30).map((m) => [
     `\`${m.sourceFile}\``,
     m.hasTest ? "\u2705" : "\u274C",
-    m.testFile ? `\`${basename4(m.testFile)}\`` : "-",
+    m.testFile ? `\`${basename3(m.testFile)}\`` : "-",
     formatNumber(m.symbolCount)
   ]);
   let output = table(headers, rows);
@@ -7059,7 +6705,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname13(sourceFile).split("/")[0];
+    const dir = dirname12(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -7082,7 +6728,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname13 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -7363,7 +7009,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname14(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -7445,7 +7091,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname15 } from "path";
+import { dirname as dirname14 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7583,7 +7229,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname15(info.filePath);
+    const dir = dirname14(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -7795,7 +7441,7 @@ function getTopLevelDir2(filePath) {
 
 // src/docs/status.ts
 import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import { join as join12 } from "path";
+import { join as join10 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7828,7 +7474,7 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join12(projectRoot, filePath);
+  const fullPath = join10(projectRoot, filePath);
   if (!existsSync10(fullPath)) {
     return comments;
   }
@@ -8413,9 +8059,9 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 
 // src/docs/metadata.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
-import { join as join13 } from "path";
+import { join as join11 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join13(outputDir, "metadata.json");
+  const metadataPath = join11(outputDir, "metadata.json");
   if (!existsSync11(metadataPath)) {
     return null;
   }
@@ -8428,7 +8074,7 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join13(outputDir, "metadata.json");
+  const metadataPath = join11(outputDir, "metadata.json");
   writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function createMetadata(version, projectPath, fileCount, symbolCount, edgeCount, docTypes) {
@@ -8510,7 +8156,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ARCHITECTURE.md...");
           const content = generateArchitecture(graph, projectRoot, version, parseTime);
-          const filePath = join14(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join12(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -8521,7 +8167,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CONVENTIONS.md...");
           const content = generateConventions(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "CONVENTIONS.md");
+          const filePath = join12(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -8532,7 +8178,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEPENDENCIES.md...");
           const content = generateDependencies(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join12(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -8543,7 +8189,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ONBOARDING.md...");
           const content = generateOnboarding(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "ONBOARDING.md");
+          const filePath = join12(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -8554,7 +8200,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating FILES.md...");
           const content = generateFiles(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "FILES.md");
+          const filePath = join12(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -8565,7 +8211,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating API_SURFACE.md...");
           const content = generateApiSurface(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "API_SURFACE.md");
+          const filePath = join12(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -8576,7 +8222,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ERRORS.md...");
           const content = generateErrors(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "ERRORS.md");
+          const filePath = join12(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -8587,7 +8233,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating TESTS.md...");
           const content = generateTests(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "TESTS.md");
+          const filePath = join12(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -8598,7 +8244,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HISTORY.md...");
           const content = generateHistory(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "HISTORY.md");
+          const filePath = join12(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -8609,7 +8255,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CURRENT.md...");
           const content = generateCurrent(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "CURRENT.md");
+          const filePath = join12(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -8620,7 +8266,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating STATUS.md...");
           const content = generateStatus(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "STATUS.md");
+          const filePath = join12(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -8631,7 +8277,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HEALTH.md...");
           const content = generateHealth(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "HEALTH.md");
+          const filePath = join12(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -8642,7 +8288,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEAD_CODE.md...");
           const content = generateDeadCode(graph, projectRoot, version);
-          const filePath = join14(options.outputDir, "DEAD_CODE.md");
+          const filePath = join12(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -8685,1492 +8331,354 @@ function getFileCount13(graph) {
   return files.size;
 }
 
-// src/mcp/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/mcp/tools.ts
-import { dirname as dirname16, join as join17 } from "path";
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-
-// src/mcp/connect.ts
-import simpleGit from "simple-git";
-import { existsSync as existsSync13 } from "fs";
-import { join as join15, basename as basename5, resolve as resolve2 } from "path";
-import { tmpdir, homedir } from "os";
-function validateProjectPath(source) {
-  const resolved = resolve2(source);
-  const blockedPaths = [
-    "/etc",
-    "/var",
-    "/usr",
-    "/bin",
-    "/sbin",
-    "/boot",
-    "/proc",
-    "/sys",
-    join15(homedir(), ".ssh"),
-    join15(homedir(), ".gnupg"),
-    join15(homedir(), ".aws"),
-    join15(homedir(), ".config"),
-    join15(homedir(), ".env")
-  ];
-  for (const blocked of blockedPaths) {
-    if (resolved.startsWith(blocked)) {
-      return { valid: false, error: `Access denied: ${blocked} is a protected path` };
-    }
-  }
-  return { valid: true };
+// src/simulation/engine.ts
+import { dirname as dirname15, join as join13 } from "path";
+function normalizePath(p) {
+  return p.replace(/^\.\//, "").replace(/\/+$/, "");
 }
-async function connectToRepo(source, subdirectory, state) {
-  try {
-    let projectRoot;
-    let projectName;
-    const isGitHub = source.startsWith("https://github.com/") || source.startsWith("git@github.com:");
-    if (isGitHub) {
-      const match = source.match(/[\/:]([^\/]+?)(?:\.git)?$/);
-      if (!match) {
-        return {
-          error: "Invalid GitHub URL",
-          message: "Could not parse repository name from URL"
-        };
-      }
-      projectName = match[1];
-      const reposDir = join15(tmpdir(), "depwire-repos");
-      const cloneDir = join15(reposDir, projectName);
-      console.error(`Connecting to GitHub repo: ${source}`);
-      const git = simpleGit();
-      if (existsSync13(cloneDir)) {
-        console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
-        try {
-          await git.cwd(cloneDir).pull();
-        } catch (error) {
-          console.error(`Pull failed, using existing clone: ${error}`);
-        }
-      } else {
-        console.error(`Cloning ${source} to ${cloneDir}...`);
-        try {
-          await git.clone(source, cloneDir, ["--depth", "1", "--no-recurse-submodules", "--single-branch"]);
-        } catch (error) {
-          return {
-            error: "Failed to clone repository",
-            message: `Git clone failed: ${error}. Ensure git is installed and the URL is correct.`
-          };
-        }
-      }
-      projectRoot = subdirectory ? join15(cloneDir, subdirectory) : cloneDir;
-    } else {
-      const validation2 = validateProjectPath(source);
-      if (!validation2.valid) {
-        return {
-          error: "Access denied",
-          message: validation2.error
-        };
-      }
-      if (!existsSync13(source)) {
-        return {
-          error: "Directory not found",
-          message: `Directory does not exist: ${source}`
-        };
-      }
-      projectRoot = subdirectory ? join15(source, subdirectory) : source;
-      projectName = basename5(projectRoot);
-    }
-    const validation = validateProjectPath(projectRoot);
-    if (!validation.valid) {
-      return {
-        error: "Access denied",
-        message: validation.error
-      };
-    }
-    if (!existsSync13(projectRoot)) {
-      return {
-        error: "Project root not found",
-        message: `Directory does not exist: ${projectRoot}`
-      };
-    }
-    console.error(`Parsing project at ${projectRoot}...`);
-    if (state.watcher) {
-      console.error("Stopping previous file watcher...");
-      await state.watcher.close();
-      state.watcher = null;
+function fileMatch(nodeFilePath, target) {
+  const a = normalizePath(nodeFilePath);
+  const b = normalizePath(target);
+  return a === b || a.endsWith("/" + b) || b.endsWith("/" + a);
+}
+var SimulationEngine = class {
+  original;
+  constructor(graph) {
+    this.original = graph;
+  }
+  simulate(action) {
+    const clone = this.original.copy();
+    const brokenImports = [];
+    switch (action.type) {
+      case "move":
+        this.applyMove(clone, action.target, action.destination, brokenImports);
+        break;
+      case "delete":
+        this.applyDelete(clone, action.target, brokenImports);
+        break;
+      case "rename":
+        this.applyRename(clone, action.target, action.newName, brokenImports);
+        break;
+      case "split":
+        this.applySplit(clone, action.target, action.newFile, action.symbols, brokenImports);
+        break;
+      case "merge":
+        this.applyMerge(clone, action.target, action.source, brokenImports);
+        break;
     }
-    const parsedFiles = await parseProject(projectRoot);
-    if (parsedFiles.length === 0) {
+    const diff = this.computeDiff(this.original, clone, brokenImports);
+    const beforeHealth = this.computeHealthScore(this.original);
+    const afterHealth = this.computeHealthScore(clone);
+    const dimensionChanges = beforeHealth.dimensions.map((bd, i) => {
+      const ad = afterHealth.dimensions[i];
       return {
-        error: "No source files found",
-        message: `No supported source files (.ts, .tsx, .js, .jsx, .py, .go) found in ${projectRoot}`
+        name: bd.name,
+        before: bd.score,
+        after: ad ? ad.score : bd.score,
+        delta: (ad ? ad.score : bd.score) - bd.score
       };
-    }
-    const graph = buildGraph(parsedFiles);
-    state.graph = graph;
-    state.projectRoot = projectRoot;
-    state.projectName = projectName;
-    console.error(`Parsed ${parsedFiles.length} files`);
-    console.error("Starting file watcher...");
-    state.watcher = watchProject(projectRoot, {
-      onFileChanged: async (filePath) => {
-        console.error(`File changed: ${filePath}`);
-        try {
-          await updateFileInGraph(state.graph, projectRoot, filePath);
-          console.error(`Graph updated for ${filePath}`);
-        } catch (error) {
-          console.error(`Failed to update graph for ${filePath}: ${error}`);
-        }
-      },
-      onFileAdded: async (filePath) => {
-        console.error(`File added: ${filePath}`);
-        try {
-          await updateFileInGraph(state.graph, projectRoot, filePath);
-          console.error(`Graph updated for ${filePath}`);
-        } catch (error) {
-          console.error(`Failed to update graph for ${filePath}: ${error}`);
-        }
-      },
-      onFileDeleted: (filePath) => {
-        console.error(`File deleted: ${filePath}`);
-        try {
-          const fileNodes = state.graph.filterNodes(
-            (node, attrs) => attrs.filePath === filePath
-          );
-          fileNodes.forEach((node) => state.graph.dropNode(node));
-          console.error(`Removed ${filePath} from graph`);
-        } catch (error) {
-          console.error(`Failed to remove ${filePath} from graph: ${error}`);
-        }
-      }
-    });
-    const summary = getArchitectureSummary(graph);
-    const mostConnected = summary.mostConnectedFiles.slice(0, 3);
-    const languageBreakdown = {};
-    parsedFiles.forEach((file) => {
-      const ext = file.filePath.toLowerCase();
-      let lang;
-      if (ext.endsWith(".ts") || ext.endsWith(".tsx")) {
-        lang = "typescript";
-      } else if (ext.endsWith(".py")) {
-        lang = "python";
-      } else if (ext.endsWith(".js") || ext.endsWith(".jsx") || ext.endsWith(".mjs") || ext.endsWith(".cjs")) {
-        lang = "javascript";
-      } else if (ext.endsWith(".go")) {
-        lang = "go";
-      } else {
-        lang = "other";
-      }
-      languageBreakdown[lang] = (languageBreakdown[lang] || 0) + 1;
     });
-    return {
-      connected: true,
-      projectRoot,
-      projectName,
-      stats: {
-        files: summary.totalFiles,
-        symbols: summary.totalSymbols,
-        edges: summary.totalEdges,
-        crossFileEdges: summary.crossFileEdges,
-        languages: languageBreakdown
-      },
-      mostConnectedFiles: mostConnected.map((f) => ({
-        path: f.filePath,
-        connections: f.incomingCount + f.outgoingCount
-      })),
-      summary: `Connected to ${projectName}. Found ${summary.totalFiles} files with ${summary.totalSymbols} symbols and ${summary.crossFileEdges} cross-file edges.`
+    const healthDelta = {
+      before: beforeHealth.score,
+      after: afterHealth.score,
+      delta: afterHealth.score - beforeHealth.score,
+      improved: afterHealth.score > beforeHealth.score,
+      dimensionChanges
     };
-  } catch (error) {
-    console.error("Error in connectToRepo:", error);
     return {
-      error: "Connection failed",
-      message: String(error)
+      action,
+      originalGraph: {
+        nodeCount: this.original.order,
+        edgeCount: this.original.size,
+        healthScore: beforeHealth.score
+      },
+      simulatedGraph: {
+        nodeCount: clone.order,
+        edgeCount: clone.size,
+        healthScore: afterHealth.score
+      },
+      diff,
+      healthDelta
     };
   }
-}
-
-// src/temporal/git.ts
-import { execSync as execSync2 } from "child_process";
-async function getCommitLog(dir, limit) {
-  try {
-    const limitArg = limit ? `-n ${limit}` : "";
-    const output = execSync2(
-      `git log ${limitArg} --pretty=format:"%H|%aI|%s|%an"`,
-      { cwd: dir, encoding: "utf-8" }
+  // ── Action implementations ─────────────────────────────────────
+  applyMove(clone, target, destination, brokenImports) {
+    const normalizedTarget = normalizePath(target);
+    const normalizedDest = normalizePath(destination);
+    const nodesToMove = clone.filterNodes(
+      (_node, attrs) => fileMatch(attrs.filePath, target)
     );
-    if (!output.trim()) {
-      return [];
+    if (nodesToMove.length === 0) return;
+    for (const oldId of nodesToMove) {
+      const attrs = clone.getNodeAttributes(oldId);
+      const symbolName = oldId.includes("::") ? oldId.split("::").slice(1).join("::") : attrs.name;
+      const newId = `${normalizedDest}::${symbolName}`;
+      clone.forEachInEdge(oldId, (edge, edgeAttrs, source) => {
+        const sourceAttrs = clone.getNodeAttributes(source);
+        if (!fileMatch(sourceAttrs.filePath, target)) {
+          brokenImports.push({
+            file: sourceAttrs.filePath,
+            importedSymbol: attrs.name,
+            reason: `imports ${attrs.name} from ${target} (path would break)`
+          });
+        }
+      });
+      if (!clone.hasNode(newId)) {
+        clone.addNode(newId, { ...attrs, filePath: normalizedDest });
+      }
+      clone.forEachInEdge(oldId, (edge, edgeAttrs, source) => {
+        const newSource = nodesToMove.includes(source) ? `${normalizedDest}::${source.includes("::") ? source.split("::").slice(1).join("::") : clone.getNodeAttributes(source).name}` : source;
+        if (clone.hasNode(newSource) && clone.hasNode(newId)) {
+          clone.mergeEdge(newSource, newId, edgeAttrs);
+        }
+      });
+      clone.forEachOutEdge(oldId, (edge, edgeAttrs, _source, outTarget) => {
+        const newTarget = nodesToMove.includes(outTarget) ? `${normalizedDest}::${outTarget.includes("::") ? outTarget.split("::").slice(1).join("::") : clone.getNodeAttributes(outTarget).name}` : outTarget;
+        if (clone.hasNode(newId) && clone.hasNode(newTarget)) {
+          clone.mergeEdge(newId, newTarget, edgeAttrs);
+        }
+      });
+      clone.dropNode(oldId);
     }
-    return output.trim().split("\n").map((line) => {
-      const [hash, date, message, author] = line.split("|");
-      return { hash, date, message, author };
-    });
-  } catch (error) {
-    throw new Error(`Failed to get git log: ${error}`);
   }
-}
-async function getCurrentBranch(dir) {
-  try {
-    return execSync2("git rev-parse --abbrev-ref HEAD", {
-      cwd: dir,
-      encoding: "utf-8"
-    }).trim();
-  } catch (error) {
-    throw new Error(`Failed to get current branch: ${error}`);
+  applyDelete(clone, target, brokenImports) {
+    const nodesToDelete = clone.filterNodes(
+      (_node, attrs) => fileMatch(attrs.filePath, target)
+    );
+    for (const nodeId of nodesToDelete) {
+      const attrs = clone.getNodeAttributes(nodeId);
+      clone.forEachInEdge(nodeId, (_edge, _edgeAttrs, source) => {
+        const sourceAttrs = clone.getNodeAttributes(source);
+        if (!fileMatch(sourceAttrs.filePath, target)) {
+          brokenImports.push({
+            file: sourceAttrs.filePath,
+            importedSymbol: attrs.name,
+            reason: `imports ${attrs.name} from ${target} (file deleted)`
+          });
+        }
+      });
+    }
+    for (const nodeId of nodesToDelete) {
+      clone.dropNode(nodeId);
+    }
   }
-}
-async function checkoutCommit(dir, hash) {
-  try {
-    execSync2(`git checkout -q ${hash}`, { cwd: dir, stdio: "ignore" });
-  } catch (error) {
-    throw new Error(`Failed to checkout commit ${hash}: ${error}`);
+  applyRename(clone, target, newName, brokenImports) {
+    const destination = join13(dirname15(target), newName);
+    this.applyMove(clone, target, destination, brokenImports);
   }
-}
-async function restoreOriginal(dir, originalBranch) {
-  try {
-    execSync2(`git checkout -q ${originalBranch}`, {
-      cwd: dir,
-      stdio: "ignore"
+  applySplit(clone, target, newFile, symbols, brokenImports) {
+    const normalizedNewFile = normalizePath(newFile);
+    const nodesToSplit = clone.filterNodes((_node, attrs) => {
+      return fileMatch(attrs.filePath, target) && symbols.includes(attrs.name);
     });
-  } catch (error) {
-    throw new Error(`Failed to restore branch ${originalBranch}: ${error}`);
-  }
-}
-async function stashChanges(dir) {
-  try {
-    const status = execSync2("git status --porcelain", {
-      cwd: dir,
-      encoding: "utf-8"
-    }).trim();
-    if (status) {
-      execSync2('git stash push -q -m "depwire temporal analysis"', {
-        cwd: dir,
-        stdio: "ignore"
+    if (nodesToSplit.length === 0) return;
+    for (const oldId of nodesToSplit) {
+      const attrs = clone.getNodeAttributes(oldId);
+      const symbolName = oldId.includes("::") ? oldId.split("::").slice(1).join("::") : attrs.name;
+      const newId = `${normalizedNewFile}::${symbolName}`;
+      clone.forEachInEdge(oldId, (_edge, _edgeAttrs, source) => {
+        const sourceAttrs = clone.getNodeAttributes(source);
+        if (!fileMatch(sourceAttrs.filePath, target) && !fileMatch(sourceAttrs.filePath, newFile)) {
+          brokenImports.push({
+            file: sourceAttrs.filePath,
+            importedSymbol: attrs.name,
+            reason: `imports ${attrs.name} from ${target} (symbol moved to ${newFile})`
+          });
+        }
       });
-      return true;
+      if (!clone.hasNode(newId)) {
+        clone.addNode(newId, { ...attrs, filePath: normalizedNewFile });
+      }
+      clone.forEachInEdge(oldId, (_edge, edgeAttrs, source) => {
+        if (clone.hasNode(source) && clone.hasNode(newId)) {
+          clone.mergeEdge(source, newId, edgeAttrs);
+        }
+      });
+      clone.forEachOutEdge(oldId, (_edge, edgeAttrs, _source, outTarget) => {
+        if (clone.hasNode(newId) && clone.hasNode(outTarget)) {
+          clone.mergeEdge(newId, outTarget, edgeAttrs);
+        }
+      });
+      clone.dropNode(oldId);
     }
-    return false;
-  } catch (error) {
-    throw new Error(`Failed to stash changes: ${error}`);
   }
-}
-async function popStash(dir) {
-  try {
-    const stashList = execSync2("git stash list", {
-      cwd: dir,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-      // Suppress stderr
-    }).trim();
-    if (stashList) {
-      execSync2("git stash pop -q", { cwd: dir, stdio: "ignore" });
+  applyMerge(clone, target, source, brokenImports) {
+    const normalizedTarget = normalizePath(target);
+    const sourceNodes = clone.filterNodes(
+      (_node, attrs) => fileMatch(attrs.filePath, source)
+    );
+    const targetNodes = clone.filterNodes(
+      (_node, attrs) => fileMatch(attrs.filePath, target)
+    );
+    const targetSymbols = new Set(
+      targetNodes.map((n) => clone.getNodeAttributes(n).name)
+    );
+    for (const nodeId of sourceNodes) {
+      const name = clone.getNodeAttributes(nodeId).name;
+      if (name !== "__file__" && targetSymbols.has(name)) {
+        throw new Error(
+          `Merge conflict: symbol "${name}" exists in both ${target} and ${source}`
+        );
+      }
     }
-  } catch (error) {
-  }
-}
-function isGitRepo(dir) {
-  try {
-    execSync2("git rev-parse --git-dir", { cwd: dir, stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/temporal/sampler.ts
-function sampleCommits(commits, targetCount, strategy) {
-  if (commits.length === 0) {
-    return [];
-  }
-  if (commits.length <= targetCount) {
-    return commits;
-  }
-  switch (strategy) {
-    case "even":
-      return sampleEvenly(commits, targetCount);
-    case "weekly":
-      return sampleWeekly(commits, targetCount);
-    case "monthly":
-      return sampleMonthly(commits, targetCount);
-    default:
-      return sampleEvenly(commits, targetCount);
+    for (const oldId of sourceNodes) {
+      const attrs = clone.getNodeAttributes(oldId);
+      const symbolName = oldId.includes("::") ? oldId.split("::").slice(1).join("::") : attrs.name;
+      const newId = `${normalizedTarget}::${symbolName}`;
+      clone.forEachInEdge(oldId, (_edge, _edgeAttrs, inSource) => {
+        const srcAttrs = clone.getNodeAttributes(inSource);
+        if (!fileMatch(srcAttrs.filePath, source) && !fileMatch(srcAttrs.filePath, target)) {
+          brokenImports.push({
+            file: srcAttrs.filePath,
+            importedSymbol: attrs.name,
+            reason: `imports ${attrs.name} from ${source} (merged into ${target})`
+          });
+        }
+      });
+      if (!clone.hasNode(newId)) {
+        clone.addNode(newId, { ...attrs, filePath: normalizedTarget });
+      }
+      clone.forEachInEdge(oldId, (_edge, edgeAttrs, inSource) => {
+        const resolvedSource = sourceNodes.includes(inSource) ? `${normalizedTarget}::${inSource.includes("::") ? inSource.split("::").slice(1).join("::") : clone.getNodeAttributes(inSource).name}` : inSource;
+        if (clone.hasNode(resolvedSource) && clone.hasNode(newId)) {
+          clone.mergeEdge(resolvedSource, newId, edgeAttrs);
+        }
+      });
+      clone.forEachOutEdge(oldId, (_edge, edgeAttrs, _s, outTarget) => {
+        const resolvedTarget = sourceNodes.includes(outTarget) ? `${normalizedTarget}::${outTarget.includes("::") ? outTarget.split("::").slice(1).join("::") : clone.getNodeAttributes(outTarget).name}` : outTarget;
+        if (clone.hasNode(newId) && clone.hasNode(resolvedTarget)) {
+          clone.mergeEdge(newId, resolvedTarget, edgeAttrs);
+        }
+      });
+      clone.dropNode(oldId);
+    }
+  }
+  // ── Diff computation ───────────────────────────────────────────
+  computeDiff(original, simulated, brokenImports) {
+    const originalEdges = this.collectEdges(original);
+    const simulatedEdges = this.collectEdges(simulated);
+    const originalKeys = new Set(originalEdges.map((e) => this.edgeKey(e)));
+    const simulatedKeys = new Set(simulatedEdges.map((e) => this.edgeKey(e)));
+    const addedEdges = simulatedEdges.filter((e) => !originalKeys.has(this.edgeKey(e)));
+    const removedEdges = originalEdges.filter((e) => !simulatedKeys.has(this.edgeKey(e)));
+    const affectedNodeSet = /* @__PURE__ */ new Set();
+    for (const e of [...addedEdges, ...removedEdges]) {
+      affectedNodeSet.add(e.source);
+      affectedNodeSet.add(e.target);
+    }
+    const originalCycles = this.detectCycles(original);
+    const simulatedCycles = this.detectCycles(simulated);
+    const originalCycleKeys = new Set(originalCycles.map((c) => [...c].sort().join(",")));
+    const simulatedCycleKeys = new Set(simulatedCycles.map((c) => [...c].sort().join(",")));
+    const circularDepsIntroduced = simulatedCycles.filter(
+      (c) => !originalCycleKeys.has([...c].sort().join(","))
+    );
+    const circularDepsResolved = originalCycles.filter(
+      (c) => !simulatedCycleKeys.has([...c].sort().join(","))
+    );
+    return {
+      addedEdges,
+      removedEdges,
+      affectedNodes: Array.from(affectedNodeSet),
+      brokenImports,
+      circularDepsIntroduced,
+      circularDepsResolved
+    };
   }
-}
-function sampleEvenly(commits, targetCount) {
-  if (targetCount >= commits.length) {
-    return commits;
+  collectEdges(graph) {
+    const edges = [];
+    graph.forEachEdge((_edge, attrs, source, target) => {
+      edges.push({ source, target, kind: attrs.kind });
+    });
+    return edges;
+  }
+  edgeKey(e) {
+    return `${e.source}|${e.target}|${e.kind || ""}`;
+  }
+  // ── Cycle detection (adapted from src/health/metrics.ts) ───────
+  detectCycles(graph) {
+    const fileGraph = /* @__PURE__ */ new Map();
+    graph.forEachEdge((_edge, _attrs, source, target) => {
+      const sourceFile = graph.getNodeAttributes(source).filePath;
+      const targetFile = graph.getNodeAttributes(target).filePath;
+      if (sourceFile !== targetFile) {
+        if (!fileGraph.has(sourceFile)) {
+          fileGraph.set(sourceFile, /* @__PURE__ */ new Set());
+        }
+        fileGraph.get(sourceFile).add(targetFile);
+      }
+    });
+    const visited = /* @__PURE__ */ new Set();
+    const recStack = /* @__PURE__ */ new Set();
+    const cycles = [];
+    const dfs = (node, path6) => {
+      if (recStack.has(node)) {
+        const cycleStart = path6.indexOf(node);
+        if (cycleStart >= 0) {
+          cycles.push(path6.slice(cycleStart));
+        }
+        return;
+      }
+      if (visited.has(node)) return;
+      visited.add(node);
+      recStack.add(node);
+      path6.push(node);
+      const neighbors = fileGraph.get(node);
+      if (neighbors) {
+        for (const neighbor of neighbors) {
+          dfs(neighbor, [...path6]);
+        }
+      }
+      recStack.delete(node);
+    };
+    for (const node of fileGraph.keys()) {
+      if (!visited.has(node)) {
+        dfs(node, []);
+      }
+    }
+    const unique = /* @__PURE__ */ new Map();
+    for (const cycle of cycles) {
+      const key = [...cycle].sort().join(",");
+      if (!unique.has(key)) {
+        unique.set(key, cycle);
+      }
+    }
+    return Array.from(unique.values());
   }
-  const result = [];
-  const step = (commits.length - 1) / (targetCount - 1);
-  for (let i = 0; i < targetCount; i++) {
-    const index = Math.round(i * step);
-    result.push(commits[index]);
+  // ── Health score (side-effect free) ────────────────────────────
+  computeHealthScore(graph) {
+    const dimensions = [
+      calculateCouplingScore(graph),
+      calculateCohesionScore(graph),
+      calculateCircularDepsScore(graph),
+      calculateGodFilesScore(graph),
+      calculateOrphansScore(graph),
+      calculateDepthScore(graph)
+    ];
+    const score = Math.round(
+      dimensions.reduce((sum, dim) => sum + dim.score * dim.weight, 0)
+    );
+    return { score, dimensions };
   }
-  return result;
-}
-function sampleWeekly(commits, targetCount) {
-  const result = [];
-  const first = commits[0];
-  const last = commits[commits.length - 1];
-  result.push(first);
-  const weekMap = /* @__PURE__ */ new Map();
-  for (const commit of commits) {
-    const date = new Date(commit.date);
-    const year = date.getFullYear();
-    const week = getWeekNumber(date);
-    const key = `${year}-W${week}`;
-    weekMap.set(key, commit);
-  }
-  const weeklyCommits = Array.from(weekMap.values());
-  if (weeklyCommits.length <= targetCount) {
-    return weeklyCommits;
-  }
-  const step = Math.floor((weeklyCommits.length - 2) / (targetCount - 2));
-  for (let i = 1; i < targetCount - 1; i++) {
-    const index = Math.min(i * step, weeklyCommits.length - 2);
-    if (weeklyCommits[index] !== first && weeklyCommits[index] !== last) {
-      result.push(weeklyCommits[index]);
-    }
-  }
-  if (result[result.length - 1] !== last) {
-    result.push(last);
-  }
-  return result;
-}
-function sampleMonthly(commits, targetCount) {
-  const result = [];
-  const first = commits[0];
-  const last = commits[commits.length - 1];
-  result.push(first);
-  const monthMap = /* @__PURE__ */ new Map();
-  for (const commit of commits) {
-    const date = new Date(commit.date);
-    const key = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`;
-    monthMap.set(key, commit);
-  }
-  const monthlyCommits = Array.from(monthMap.values());
-  if (monthlyCommits.length <= targetCount) {
-    return monthlyCommits;
-  }
-  const step = Math.floor((monthlyCommits.length - 2) / (targetCount - 2));
-  for (let i = 1; i < targetCount - 1; i++) {
-    const index = Math.min(i * step, monthlyCommits.length - 2);
-    if (monthlyCommits[index] !== first && monthlyCommits[index] !== last) {
-      result.push(monthlyCommits[index]);
-    }
-  }
-  if (result[result.length - 1] !== last) {
-    result.push(last);
-  }
-  return result;
-}
-function getWeekNumber(date) {
-  const d = new Date(
-    Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
-  );
-  const dayNum = d.getUTCDay() || 7;
-  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
-}
-
-// src/temporal/snapshots.ts
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync10, mkdirSync as mkdirSync3, existsSync as existsSync14, readdirSync as readdirSync5 } from "fs";
-import { join as join16 } from "path";
-function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync14(outputDir)) {
-    mkdirSync3(outputDir, { recursive: true });
-  }
-  const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
-  const filepath = join16(outputDir, filename);
-  writeFileSync4(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
-}
-function loadSnapshot(commitHash, outputDir) {
-  const shortHash = commitHash.substring(0, 8);
-  const filepath = join16(outputDir, `${shortHash}.json`);
-  if (!existsSync14(filepath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync10(filepath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function createSnapshot(graph, commitHash, commitDate, commitMessage, commitAuthor) {
-  const fileMap = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (!fileMap.has(node.filePath)) {
-      fileMap.set(node.filePath, { symbols: 0, inbound: 0, outbound: 0 });
-    }
-    fileMap.get(node.filePath).symbols++;
-  }
-  for (const edge of graph.edges) {
-    const sourceNode = graph.nodes.find((n) => n.id === edge.source);
-    const targetNode = graph.nodes.find((n) => n.id === edge.target);
-    if (sourceNode && targetNode && sourceNode.filePath !== targetNode.filePath) {
-      if (fileMap.has(sourceNode.filePath)) {
-        fileMap.get(sourceNode.filePath).outbound++;
-      }
-      if (fileMap.has(targetNode.filePath)) {
-        fileMap.get(targetNode.filePath).inbound++;
-      }
-    }
-  }
-  const files = Array.from(fileMap.entries()).map(([path6, data]) => ({
-    path: path6,
-    symbols: data.symbols,
-    connections: data.inbound + data.outbound
-  }));
-  const edgeMap = /* @__PURE__ */ new Map();
-  for (const edge of graph.edges) {
-    const sourceNode = graph.nodes.find((n) => n.id === edge.source);
-    const targetNode = graph.nodes.find((n) => n.id === edge.target);
-    if (sourceNode && targetNode && sourceNode.filePath !== targetNode.filePath) {
-      const key = sourceNode.filePath < targetNode.filePath ? `${sourceNode.filePath}|${targetNode.filePath}` : `${targetNode.filePath}|${sourceNode.filePath}`;
-      edgeMap.set(key, (edgeMap.get(key) || 0) + 1);
-    }
-  }
-  const edges = Array.from(edgeMap.entries()).map(([key, weight]) => {
-    const [source, target] = key.split("|");
-    return { source, target, weight };
-  });
-  const languages2 = {};
-  for (const file of graph.files) {
-    const ext = file.split(".").pop() || "unknown";
-    const lang = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" || ext === "mjs" || ext === "cjs" ? "javascript" : ext === "py" ? "python" : ext === "go" ? "go" : "other";
-    languages2[lang] = (languages2[lang] || 0) + 1;
-  }
-  return {
-    commitHash,
-    commitDate,
-    commitMessage,
-    commitAuthor,
-    stats: {
-      totalFiles: graph.files.length,
-      totalSymbols: graph.nodes.length,
-      totalEdges: edges.length,
-      languages: languages2
-    },
-    files,
-    edges
-  };
-}
-
-// src/mcp/tools.ts
-function getToolsList() {
-  return [
-    {
-      name: "connect_repo",
-      description: "Connect Depwire to a codebase for analysis. Accepts a local directory path or a GitHub repository URL. If a GitHub URL is provided, the repo will be cloned automatically. This replaces the currently loaded project.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          source: {
-            type: "string",
-            description: "Local directory path (e.g., '/Users/me/project') or GitHub URL (e.g., 'https://github.com/vercel/next.js')"
-          },
-          subdirectory: {
-            type: "string",
-            description: "Subdirectory within the repo to analyze (optional, e.g., 'packages/core/src')"
-          }
-        },
-        required: ["source"]
-      }
-    },
-    {
-      name: "get_symbol_info",
-      description: "Look up detailed information about a symbol (function, class, variable, type, etc.) by name. Pass a symbol name (e.g., 'Router') or a fully qualified ID (e.g., 'src/router.ts::Router') for exact matching. If multiple symbols share the same name, returns all matches for disambiguation.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          name: {
-            type: "string",
-            description: "The symbol name to look up (e.g., 'UserService') or full ID (e.g., 'src/services/UserService.ts::UserService')"
-          }
-        },
-        required: ["name"]
-      }
-    },
-    {
-      name: "get_dependencies",
-      description: "Get all symbols that a given symbol depends on (what does this symbol use/import/call?). Pass a symbol name (e.g., 'Router') or a fully qualified ID (e.g., 'src/router.ts::Router') for exact matching. If multiple symbols share the same name, returns all matches for disambiguation.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          symbol: {
-            type: "string",
-            description: "Symbol name (e.g., 'Router') or full ID (e.g., 'src/router.ts::Router')"
-          }
-        },
-        required: ["symbol"]
-      }
-    },
-    {
-      name: "get_dependents",
-      description: "Get all symbols that depend on a given symbol (what uses this symbol?). Pass a symbol name (e.g., 'Router') or a fully qualified ID (e.g., 'src/router.ts::Router') for exact matching. If multiple symbols share the same name, returns all matches for disambiguation.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          symbol: {
-            type: "string",
-            description: "Symbol name (e.g., 'Router') or full ID (e.g., 'src/router.ts::Router')"
-          }
-        },
-        required: ["symbol"]
-      }
-    },
-    {
-      name: "impact_analysis",
-      description: "Analyze what would break if a symbol is changed, renamed, or removed. Shows direct dependents, transitive dependents (chain reaction), and all affected files. Pass a symbol name (e.g., 'Router') or a fully qualified ID (e.g., 'src/router.ts::Router') for exact matching. If multiple symbols share the same name, returns all matches for disambiguation. Use this before making changes to understand the blast radius.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          symbol: {
-            type: "string",
-            description: "Symbol name (e.g., 'Router') or full ID (e.g., 'src/router.ts::Router')"
-          },
-          file: {
-            type: "string",
-            description: "Optional: File path to disambiguate when multiple symbols have the same name (e.g., 'src/router.ts')"
-          }
-        },
-        required: ["symbol"]
-      }
-    },
-    {
-      name: "get_file_context",
-      description: "Get complete context about a file \u2014 all symbols defined in it, all imports, all exports, and all files that import from it.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          filePath: {
-            type: "string",
-            description: "Relative file path (e.g., 'services/UserService.ts')"
-          }
-        },
-        required: ["filePath"]
-      }
-    },
-    {
-      name: "search_symbols",
-      description: "Search for symbols by name across the entire codebase. Supports partial matching.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "Search query (case-insensitive substring match)"
-          },
-          limit: {
-            type: "number",
-            description: "Maximum results to return (default: 20)"
-          }
-        },
-        required: ["query"]
-      }
-    },
-    {
-      name: "get_architecture_summary",
-      description: "Get a high-level overview of the project's architecture \u2014 file count, symbol count, most connected files, dependency hotspots, and orphan files.",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      }
-    },
-    {
-      name: "list_files",
-      description: "List all files in the project with basic stats.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          directory: {
-            type: "string",
-            description: "Filter to a specific subdirectory (optional)"
-          }
-        }
-      }
-    },
-    {
-      name: "visualize_graph",
-      description: "Render an interactive arc diagram visualization of the current codebase's cross-reference graph. Shows files as bars along the bottom and dependency arcs connecting them, colored by distance. The visualization appears inline in the conversation.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          highlight: {
-            type: "string",
-            description: "File or symbol name to highlight in the visualization (optional)"
-          },
-          maxFiles: {
-            type: "number",
-            description: "Limit to top N most connected files (optional, default: all)"
-          }
-        }
-      }
-    },
-    {
-      name: "get_project_docs",
-      description: "Retrieve auto-generated codebase documentation. Returns architecture overview, code conventions, dependency maps, and onboarding guides. Documentation must be generated first with `depwire docs` command.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          doc_type: {
-            type: "string",
-            description: "Document type to retrieve: 'architecture', 'conventions', 'dependencies', 'onboarding', or 'all' (default: 'all')"
-          }
-        }
-      }
-    },
-    {
-      name: "update_project_docs",
-      description: "Regenerate codebase documentation with the latest changes. If docs don't exist, generates them for the first time. Use this after significant code changes to keep documentation up-to-date.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          doc_type: {
-            type: "string",
-            description: "Document type to update: 'architecture', 'conventions', 'dependencies', 'onboarding', or 'all' (default: 'all')"
-          }
-        }
-      }
-    },
-    {
-      name: "get_health_score",
-      description: "Get a 0-100 health score for the project's dependency architecture. Scores coupling, cohesion, circular dependencies, god files, orphan files, and dependency depth. Returns overall score, per-dimension breakdown, and actionable recommendations.",
-      inputSchema: {
-        type: "object",
-        properties: {}
-      }
-    },
-    {
-      name: "get_temporal_graph",
-      description: "Show how the dependency graph evolved over git history. Returns snapshots at sampled commits showing file counts, symbol counts, edge counts, and structural changes over time.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          commits: {
-            type: "number",
-            description: "Number of commits to sample (default: 10)"
-          },
-          strategy: {
-            type: "string",
-            enum: ["even", "weekly", "monthly"],
-            description: "Sampling strategy (default: even)"
-          }
-        }
-      }
-    },
-    {
-      name: "find_dead_code",
-      description: "Find potentially dead code \u2014 symbols that are defined but never referenced anywhere in the codebase. Returns symbols categorized by confidence level (high, medium, low). High confidence means definitely unused. Use this to identify cleanup opportunities.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          confidence: {
-            type: "string",
-            enum: ["high", "medium", "low"],
-            description: "Minimum confidence level to return (default: medium)",
-            default: "medium"
-          }
-        }
-      }
-    }
-  ];
-}
-async function handleToolCall(name, args, state) {
-  try {
-    let result;
-    if (name === "connect_repo") {
-      result = await connectToRepo(args.source, args.subdirectory, state);
-    } else if (name === "get_architecture_summary") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          status: "no_project",
-          message: "No project loaded. Use connect_repo to analyze a codebase."
-        };
-      } else {
-        result = handleGetArchitectureSummary(state.graph);
-      }
-    } else if (name === "visualize_graph") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = await handleVisualizeGraph(args.highlight, args.maxFiles, state);
-      }
-    } else if (name === "get_project_docs") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = await handleGetProjectDocs(args.doc_type || "all", state);
-      }
-    } else if (name === "update_project_docs") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = await handleUpdateProjectDocs(args.doc_type || "all", state);
-      }
-    } else if (name === "get_health_score") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = handleGetHealthScore(state);
-      }
-    } else if (name === "get_temporal_graph") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = await handleGetTemporalGraph(state, args.commits || 10, args.strategy || "even");
-      }
-    } else if (name === "find_dead_code") {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        result = handleFindDeadCode(state, args.confidence || "medium");
-      }
-    } else {
-      if (!isProjectLoaded(state)) {
-        result = {
-          error: "No project loaded",
-          message: "Use connect_repo to connect to a codebase first"
-        };
-      } else {
-        const graph = state.graph;
-        switch (name) {
-          case "get_symbol_info":
-            result = handleGetSymbolInfo(args.name, graph);
-            break;
-          case "get_dependencies":
-            result = handleGetDependencies(args.symbol, graph);
-            break;
-          case "get_dependents":
-            result = handleGetDependents(args.symbol, graph);
-            break;
-          case "impact_analysis":
-            result = handleImpactAnalysis(args.symbol, graph, args.file);
-            break;
-          case "get_file_context":
-            result = handleGetFileContext(args.filePath, graph);
-            break;
-          case "search_symbols":
-            result = handleSearchSymbols(args.query, args.limit || 20, graph);
-            break;
-          case "list_files":
-            result = handleListFiles(args.directory, graph);
-            break;
-          default:
-            result = { error: `Unknown tool: ${name}` };
-        }
-      }
-    }
-    if (result && typeof result === "object" && "_mcpAppResponse" in result) {
-      const appResult = result;
-      return {
-        content: [
-          {
-            type: "text",
-            text: appResult.text
-          },
-          {
-            type: "resource",
-            resource: {
-              uri: "ui://depwire/arc-diagram",
-              mimeType: "text/html;profile=mcp-app",
-              text: appResult.html
-            }
-          }
-        ]
-      };
-    }
-    if (result && typeof result === "object" && "content" in result && Array.isArray(result.content)) {
-      return result;
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result, null, 2)
-        }
-      ]
-    };
-  } catch (error) {
-    console.error("Error handling tool call:", error);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ error: String(error) }, null, 2)
-        }
-      ]
-    };
-  }
-}
-function createDisambiguationResponse(matches, queryName) {
-  const suggestion = matches.length > 0 ? matches[0].id : "";
-  const exampleFile = matches.length > 0 ? matches[0].filePath : "";
-  return {
-    ambiguous: true,
-    message: `Found ${matches.length} symbols named '${queryName}'. Disambiguate by:
-1. Using full ID: '${suggestion}'
-2. Or adding file parameter: { symbol: '${queryName}', file: '${exampleFile}' }`,
-    matches: matches.map((m, index) => ({
-      id: m.id,
-      kind: m.kind,
-      filePath: m.filePath,
-      line: m.startLine,
-      dependents: m.dependentCount,
-      hint: index === 0 && m.dependentCount > 0 ? "Most dependents \u2014 likely the one you want" : ""
-    })),
-    suggestion
-  };
-}
-function handleGetSymbolInfo(name, graph) {
-  const matches = findSymbols(graph, name);
-  if (matches.length === 0) {
-    const fuzzyMatches = searchSymbols(graph, name).slice(0, 10);
-    return {
-      error: `Symbol '${name}' not found`,
-      suggestion: fuzzyMatches.length > 0 ? `Did you mean: ${fuzzyMatches.map((m) => m.name).join(", ")}?` : "Try using search_symbols to find available symbols",
-      fuzzyMatches: fuzzyMatches.map((m) => ({
-        id: m.id,
-        name: m.name,
-        kind: m.kind,
-        filePath: m.filePath
-      }))
-    };
-  }
-  return {
-    matches: matches.map((m) => ({
-      id: m.id,
-      name: m.name,
-      kind: m.kind,
-      filePath: m.filePath,
-      startLine: m.startLine,
-      endLine: m.endLine,
-      exported: m.exported,
-      scope: m.scope,
-      dependents: m.dependentCount
-    })),
-    count: matches.length
-  };
-}
-function handleGetDependencies(symbol, graph) {
-  const matches = findSymbols(graph, symbol);
-  if (matches.length === 0) {
-    const fuzzyMatches = searchSymbols(graph, symbol).slice(0, 10);
-    return {
-      error: `Symbol '${symbol}' not found`,
-      suggestion: fuzzyMatches.length > 0 ? `Did you mean: ${fuzzyMatches.map((m) => m.name).join(", ")}?` : "Try using search_symbols to find available symbols"
-    };
-  }
-  if (matches.length > 1) {
-    return createDisambiguationResponse(matches, symbol);
-  }
-  const target = matches[0];
-  const deps = getDependencies(graph, target.id);
-  const grouped = {};
-  graph.forEachOutEdge(target.id, (edge, attrs, source, targetNode) => {
-    const kind = attrs.kind;
-    if (!grouped[kind]) {
-      grouped[kind] = [];
-    }
-    const targetAttrs = graph.getNodeAttributes(targetNode);
-    grouped[kind].push({
-      name: targetAttrs.name,
-      filePath: targetAttrs.filePath,
-      kind: targetAttrs.kind
-    });
-  });
-  const totalCount = Object.values(grouped).reduce((sum, arr) => sum + arr.length, 0);
-  return {
-    symbol: target.id,
-    dependencies: grouped,
-    totalCount
-  };
-}
-function handleGetDependents(symbol, graph) {
-  const matches = findSymbols(graph, symbol);
-  if (matches.length === 0) {
-    const fuzzyMatches = searchSymbols(graph, symbol).slice(0, 10);
-    return {
-      error: `Symbol '${symbol}' not found`,
-      suggestion: fuzzyMatches.length > 0 ? `Did you mean: ${fuzzyMatches.map((m) => m.name).join(", ")}?` : "Try using search_symbols to find available symbols"
-    };
-  }
-  if (matches.length > 1) {
-    return createDisambiguationResponse(matches, symbol);
-  }
-  const target = matches[0];
-  const deps = getDependents(graph, target.id);
-  const grouped = {};
-  graph.forEachInEdge(target.id, (edge, attrs, source, targetNode) => {
-    const kind = attrs.kind;
-    if (!grouped[kind]) {
-      grouped[kind] = [];
-    }
-    const sourceAttrs = graph.getNodeAttributes(source);
-    grouped[kind].push({
-      name: sourceAttrs.name,
-      filePath: sourceAttrs.filePath,
-      kind: sourceAttrs.kind
-    });
-  });
-  const totalCount = Object.values(grouped).reduce((sum, arr) => sum + arr.length, 0);
-  return {
-    symbol: target.id,
-    dependents: grouped,
-    totalCount
-  };
-}
-function handleImpactAnalysis(symbol, graph, file) {
-  const matches = findSymbols(graph, symbol);
-  if (matches.length === 0) {
-    const fuzzyMatches = searchSymbols(graph, symbol).slice(0, 10);
-    return {
-      error: `Symbol '${symbol}' not found`,
-      suggestion: fuzzyMatches.length > 0 ? `Did you mean: ${fuzzyMatches.map((m) => m.name).join(", ")}?` : "Try using search_symbols to find available symbols"
-    };
-  }
-  let filteredMatches = matches;
-  if (file) {
-    filteredMatches = matches.filter((m) => m.filePath === file || m.filePath.endsWith(file));
-    if (filteredMatches.length === 0) {
-      return {
-        error: `Symbol '${symbol}' not found in file '${file}'`,
-        availableFiles: matches.map((m) => m.filePath),
-        suggestion: `The symbol exists in: ${matches.map((m) => m.filePath).join(", ")}`
-      };
-    }
-  }
-  if (filteredMatches.length > 1) {
-    return createDisambiguationResponse(filteredMatches, symbol);
-  }
-  const target = filteredMatches[0];
-  const impact = getImpact(graph, target.id);
-  const directWithKinds = impact.directDependents.map((dep) => {
-    let relationship = "unknown";
-    graph.forEachEdge(dep.id, target.id, (edge, attrs) => {
-      relationship = attrs.kind;
-    });
-    return {
-      name: dep.name,
-      filePath: dep.filePath,
-      kind: dep.kind,
-      relationship
-    };
-  });
-  const transitiveFormatted = impact.transitiveDependents.filter((dep) => !impact.directDependents.some((d) => d.id === dep.id)).map((dep) => ({
-    name: dep.name,
-    filePath: dep.filePath,
-    kind: dep.kind
-  }));
-  const summary = `Changing ${target.name} would directly affect ${impact.directDependents.length} symbol(s) and transitively affect ${transitiveFormatted.length} more, across ${impact.affectedFiles.length} file(s).`;
-  return {
-    symbol: {
-      id: target.id,
-      name: target.name,
-      filePath: target.filePath,
-      kind: target.kind
-    },
-    impact: {
-      directDependents: directWithKinds,
-      transitiveDependents: transitiveFormatted,
-      affectedFiles: impact.affectedFiles,
-      summary
-    }
-  };
-}
-function handleGetFileContext(filePath, graph) {
-  const fileSymbols = [];
-  graph.forEachNode((nodeId, attrs) => {
-    if (attrs.filePath === filePath) {
-      fileSymbols.push({
-        name: attrs.name,
-        kind: attrs.kind,
-        exported: attrs.exported,
-        startLine: attrs.startLine,
-        endLine: attrs.endLine,
-        scope: attrs.scope
-      });
-    }
-  });
-  if (fileSymbols.length === 0) {
-    return {
-      error: `File '${filePath}' not found`,
-      suggestion: "Use list_files to see available files"
-    };
-  }
-  const importsMap = /* @__PURE__ */ new Map();
-  graph.forEachNode((nodeId, attrs) => {
-    if (attrs.filePath === filePath) {
-      graph.forEachOutEdge(nodeId, (edge, edgeAttrs, source, target) => {
-        const targetAttrs = graph.getNodeAttributes(target);
-        if (targetAttrs.filePath !== filePath) {
-          if (!importsMap.has(targetAttrs.filePath)) {
-            importsMap.set(targetAttrs.filePath, /* @__PURE__ */ new Set());
-          }
-          importsMap.get(targetAttrs.filePath).add(targetAttrs.name);
-        }
-      });
-    }
-  });
-  const imports = Array.from(importsMap.entries()).map(([file, symbols]) => ({
-    from: file,
-    symbols: Array.from(symbols)
-  }));
-  const importedByMap = /* @__PURE__ */ new Map();
-  graph.forEachNode((nodeId, attrs) => {
-    if (attrs.filePath === filePath) {
-      graph.forEachInEdge(nodeId, (edge, edgeAttrs, source, target) => {
-        const sourceAttrs = graph.getNodeAttributes(source);
-        if (sourceAttrs.filePath !== filePath) {
-          if (!importedByMap.has(sourceAttrs.filePath)) {
-            importedByMap.set(sourceAttrs.filePath, /* @__PURE__ */ new Set());
-          }
-          importedByMap.get(sourceAttrs.filePath).add(attrs.name);
-        }
-      });
-    }
-  });
-  const importedBy = Array.from(importedByMap.entries()).map(([file, symbols]) => ({
-    file,
-    symbols: Array.from(symbols)
-  }));
-  const summary = `${filePath} defines ${fileSymbols.length} symbol(s), imports from ${imports.length} file(s), and is imported by ${importedBy.length} file(s).`;
-  return {
-    filePath,
-    symbols: fileSymbols,
-    imports,
-    importedBy,
-    summary
-  };
-}
-function handleSearchSymbols(query, limit, graph) {
-  const results = searchSymbols(graph, query);
-  const queryLower = query.toLowerCase();
-  results.sort((a, b) => {
-    const aName = a.name.toLowerCase();
-    const bName = b.name.toLowerCase();
-    if (aName === queryLower && bName !== queryLower) return -1;
-    if (bName === queryLower && aName !== queryLower) return 1;
-    const aStarts = aName.startsWith(queryLower);
-    const bStarts = bName.startsWith(queryLower);
-    if (aStarts && !bStarts) return -1;
-    if (bStarts && !aStarts) return 1;
-    return aName.localeCompare(bName);
-  });
-  const showing = Math.min(limit, results.length);
-  return {
-    query,
-    results: results.slice(0, limit).map((r) => ({
-      name: r.name,
-      kind: r.kind,
-      filePath: r.filePath,
-      exported: r.exported,
-      scope: r.scope
-    })),
-    totalMatches: results.length,
-    showing
-  };
-}
-function handleGetArchitectureSummary(graph) {
-  const summary = getArchitectureSummary(graph);
-  const fileSummary = getFileSummary(graph);
-  const dirMap = /* @__PURE__ */ new Map();
-  const languageBreakdown = {};
-  fileSummary.forEach((f) => {
-    const dir = f.filePath.includes("/") ? dirname16(f.filePath) : ".";
-    if (!dirMap.has(dir)) {
-      dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
-    }
-    const entry = dirMap.get(dir);
-    entry.fileCount++;
-    entry.symbolCount += f.symbolCount;
-    const ext = f.filePath.toLowerCase();
-    let lang;
-    if (ext.endsWith(".ts") || ext.endsWith(".tsx")) {
-      lang = "typescript";
-    } else if (ext.endsWith(".py")) {
-      lang = "python";
-    } else if (ext.endsWith(".js") || ext.endsWith(".jsx") || ext.endsWith(".mjs") || ext.endsWith(".cjs")) {
-      lang = "javascript";
-    } else {
-      lang = "other";
-    }
-    languageBreakdown[lang] = (languageBreakdown[lang] || 0) + 1;
-  });
-  const directories = Array.from(dirMap.entries()).map(([name, stats]) => ({ name, ...stats })).sort((a, b) => b.symbolCount - a.symbolCount);
-  const summaryText = `Project has ${summary.fileCount} files with ${summary.symbolCount} symbols and ${summary.edgeCount} edges. The most connected file is ${summary.mostConnectedFiles[0]?.filePath || "N/A"} with ${summary.mostConnectedFiles[0]?.connections || 0} connections.`;
-  return {
-    overview: {
-      totalFiles: summary.fileCount,
-      totalSymbols: summary.symbolCount,
-      totalEdges: summary.edgeCount,
-      languages: languageBreakdown
-    },
-    mostConnectedFiles: summary.mostConnectedFiles.slice(0, 10),
-    directories: directories.slice(0, 10),
-    orphanFiles: summary.orphanFiles,
-    summary: summaryText
-  };
-}
-function handleListFiles(directory, graph) {
-  const fileSummary = getFileSummary(graph);
-  let filtered = fileSummary;
-  if (directory) {
-    filtered = fileSummary.filter((f) => f.filePath.startsWith(directory));
-  }
-  const files = filtered.map((f) => ({
-    path: f.filePath,
-    symbolCount: f.symbolCount,
-    connections: f.incomingRefs + f.outgoingRefs
-  }));
-  return {
-    files,
-    totalFiles: files.length
-  };
-}
-async function handleVisualizeGraph(highlight, maxFiles, state) {
-  const vizData = prepareVizData(state.graph, state.projectRoot);
-  const { url, alreadyRunning } = await startVizServer(
-    vizData,
-    state.graph,
-    state.projectRoot,
-    3456,
-    // Use different port from CLI default to avoid conflicts
-    false
-    // Don't auto-open browser from MCP
-  );
-  const fileCount = maxFiles && maxFiles < vizData.files.length ? maxFiles : vizData.files.length;
-  const arcCount = vizData.arcs.filter((a) => {
-    if (!maxFiles || maxFiles >= vizData.files.length) return true;
-    const topFiles = vizData.files.sort((a2, b) => b.incomingCount + b.outgoingCount - (a2.incomingCount + a2.outgoingCount)).slice(0, maxFiles).map((f) => f.path);
-    return topFiles.includes(a.sourceFile) && topFiles.includes(a.targetFile);
-  }).length;
-  const statusMessage = alreadyRunning ? "Visualization server is already running." : "Visualization server started.";
-  const message = `${statusMessage}
-
-Interactive arc diagram: ${url}
-
-The diagram shows ${fileCount} files and ${arcCount} cross-file dependencies.${highlight ? ` Highlighted: ${highlight}` : ""}
-
-Features:
-\u2022 Hover over arcs to see source \u2192 target details
-\u2022 Click files to filter connections
-\u2022 Search for specific files
-\u2022 Export as SVG or PNG
-
-The server will keep running until you end the MCP session or press Ctrl+C.`;
-  return {
-    content: [{ type: "text", text: message }]
-  };
-}
-async function handleGetProjectDocs(docType, state) {
-  const docsDir = join17(state.projectRoot, ".depwire");
-  if (!existsSync15(docsDir)) {
-    const errorMessage = `Project documentation has not been generated yet.
-
-Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
-
-Once generated, this tool will return the requested documentation.
-
-Available document types:
-- architecture: High-level structural overview
-- conventions: Auto-detected coding patterns
-- dependencies: Complete dependency mapping
-- onboarding: Guide for new developers`;
-    return {
-      content: [{ type: "text", text: errorMessage }]
-    };
-  }
-  const metadata = loadMetadata(docsDir);
-  if (!metadata) {
-    return {
-      content: [{ type: "text", text: "Documentation directory exists but metadata is missing. Please regenerate with `depwire docs`." }]
-    };
-  }
-  const docsToReturn = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  let output = "";
-  const missing = [];
-  for (const doc of docsToReturn) {
-    if (!metadata.documents[doc]) {
-      missing.push(doc);
-      continue;
-    }
-    const filePath = join17(docsDir, metadata.documents[doc].file);
-    if (!existsSync15(filePath)) {
-      missing.push(doc);
-      continue;
-    }
-    const content = readFileSync11(filePath, "utf-8");
-    if (docsToReturn.length > 1) {
-      output += `
-
----
-
-# ${doc.toUpperCase()}
-
-`;
-    }
-    output += content;
-  }
-  if (missing.length > 0) {
-    output += `
-
----
-
-**Note:** The following documents are missing: ${missing.join(", ")}. Run \`depwire docs ${state.projectRoot} --update\` to generate them.`;
-  }
-  return {
-    content: [{ type: "text", text: output }]
-  };
-}
-async function handleUpdateProjectDocs(docType, state) {
-  const startTime = Date.now();
-  const docsDir = join17(state.projectRoot, ".depwire");
-  console.error("Regenerating project documentation...");
-  const parsedFiles = await parseProject(state.projectRoot);
-  const graph = buildGraph(parsedFiles);
-  const parseTime = (Date.now() - startTime) / 1e3;
-  state.graph = graph;
-  const packageJsonPath = join17(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
-  const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync15(docsDir);
-  const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
-    outputDir: docsDir,
-    format: "markdown",
-    include: docsToGenerate,
-    update: docsExist,
-    only: docsExist ? docsToGenerate : void 0,
-    verbose: false,
-    stats: false
-  });
-  const elapsed = (Date.now() - startTime) / 1e3;
-  if (result.success) {
-    const fileCount = /* @__PURE__ */ new Set();
-    graph.forEachNode((node, attrs) => {
-      fileCount.add(attrs.filePath);
-    });
-    return {
-      status: "success",
-      message: `Updated ${result.generated.join(", ")} (${fileCount.size} files, ${graph.order} symbols, ${elapsed.toFixed(1)}s)`,
-      generated: result.generated,
-      stats: {
-        files: fileCount.size,
-        symbols: graph.order,
-        edges: graph.size,
-        time: elapsed
-      }
-    };
-  } else {
-    return {
-      status: "error",
-      message: `Failed to update documentation: ${result.errors.join(", ")}`,
-      errors: result.errors
-    };
-  }
-}
-function handleGetHealthScore(state) {
-  const graph = state.graph;
-  const projectRoot = state.projectRoot;
-  const report = calculateHealthScore(graph, projectRoot);
-  return report;
-}
-async function handleGetTemporalGraph(state, commits, strategy) {
-  const projectRoot = state.projectRoot;
-  if (!isGitRepo(projectRoot)) {
-    return {
-      error: "Not a git repository",
-      message: "Temporal analysis requires git history"
-    };
-  }
-  try {
-    const allCommits = await getCommitLog(projectRoot);
-    if (allCommits.length === 0) {
-      return {
-        error: "No commits found",
-        message: "Repository has no commit history"
-      };
-    }
-    const sampledCommits = sampleCommits(allCommits, commits, strategy);
-    const snapshots = [];
-    const outputDir = join17(projectRoot, ".depwire", "temporal");
-    for (const commit of sampledCommits) {
-      const existing = loadSnapshot(commit.hash, outputDir);
-      if (existing) {
-        snapshots.push(existing);
-      }
-    }
-    if (snapshots.length === 0) {
-      return {
-        status: "no_snapshots",
-        message: "No temporal snapshots found. Run `depwire temporal` to generate them.",
-        commits_found: allCommits.length,
-        commits_to_sample: sampledCommits.length
-      };
-    }
-    const first = snapshots[0];
-    const last = snapshots[snapshots.length - 1];
-    const growth = {
-      files: last.stats.totalFiles - first.stats.totalFiles,
-      symbols: last.stats.totalSymbols - first.stats.totalSymbols,
-      edges: last.stats.totalEdges - first.stats.totalEdges
-    };
-    const trend = growth.files > 0 ? "Growing" : growth.files < 0 ? "Shrinking" : "Stable";
-    let biggestGrowth = { index: 0, files: 0, date: "", message: "" };
-    for (let i = 1; i < snapshots.length; i++) {
-      const delta = snapshots[i].stats.totalFiles - snapshots[i - 1].stats.totalFiles;
-      if (delta > biggestGrowth.files) {
-        biggestGrowth = {
-          index: i,
-          files: delta,
-          date: snapshots[i].commitDate,
-          message: snapshots[i].commitMessage
-        };
-      }
-    }
-    return {
-      status: "success",
-      time_range: {
-        from: first.commitDate,
-        to: last.commitDate
-      },
-      snapshots: snapshots.map((s) => ({
-        commit: s.commitHash.substring(0, 8),
-        date: s.commitDate,
-        message: s.commitMessage,
-        author: s.commitAuthor,
-        files: s.stats.totalFiles,
-        symbols: s.stats.totalSymbols,
-        edges: s.stats.totalEdges
-      })),
-      growth,
-      trend,
-      biggest_growth_period: biggestGrowth.files > 0 ? biggestGrowth : null,
-      summary: `Analyzed ${snapshots.length} snapshots from ${new Date(first.commitDate).toLocaleDateString()} to ${new Date(last.commitDate).toLocaleDateString()}. Overall trend: ${trend}.`
-    };
-  } catch (error) {
-    return {
-      error: "Failed to analyze temporal graph",
-      message: String(error)
-    };
-  }
-}
-function handleFindDeadCode(state, confidence) {
-  if (!state.graph || !state.projectRoot) {
-    return {
-      error: "No project loaded",
-      message: "Use connect_repo to connect to a codebase first"
-    };
-  }
-  try {
-    const report = analyzeDeadCode(state.graph, state.projectRoot, {
-      confidence,
-      includeTests: false,
-      verbose: false,
-      stats: false,
-      json: true
-    });
-    return {
-      status: "success",
-      totalSymbols: report.totalSymbols,
-      deadSymbols: report.deadSymbols,
-      deadPercentage: report.deadPercentage,
-      byConfidence: report.byConfidence,
-      symbols: report.symbols.map((s) => ({
-        name: s.name,
-        kind: s.kind,
-        file: s.file,
-        line: s.line,
-        exported: s.exported,
-        dependents: s.dependents,
-        confidence: s.confidence,
-        reason: s.reason
-      })),
-      summary: `Found ${report.deadSymbols} potentially dead symbols (${report.byConfidence.high} high, ${report.byConfidence.medium} medium, ${report.byConfidence.low} low confidence) out of ${report.totalSymbols} total symbols (${report.deadPercentage.toFixed(1)}% dead code).`
-    };
-  } catch (error) {
-    return {
-      error: "Failed to analyze dead code",
-      message: String(error)
-    };
-  }
-}
-
-// src/mcp/server.ts
-async function startMcpServer(state) {
-  const server = new Server(
-    {
-      name: "depwire",
-      version: "0.1.0"
-    },
-    {
-      capabilities: {
-        tools: {}
-      }
-    }
-  );
-  const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-      tools: getToolsList()
-    };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return await handleToolCall(name, args || {}, state);
-  });
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("Depwire MCP server started");
-  if (state.projectRoot) {
-    console.error(`Project: ${state.projectRoot}`);
-  } else {
-    console.error("No project loaded. Use connect_repo to connect to a codebase.");
-  }
-}
+};
 
 export {
   findProjectRoot,
+  parseTypeScriptFile,
   parseProject,
   buildGraph,
+  findSymbols,
+  getDependencies,
+  getDependents,
   getImpact,
+  getCrossFileEdges,
+  getFileSummary,
   searchSymbols,
   getArchitectureSummary,
-  prepareVizData,
-  watchProject,
-  startVizServer,
-  createEmptyState,
-  updateFileInGraph,
   calculateHealthScore,
   getHealthTrend,
   analyzeDeadCode,
+  loadMetadata,
   generateDocs,
-  getCommitLog,
-  getCurrentBranch,
-  checkoutCommit,
-  restoreOriginal,
-  stashChanges,
-  popStash,
-  isGitRepo,
-  sampleCommits,
-  saveSnapshot,
-  loadSnapshot,
-  createSnapshot,
-  startMcpServer
+  SimulationEngine
 };