depwire-cli 0.9.20 → 0.9.22

package/dist/chunk-XBCQPU63.js

@@ -0,0 +1,2002 @@
+import {
+  SimulationEngine,
+  analyzeDeadCode,
+  buildGraph,
+  calculateHealthScore,
+  findSymbols,
+  generateDocs,
+  getArchitectureSummary,
+  getCrossFileEdges,
+  getDependencies,
+  getDependents,
+  getFileSummary,
+  getImpact,
+  loadMetadata,
+  parseProject,
+  parseTypeScriptFile,
+  searchSymbols
+} from "./chunk-QHVWDUSX.js";
+
+// 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 } from "url";
+import { dirname, join } from "path";
+import { WebSocketServer } from "ws";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__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((resolve2) => {
+      const server = net.createServer();
+      server.once("error", () => {
+        resolve2(false);
+      });
+      server.once("listening", () => {
+        server.close();
+        resolve2(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 = join(__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 join2 } 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 = join2(projectRoot, relativeFilePath);
+  try {
+    const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
+    addFileToGraph(graph, parsedFile);
+  } catch (error) {
+    console.error(`Failed to parse file ${relativeFilePath}:`, error);
+  }
+}
+
+// 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 dirname2, join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+
+// src/mcp/connect.ts
+import simpleGit from "simple-git";
+import { existsSync } from "fs";
+import { join as join3, basename as basename2, resolve } from "path";
+import { tmpdir, homedir } from "os";
+function validateProjectPath(source) {
+  const resolved = resolve(source);
+  const blockedPaths = [
+    "/etc",
+    "/var",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/boot",
+    "/proc",
+    "/sys",
+    join3(homedir(), ".ssh"),
+    join3(homedir(), ".gnupg"),
+    join3(homedir(), ".aws"),
+    join3(homedir(), ".config"),
+    join3(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 };
+}
+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 = join3(tmpdir(), "depwire-repos");
+      const cloneDir = join3(reposDir, projectName);
+      console.error(`Connecting to GitHub repo: ${source}`);
+      const git = simpleGit();
+      if (existsSync(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 ? join3(cloneDir, subdirectory) : cloneDir;
+    } else {
+      const validation2 = validateProjectPath(source);
+      if (!validation2.valid) {
+        return {
+          error: "Access denied",
+          message: validation2.error
+        };
+      }
+      if (!existsSync(source)) {
+        return {
+          error: "Directory not found",
+          message: `Directory does not exist: ${source}`
+        };
+      }
+      projectRoot = subdirectory ? join3(source, subdirectory) : source;
+      projectName = basename2(projectRoot);
+    }
+    const validation = validateProjectPath(projectRoot);
+    if (!validation.valid) {
+      return {
+        error: "Access denied",
+        message: validation.error
+      };
+    }
+    if (!existsSync(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;
+    }
+    const parsedFiles = await parseProject(projectRoot);
+    if (parsedFiles.length === 0) {
+      return {
+        error: "No source files found",
+        message: `No supported source files (.ts, .tsx, .js, .jsx, .py, .go) found in ${projectRoot}`
+      };
+    }
+    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.`
+    };
+  } catch (error) {
+    console.error("Error in connectToRepo:", error);
+    return {
+      error: "Connection failed",
+      message: String(error)
+    };
+  }
+}
+
+// src/temporal/git.ts
+import { execSync } from "child_process";
+async function getCommitLog(dir, limit) {
+  try {
+    const limitArg = limit ? `-n ${limit}` : "";
+    const output = execSync(
+      `git log ${limitArg} --pretty=format:"%H|%aI|%s|%an"`,
+      { cwd: dir, encoding: "utf-8" }
+    );
+    if (!output.trim()) {
+      return [];
+    }
+    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 execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: dir,
+      encoding: "utf-8"
+    }).trim();
+  } catch (error) {
+    throw new Error(`Failed to get current branch: ${error}`);
+  }
+}
+async function checkoutCommit(dir, hash) {
+  try {
+    execSync(`git checkout -q ${hash}`, { cwd: dir, stdio: "ignore" });
+  } catch (error) {
+    throw new Error(`Failed to checkout commit ${hash}: ${error}`);
+  }
+}
+async function restoreOriginal(dir, originalBranch) {
+  try {
+    execSync(`git checkout -q ${originalBranch}`, {
+      cwd: dir,
+      stdio: "ignore"
+    });
+  } catch (error) {
+    throw new Error(`Failed to restore branch ${originalBranch}: ${error}`);
+  }
+}
+async function stashChanges(dir) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: dir,
+      encoding: "utf-8"
+    }).trim();
+    if (status) {
+      execSync('git stash push -q -m "depwire temporal analysis"', {
+        cwd: dir,
+        stdio: "ignore"
+      });
+      return true;
+    }
+    return false;
+  } catch (error) {
+    throw new Error(`Failed to stash changes: ${error}`);
+  }
+}
+async function popStash(dir) {
+  try {
+    const stashList = execSync("git stash list", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+      // Suppress stderr
+    }).trim();
+    if (stashList) {
+      execSync("git stash pop -q", { cwd: dir, stdio: "ignore" });
+    }
+  } catch (error) {
+  }
+}
+function isGitRepo(dir) {
+  try {
+    execSync("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);
+  }
+}
+function sampleEvenly(commits, targetCount) {
+  if (targetCount >= commits.length) {
+    return commits;
+  }
+  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]);
+  }
+  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, readFileSync, mkdirSync, existsSync as existsSync2, readdirSync } from "fs";
+import { join as join4 } from "path";
+function saveSnapshot(snapshot, outputDir) {
+  if (!existsSync2(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
+  const filepath = join4(outputDir, filename);
+  writeFileSync(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
+}
+function loadSnapshot(commitHash, outputDir) {
+  const shortHash = commitHash.substring(0, 8);
+  const filepath = join4(outputDir, `${shortHash}.json`);
+  if (!existsSync2(filepath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(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(([path, data]) => ({
+    path,
+    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 languages = {};
+  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";
+    languages[lang] = (languages[lang] || 0) + 1;
+  }
+  return {
+    commitHash,
+    commitDate,
+    commitMessage,
+    commitAuthor,
+    stats: {
+      totalFiles: graph.files.length,
+      totalSymbols: graph.nodes.length,
+      totalEdges: edges.length,
+      languages
+    },
+    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"
+          }
+        }
+      }
+    },
+    {
+      name: "simulate_change",
+      description: `Simulate an architectural change before touching any code. Returns health score delta, broken imports, and affected nodes. Zero file I/O \u2014 pure in-memory simulation.
+
+Operations:
+- delete: Simulate deleting a file. Shows every file that would break and the full blast radius.
+- move: Simulate moving a file to a new path. Shows broken imports and edge changes.
+- rename: Simulate renaming a file. Shows all affected imports and nodes.
+- split: Simulate splitting a file by moving specified symbols to a new file.
+- merge: Simulate merging two files into one. Fails fast on symbol name collision.
+
+Always run this before any refactor that touches file structure.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          operation: {
+            type: "string",
+            enum: ["move", "delete", "rename", "split", "merge"],
+            description: "Type of change to simulate"
+          },
+          target: {
+            type: "string",
+            description: "Relative file path of the primary target"
+          },
+          destination: {
+            type: "string",
+            description: "Required for move and rename \u2014 the new file path"
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: "Required for split \u2014 symbol names to move to new file"
+          },
+          mergeTarget: {
+            type: "string",
+            description: "Required for merge \u2014 the file to merge into target"
+          }
+        },
+        required: ["operation", "target"]
+      }
+    }
+  ];
+}
+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 (name === "simulate_change") {
+      if (!isProjectLoaded(state)) {
+        result = {
+          error: true,
+          message: "No project loaded. Use connect_repo to connect to a codebase first.",
+          operation: args.operation,
+          target: args.target
+        };
+      } else {
+        result = handleSimulateChange(args, state);
+      }
+    } 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("/") ? dirname2(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 = join5(state.projectRoot, ".depwire");
+  if (!existsSync3(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 = join5(docsDir, metadata.documents[doc].file);
+    if (!existsSync3(filePath)) {
+      missing.push(doc);
+      continue;
+    }
+    const content = readFileSync2(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 = join5(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 = join5(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+  const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
+  const docsExist = existsSync3(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 = join5(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)
+    };
+  }
+}
+function handleSimulateChange(args, state) {
+  const { operation, target, destination, symbols, mergeTarget } = args;
+  const graph = state.graph;
+  if ((operation === "move" || operation === "rename") && !destination) {
+    return {
+      error: true,
+      message: "destination is required for move and rename operations",
+      operation,
+      target
+    };
+  }
+  if (operation === "split" && (!symbols || symbols.length === 0)) {
+    return {
+      error: true,
+      message: "symbols is required for split operations and must not be empty",
+      operation,
+      target
+    };
+  }
+  if (operation === "merge" && !mergeTarget) {
+    return {
+      error: true,
+      message: "mergeTarget is required for merge operations",
+      operation,
+      target
+    };
+  }
+  const targetNodes = graph.filterNodes(
+    (_node, attrs) => {
+      const fp = attrs.filePath?.replace(/^\.\//, "").replace(/\/+$/, "");
+      const t = target.replace(/^\.\//, "").replace(/\/+$/, "");
+      return fp === t || fp?.endsWith("/" + t) || t.endsWith("/" + fp);
+    }
+  );
+  if (targetNodes.length === 0) {
+    return {
+      error: true,
+      message: `Target file '${target}' not found in the dependency graph`,
+      operation,
+      target
+    };
+  }
+  let action;
+  switch (operation) {
+    case "move":
+      action = { type: "move", target, destination };
+      break;
+    case "delete":
+      action = { type: "delete", target };
+      break;
+    case "rename":
+      action = { type: "rename", target, newName: destination };
+      break;
+    case "split":
+      action = { type: "split", target, newFile: destination || target.replace(/(\.\w+)$/, ".split$1"), symbols };
+      break;
+    case "merge":
+      action = { type: "merge", target, source: mergeTarget };
+      break;
+    default:
+      return {
+        error: true,
+        message: `Unknown operation: ${operation}`,
+        operation,
+        target
+      };
+  }
+  try {
+    const engine = new SimulationEngine(graph);
+    const result = engine.simulate(action);
+    const brokenImportCount = result.diff.brokenImports.length;
+    const affectedNodeCount = result.diff.affectedNodes.length;
+    const removedEdgeCount = result.diff.removedEdges.length;
+    return {
+      operation,
+      target,
+      healthBefore: result.healthDelta.before,
+      healthAfter: result.healthDelta.after,
+      healthDelta: result.healthDelta.delta,
+      affectedNodes: affectedNodeCount,
+      brokenImports: result.diff.brokenImports.map((bi) => ({
+        file: bi.file,
+        importedSymbol: bi.importedSymbol
+      })),
+      removedEdges: removedEdgeCount,
+      circularDepsIntroduced: result.diff.circularDepsIntroduced.length,
+      circularDepsResolved: result.diff.circularDepsResolved.length,
+      summary: `${operation.charAt(0).toUpperCase() + operation.slice(1)}ing ${target} would ${result.healthDelta.delta >= 0 ? "improve" : "reduce"} health score from ${result.healthDelta.before} to ${result.healthDelta.after} (${result.healthDelta.delta >= 0 ? "+" : ""}${result.healthDelta.delta}), breaking ${brokenImportCount} import${brokenImportCount !== 1 ? "s" : ""} across ${affectedNodeCount} affected node${affectedNodeCount !== 1 ? "s" : ""}.`
+    };
+  } catch (err) {
+    return {
+      error: true,
+      message: err.message,
+      operation,
+      target
+    };
+  }
+}
+
+// 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 {
+  prepareVizData,
+  watchProject,
+  startVizServer,
+  createEmptyState,
+  updateFileInGraph,
+  getCommitLog,
+  getCurrentBranch,
+  checkoutCommit,
+  restoreOriginal,
+  stashChanges,
+  popStash,
+  isGitRepo,
+  sampleCommits,
+  saveSnapshot,
+  loadSnapshot,
+  createSnapshot,
+  startMcpServer
+};