depwire-cli 0.1.0

package/dist/chunk-2XOJSBSD.js

@@ -0,0 +1,3302 @@
+// src/parser/index.ts
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/utils/files.ts
+import { readdirSync, statSync, existsSync, lstatSync } from "fs";
+import { join, relative } from "path";
+function scanDirectory(rootDir, baseDir = rootDir) {
+  const files = [];
+  try {
+    const entries = readdirSync(baseDir);
+    for (const entry of entries) {
+      const fullPath = join(baseDir, entry);
+      if (entry.startsWith(".")) {
+        continue;
+      }
+      if (entry === "node_modules" || entry === "vendor" || entry === "dist" || entry === "build") {
+        continue;
+      }
+      try {
+        const stats2 = lstatSync(fullPath);
+        if (stats2.isSymbolicLink()) {
+          continue;
+        }
+      } catch (err) {
+        continue;
+      }
+      const stats = statSync(fullPath);
+      if (stats.isDirectory()) {
+        files.push(...scanDirectory(rootDir, fullPath));
+      } else if (stats.isFile()) {
+        const isTypeScript = (entry.endsWith(".ts") || entry.endsWith(".tsx")) && !entry.endsWith(".d.ts");
+        const isJavaScript = entry.endsWith(".js") || entry.endsWith(".jsx") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
+        const isPython = entry.endsWith(".py");
+        const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
+        if (isTypeScript || isJavaScript || isPython || isGo) {
+          files.push(relative(rootDir, fullPath));
+        }
+      }
+    }
+  } catch (err) {
+    console.error(`Error scanning directory ${baseDir}:`, err);
+  }
+  return files;
+}
+function fileExists(filePath) {
+  try {
+    return existsSync(filePath) && statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/parser/detect.ts
+import { extname as extname3 } from "path";
+
+// src/parser/typescript.ts
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+
+// src/parser/resolver.ts
+import { join as join2, dirname, resolve, relative as relative2 } from "path";
+import { readFileSync } from "fs";
+var tsconfigCache = /* @__PURE__ */ new Map();
+function loadTsConfig(projectRoot) {
+  if (tsconfigCache.has(projectRoot)) {
+    return tsconfigCache.get(projectRoot);
+  }
+  let config = {};
+  let currentDir = projectRoot;
+  while (currentDir !== dirname(currentDir)) {
+    const tsconfigPath = join2(currentDir, "tsconfig.json");
+    try {
+      const raw = readFileSync(tsconfigPath, "utf-8");
+      const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([\]}])/g, "$1");
+      const parsed = JSON.parse(stripped);
+      if (parsed.compilerOptions) {
+        config.baseUrl = parsed.compilerOptions.baseUrl;
+        config.paths = parsed.compilerOptions.paths;
+        if (config.baseUrl) {
+          config.baseUrl = resolve(currentDir, config.baseUrl);
+        }
+      }
+      break;
+    } catch (err) {
+      currentDir = dirname(currentDir);
+    }
+  }
+  tsconfigCache.set(projectRoot, config);
+  return config;
+}
+function expandPathAlias(importPath, tsconfig) {
+  if (!tsconfig.paths) return null;
+  for (const [pattern, mappings] of Object.entries(tsconfig.paths)) {
+    const patternRegex = new RegExp(
+      "^" + pattern.replace(/\*/g, "(.*)") + "$"
+    );
+    const match = importPath.match(patternRegex);
+    if (match) {
+      const captured = match[1] || "";
+      for (const mapping of mappings) {
+        const expanded = mapping.replace(/\*/g, captured);
+        const baseUrl = tsconfig.baseUrl || ".";
+        return join2(baseUrl, expanded);
+      }
+    }
+  }
+  return null;
+}
+function tryResolve(basePath, projectRoot) {
+  const candidates = [];
+  if (basePath.endsWith(".js")) {
+    candidates.push(basePath.replace(/\.js$/, ".ts"));
+    candidates.push(basePath.replace(/\.js$/, ".tsx"));
+    candidates.push(basePath);
+  } else if (basePath.endsWith(".jsx")) {
+    candidates.push(basePath.replace(/\.jsx$/, ".tsx"));
+    candidates.push(basePath);
+  } else if (basePath.endsWith(".ts") || basePath.endsWith(".tsx")) {
+    candidates.push(basePath);
+  } else {
+    candidates.push(basePath + ".ts");
+    candidates.push(basePath + ".tsx");
+    candidates.push(join2(basePath, "index.ts"));
+    candidates.push(join2(basePath, "index.tsx"));
+    candidates.push(basePath);
+  }
+  for (const candidate of candidates) {
+    if (fileExists(candidate)) {
+      return relative2(projectRoot, candidate);
+    }
+  }
+  return null;
+}
+function resolveImportPath(importPath, fromFile, projectRoot) {
+  const tsconfig = loadTsConfig(projectRoot);
+  if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+    const expanded = expandPathAlias(importPath, tsconfig);
+    if (expanded) {
+      return tryResolve(expanded, projectRoot);
+    }
+    return null;
+  }
+  const fromDir = dirname(join2(projectRoot, fromFile));
+  let resolvedPath;
+  if (importPath.startsWith(".")) {
+    resolvedPath = resolve(fromDir, importPath);
+  } else {
+    resolvedPath = resolve(projectRoot, importPath.substring(1));
+  }
+  return tryResolve(resolvedPath, projectRoot);
+}
+
+// src/parser/typescript.ts
+var tsParser = new Parser();
+tsParser.setLanguage(TypeScript.typescript);
+var tsxParser = new Parser();
+tsxParser.setLanguage(TypeScript.tsx);
+function parseTypeScriptFile(filePath, sourceCode, projectRoot) {
+  const parser2 = filePath.endsWith(".tsx") ? tsxParser : tsParser;
+  const tree = parser2.parse(sourceCode);
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    imports: /* @__PURE__ */ new Map()
+  };
+  walkNode(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode(node, context) {
+  processNode(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode(child, context);
+    }
+  }
+}
+function processNode(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_declaration":
+      processFunctionDeclaration(node, context);
+      break;
+    case "class_declaration":
+      processClassDeclaration(node, context);
+      break;
+    case "variable_declaration":
+    case "lexical_declaration":
+      processVariableDeclaration(node, context);
+      break;
+    case "type_alias_declaration":
+      processTypeAliasDeclaration(node, context);
+      break;
+    case "interface_declaration":
+      processInterfaceDeclaration(node, context);
+      break;
+    case "enum_declaration":
+      processEnumDeclaration(node, context);
+      break;
+    case "import_statement":
+      processImportStatement(node, context);
+      break;
+    case "export_statement":
+      processExportStatement(node, context);
+      break;
+    case "call_expression":
+      processCallExpression(node, context);
+      break;
+    case "new_expression":
+      processNewExpression(node, context);
+      break;
+  }
+}
+function processFunctionDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const exported = isExported(node);
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const scope = context.currentScope.length > 0 ? context.currentScope.join(".") : void 0;
+  const symbolId = `${context.filePath}::${scope ? scope + "." : ""}${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "function",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported,
+    scope
+  });
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode(body, context);
+  }
+  context.currentScope.pop();
+}
+function processClassDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const exported = isExported(node);
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported
+  });
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "class_heritage") {
+      const extendsClause = child.childForFieldName("extends");
+      if (extendsClause) {
+        for (let j = 0; j < extendsClause.childCount; j++) {
+          const typeNode = extendsClause.child(j);
+          if (typeNode && typeNode.type === "identifier") {
+            const targetName = typeNode.text;
+            const targetId = `${context.filePath}::${targetName}`;
+            context.edges.push({
+              source: symbolId,
+              target: targetId,
+              kind: "extends",
+              filePath: context.filePath,
+              line: typeNode.startPosition.row + 1
+            });
+          }
+        }
+      }
+      const implementsClause = child.childForFieldName("implements");
+      if (implementsClause) {
+        for (let j = 0; j < implementsClause.childCount; j++) {
+          const typeNode = implementsClause.child(j);
+          if (typeNode && typeNode.type === "type_identifier") {
+            const targetName = typeNode.text;
+            const targetId = `${context.filePath}::${targetName}`;
+            context.edges.push({
+              source: symbolId,
+              target: targetId,
+              kind: "implements",
+              filePath: context.filePath,
+              line: typeNode.startPosition.row + 1
+            });
+          }
+        }
+      }
+    }
+  }
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child) {
+        if (child.type === "method_definition") {
+          processMethodDefinition(child, context);
+        } else if (child.type === "public_field_definition" || child.type === "field_definition") {
+          processPropertyDefinition(child, context);
+        }
+      }
+    }
+  }
+  context.currentScope.pop();
+}
+function processMethodDefinition(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const className = context.currentScope[context.currentScope.length - 1];
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${className}.${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported: false,
+    scope: className
+  });
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode(body, context);
+  }
+  context.currentScope.pop();
+}
+function processPropertyDefinition(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const className = context.currentScope[context.currentScope.length - 1];
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${className}.${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "property",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported: false,
+    scope: className
+  });
+}
+function processVariableDeclaration(node, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "variable_declarator") {
+      const nameNode = child.childForFieldName("name");
+      if (!nameNode) continue;
+      const name = nameNode.text;
+      const exported = isExported(node.parent);
+      const startLine = child.startPosition.row + 1;
+      const endLine = child.endPosition.row + 1;
+      const scope = context.currentScope.length > 0 ? context.currentScope.join(".") : void 0;
+      const value = child.childForFieldName("value");
+      const kind = value && value.type === "arrow_function" ? "function" : "variable";
+      const symbolId = `${context.filePath}::${scope ? scope + "." : ""}${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind,
+        filePath: context.filePath,
+        startLine,
+        endLine,
+        exported,
+        scope
+      });
+      if (kind === "function" && value) {
+        context.currentScope.push(name);
+        walkNode(value, context);
+        context.currentScope.pop();
+      }
+    }
+  }
+}
+function processTypeAliasDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const exported = isExported(node);
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "type_alias",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported
+  });
+}
+function processInterfaceDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const exported = isExported(node);
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "interface",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported
+  });
+}
+function processEnumDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const exported = isExported(node);
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "enum",
+    filePath: context.filePath,
+    startLine,
+    endLine,
+    exported
+  });
+}
+function processImportStatement(node, context) {
+  const source = node.childForFieldName("source");
+  if (!source) return;
+  const importPath = source.text.slice(1, -1);
+  const resolvedPath = resolveImportPath(importPath, context.filePath, context.projectRoot);
+  const importClause = node.child(1);
+  if (!importClause) return;
+  const importedNames = [];
+  const namedImports = findChildByType(importClause, "named_imports");
+  if (namedImports) {
+    for (let i = 0; i < namedImports.childCount; i++) {
+      const child = namedImports.child(i);
+      if (child && child.type === "import_specifier") {
+        const identifier2 = findChildByType(child, "identifier");
+        if (identifier2) {
+          importedNames.push(identifier2.text);
+        }
+      }
+    }
+  }
+  const identifier = findChildByType(importClause, "identifier");
+  if (identifier) {
+    importedNames.push(identifier.text);
+  }
+  const namespaceImport = findChildByType(importClause, "namespace_import");
+  if (namespaceImport) {
+    const alias = findChildByType(namespaceImport, "identifier");
+    if (alias) {
+      importedNames.push(alias.text);
+    }
+  }
+  if (resolvedPath) {
+    const currentSymbolId = getCurrentSymbolId(context);
+    for (const importedName of importedNames) {
+      const targetId = `${resolvedPath}::${importedName}`;
+      context.imports.set(importedName, targetId);
+      context.edges.push({
+        source: currentSymbolId || `${context.filePath}::__file__`,
+        target: targetId,
+        kind: "imports",
+        filePath: context.filePath,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+}
+function processExportStatement(node, context) {
+  const source = node.childForFieldName("source");
+  if (source) {
+    const importPath = source.text.slice(1, -1);
+    const resolvedPath = resolveImportPath(importPath, context.filePath, context.projectRoot);
+    const exportClause = node.child(1);
+    if (exportClause && resolvedPath) {
+      const exportedNames = [];
+      for (let i = 0; i < exportClause.childCount; i++) {
+        const child = exportClause.child(i);
+        if (child && child.type === "export_specifier") {
+          const identifier = findChildByType(child, "identifier");
+          if (identifier) {
+            exportedNames.push(identifier.text);
+          }
+        }
+      }
+      const currentSymbolId = getCurrentSymbolId(context);
+      const startLine = node.startPosition.row + 1;
+      const endLine = node.endPosition.row + 1;
+      for (const exportedName of exportedNames) {
+        const symbolId = `${context.filePath}::${exportedName}`;
+        context.symbols.push({
+          id: symbolId,
+          name: exportedName,
+          kind: "export",
+          filePath: context.filePath,
+          startLine,
+          endLine,
+          exported: true
+        });
+        const targetId = `${resolvedPath}::${exportedName}`;
+        context.edges.push({
+          source: symbolId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: startLine
+        });
+      }
+    }
+  }
+}
+function processCallExpression(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let functionName = null;
+  if (functionNode.type === "identifier") {
+    functionName = functionNode.text;
+  } else if (functionNode.type === "member_expression") {
+    const property = functionNode.childForFieldName("property");
+    if (property) {
+      functionName = property.text;
+    }
+  }
+  if (functionName) {
+    const currentSymbolId = getCurrentSymbolId(context);
+    if (currentSymbolId) {
+      let targetId;
+      if (context.imports.has(functionName)) {
+        targetId = context.imports.get(functionName);
+      } else {
+        targetId = `${context.filePath}::${functionName}`;
+      }
+      context.edges.push({
+        source: currentSymbolId,
+        target: targetId,
+        kind: "calls",
+        filePath: context.filePath,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+}
+function processNewExpression(node, context) {
+  const classNode = node.child(1);
+  if (!classNode || classNode.type !== "identifier") return;
+  const className = classNode.text;
+  const currentSymbolId = getCurrentSymbolId(context);
+  if (currentSymbolId) {
+    const targetId = `${context.filePath}::${className}`;
+    context.edges.push({
+      source: currentSymbolId,
+      target: targetId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function isExported(node) {
+  if (!node) return false;
+  if (node.type === "export_statement") return true;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "export") return true;
+  }
+  return isExported(node.parent);
+}
+function findChildByType(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function getCurrentSymbolId(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join(".")}`;
+}
+var typescriptParser = {
+  name: "typescript",
+  extensions: [".ts", ".tsx"],
+  parseFile: parseTypeScriptFile
+};
+
+// src/parser/python.ts
+import Parser2 from "tree-sitter";
+import Python from "tree-sitter-python";
+import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var pyParser = new Parser2();
+pyParser.setLanguage(Python);
+function parsePythonFile(filePath, sourceCode, projectRoot) {
+  const tree = pyParser.parse(sourceCode);
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentClass: null,
+    imports: /* @__PURE__ */ new Map()
+  };
+  walkNode2(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode2(node, context) {
+  processNode2(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode2(child, context);
+    }
+  }
+}
+function processNode2(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_definition":
+      processFunctionDefinition(node, context);
+      break;
+    case "class_definition":
+      processClassDefinition(node, context);
+      break;
+    case "expression_statement":
+      processExpressionStatement(node, context);
+      break;
+    case "import_statement":
+      processImportStatement2(node, context);
+      break;
+    case "import_from_statement":
+      processImportFromStatement(node, context);
+      break;
+    case "decorated_definition":
+      processDecoratedDefinition(node, context);
+      break;
+    case "call":
+      processCallExpression2(node, context);
+      break;
+  }
+}
+function processFunctionDefinition(node, context) {
+  const nameNode = findChildByType2(node, "identifier");
+  if (!nameNode) return;
+  const name = nodeText(nameNode, context);
+  const isAsync = node.text.startsWith("async ");
+  const kind = context.currentClass ? "method" : "function";
+  const scope = context.currentClass || void 0;
+  const exported = context.currentScope.length === 0 && !context.currentClass;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind,
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+  context.currentScope.push(name);
+  const body = findChildByType2(node, "block");
+  if (body) {
+    walkNode2(body, context);
+  }
+  context.currentScope.pop();
+}
+function processClassDefinition(node, context) {
+  const nameNode = findChildByType2(node, "identifier");
+  if (!nameNode) return;
+  const name = nodeText(nameNode, context);
+  const exported = context.currentScope.length === 0;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  const argumentList = findChildByType2(node, "argument_list");
+  if (argumentList) {
+    for (let i = 0; i < argumentList.childCount; i++) {
+      const arg = argumentList.child(i);
+      if (arg && (arg.type === "identifier" || arg.type === "attribute")) {
+        const baseName = nodeText(arg, context);
+        const baseId = resolveSymbol(baseName, context);
+        if (baseId) {
+          context.edges.push({
+            source: symbolId,
+            target: baseId,
+            kind: "inherits",
+            filePath: context.filePath,
+            line: arg.startPosition.row + 1
+          });
+        }
+      }
+    }
+  }
+  const oldClass = context.currentClass;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = findChildByType2(node, "block");
+  if (body) {
+    walkNode2(body, context);
+  }
+  context.currentScope.pop();
+  context.currentClass = oldClass;
+}
+function processExpressionStatement(node, context) {
+  if (context.currentScope.length > 0) return;
+  const assignment = findChildByType2(node, "assignment");
+  if (!assignment) return;
+  const left = assignment.child(0);
+  if (!left || left.type !== "identifier") return;
+  const name = nodeText(left, context);
+  const isConstant = name === name.toUpperCase() && name.length > 1;
+  const kind = isConstant ? "constant" : "variable";
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind,
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+    // Module-level variables are exported
+  });
+}
+function processImportStatement2(node, context) {
+  const dottedName = findChildByType2(node, "dotted_name");
+  const identifier = findChildByType2(node, "identifier");
+  const moduleName = dottedName ? nodeText(dottedName, context) : identifier ? nodeText(identifier, context) : null;
+  if (!moduleName) return;
+  const aliasedImport = findChildByType2(node, "aliased_import");
+  let importedName = moduleName;
+  if (aliasedImport) {
+    const asNode = aliasedImport.childForFieldName("alias");
+    if (asNode) {
+      importedName = nodeText(asNode, context);
+    }
+  }
+  const resolvedPath = resolveImportPath2(moduleName, context.filePath, context.projectRoot);
+  if (resolvedPath) {
+    const targetId = `${resolvedPath}::__module__`;
+    const sourceId = `${context.filePath}::__file__`;
+    context.imports.set(importedName, targetId);
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processImportFromStatement(node, context) {
+  const moduleNode = node.childForFieldName("module_name");
+  if (!moduleNode) return;
+  const moduleName = nodeText(moduleNode, context);
+  const importedNames = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "dotted_name" || child.type === "identifier") {
+      const prevSibling = node.child(i - 1);
+      if (prevSibling && prevSibling.text === "import") {
+        importedNames.push(nodeText(child, context));
+      }
+    }
+    if (child.type === "aliased_import") {
+      const nameNode = child.childForFieldName("name");
+      if (nameNode) {
+        importedNames.push(nodeText(nameNode, context));
+      }
+    }
+  }
+  const resolvedPath = resolveImportPath2(moduleName, context.filePath, context.projectRoot);
+  if (resolvedPath) {
+    const sourceId = `${context.filePath}::__file__`;
+    for (const importedName of importedNames) {
+      if (importedName === "*") continue;
+      const targetId = `${resolvedPath}::${importedName}`;
+      context.imports.set(importedName, targetId);
+      context.edges.push({
+        source: sourceId,
+        target: targetId,
+        kind: "imports",
+        filePath: context.filePath,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+}
+function processDecoratedDefinition(node, context) {
+  const decorators = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "decorator") {
+      const decoratorName = extractDecoratorName(child, context);
+      if (decoratorName) {
+        decorators.push(decoratorName);
+      }
+    }
+  }
+  const definition = findChildByType2(node, "function_definition") || findChildByType2(node, "class_definition");
+  if (definition) {
+    processNode2(definition, context);
+    const nameNode = findChildByType2(definition, "identifier");
+    if (nameNode) {
+      const targetName = nodeText(nameNode, context);
+      const targetId = `${context.filePath}::${targetName}`;
+      for (const decoratorName of decorators) {
+        const decoratorId = resolveSymbol(decoratorName, context);
+        if (decoratorId) {
+          context.edges.push({
+            source: decoratorId,
+            target: targetId,
+            kind: "decorates",
+            filePath: context.filePath,
+            line: node.startPosition.row + 1
+          });
+        }
+      }
+    }
+  }
+}
+function processCallExpression2(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let calleeName;
+  if (functionNode.type === "identifier") {
+    calleeName = nodeText(functionNode, context);
+  } else if (functionNode.type === "attribute") {
+    const attrNode = functionNode.childForFieldName("attribute");
+    if (!attrNode) return;
+    calleeName = nodeText(attrNode, context);
+  } else {
+    return;
+  }
+  const builtins = ["print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "enumerate", "zip", "map", "filter", "open", "type", "isinstance", "hasattr", "getattr", "setattr"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId2(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function resolveImportPath2(moduleName, currentFile, projectRoot) {
+  if (moduleName.startsWith(".")) {
+    const currentDir = dirname2(join3(projectRoot, currentFile));
+    let level = 0;
+    while (moduleName[level] === ".") level++;
+    let targetDir = currentDir;
+    for (let i = 0; i < level - 1; i++) {
+      targetDir = dirname2(targetDir);
+    }
+    const relativeModule = moduleName.substring(level);
+    if (relativeModule) {
+      const modulePath2 = relativeModule.replace(/\./g, "/");
+      const candidates2 = [
+        join3(targetDir, `${modulePath2}.py`),
+        join3(targetDir, modulePath2, "__init__.py")
+      ];
+      for (const candidate of candidates2) {
+        if (existsSync2(candidate)) {
+          return candidate.substring(projectRoot.length + 1);
+        }
+      }
+    } else {
+      const initPath = join3(targetDir, "__init__.py");
+      if (existsSync2(initPath)) {
+        return initPath.substring(projectRoot.length + 1);
+      }
+    }
+    return null;
+  }
+  const modulePath = moduleName.replace(/\./g, "/");
+  const candidates = [
+    join3(projectRoot, `${modulePath}.py`),
+    join3(projectRoot, modulePath, "__init__.py")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      return candidate.substring(projectRoot.length + 1);
+    }
+  }
+  return null;
+}
+function resolveSymbol(name, context) {
+  if (context.imports.has(name)) {
+    return context.imports.get(name) || null;
+  }
+  const currentFileId = `${context.filePath}::${name}`;
+  const symbol = context.symbols.find((s) => s.id === currentFileId);
+  if (symbol) {
+    return currentFileId;
+  }
+  if (context.currentClass) {
+    const classMethodId = `${context.filePath}::${context.currentClass}.${name}`;
+    const classMethod = context.symbols.find((s) => s.id === classMethodId);
+    if (classMethod) {
+      return classMethodId;
+    }
+  }
+  return null;
+}
+function extractDecoratorName(node, context) {
+  const identifier = findChildByType2(node, "identifier");
+  const attribute = findChildByType2(node, "attribute");
+  if (attribute) {
+    return nodeText(attribute, context);
+  } else if (identifier) {
+    return nodeText(identifier, context);
+  }
+  return null;
+}
+function findChildByType2(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function nodeText(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId2(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join(".")}`;
+}
+var pythonParser = {
+  name: "python",
+  extensions: [".py"],
+  parseFile: parsePythonFile
+};
+
+// src/parser/javascript.ts
+import Parser3 from "tree-sitter";
+import JavaScript from "tree-sitter-javascript";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4, dirname as dirname3, extname as extname2 } from "path";
+var jsParser = new Parser3();
+jsParser.setLanguage(JavaScript);
+function parseJavaScriptFile(filePath, sourceCode, projectRoot) {
+  const tree = jsParser.parse(sourceCode);
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    imports: /* @__PURE__ */ new Map(),
+    isJSX: filePath.endsWith(".jsx")
+  };
+  walkNode3(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode3(node, context) {
+  processNode3(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode3(child, context);
+    }
+  }
+}
+function processNode3(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_declaration":
+      processFunctionDeclaration2(node, context);
+      break;
+    case "function":
+      processFunctionExpression(node, context);
+      break;
+    case "class_declaration":
+      processClassDeclaration2(node, context);
+      break;
+    case "method_definition":
+      processMethodDefinition2(node, context);
+      break;
+    case "lexical_declaration":
+    case "variable_declaration":
+      processVariableDeclaration2(node, context);
+      break;
+    case "import_statement":
+      processImportStatement3(node, context);
+      break;
+    case "export_statement":
+      processExportStatement2(node, context);
+      break;
+    case "call_expression":
+      processCallExpression3(node, context);
+      break;
+    case "new_expression":
+      processNewExpression2(node, context);
+      break;
+    case "jsx_element":
+    case "jsx_self_closing_element":
+      if (context.isJSX) {
+        processJSXElement(node, context);
+      }
+      break;
+  }
+}
+function processFunctionDeclaration2(node, context) {
+  const nameNode = findChildByType3(node, "identifier");
+  if (!nameNode) return;
+  const name = nodeText2(nameNode, context);
+  const exported = isExported2(node.parent);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  context.currentScope.push(name);
+  const body = findChildByType3(node, "statement_block");
+  if (body) {
+    walkNode3(body, context);
+  }
+  context.currentScope.pop();
+}
+function processFunctionExpression(node, context) {
+  if (node.parent && node.parent.type === "variable_declarator") {
+    const nameNode = node.parent.childForFieldName("name");
+    if (nameNode && nameNode.type === "identifier") {
+      const name = nodeText2(nameNode, context);
+      const exported = isExported2(node.parent.parent?.parent || null);
+      const symbolId = `${context.filePath}::${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "function",
+        filePath: context.filePath,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        exported
+      });
+      context.currentScope.push(name);
+      const body = findChildByType3(node, "statement_block");
+      if (body) {
+        walkNode3(body, context);
+      }
+      context.currentScope.pop();
+    }
+  }
+}
+function processClassDeclaration2(node, context) {
+  const nameNode = findChildByType3(node, "identifier");
+  if (!nameNode) return;
+  const name = nodeText2(nameNode, context);
+  const exported = isExported2(node.parent);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  const heritage = node.childForFieldName("heritage");
+  if (heritage) {
+    for (let i = 0; i < heritage.childCount; i++) {
+      const child = heritage.child(i);
+      if (child && child.type === "extends_clause") {
+        const baseClass = findChildByType3(child, "identifier");
+        if (baseClass) {
+          const baseName = nodeText2(baseClass, context);
+          const baseId = resolveSymbol2(baseName, context);
+          if (baseId) {
+            context.edges.push({
+              source: symbolId,
+              target: baseId,
+              kind: "extends",
+              filePath: context.filePath,
+              line: child.startPosition.row + 1
+            });
+          }
+        }
+      }
+    }
+  }
+  context.currentScope.push(name);
+  const body = findChildByType3(node, "class_body");
+  if (body) {
+    walkNode3(body, context);
+  }
+  context.currentScope.pop();
+}
+function processMethodDefinition2(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText2(nameNode, context);
+  const scope = context.currentScope.length > 0 ? context.currentScope[context.currentScope.length - 1] : void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: false,
+    scope
+  });
+  context.currentScope.push(name);
+  const body = findChildByType3(node, "statement_block");
+  if (body) {
+    walkNode3(body, context);
+  }
+  context.currentScope.pop();
+}
+function processVariableDeclaration2(node, context) {
+  const declarators = node.children.filter((c) => c.type === "variable_declarator");
+  for (const declarator of declarators) {
+    const nameNode = declarator.childForFieldName("name");
+    const valueNode = declarator.childForFieldName("value");
+    if (!nameNode) continue;
+    if (valueNode && valueNode.type === "call_expression") {
+      const functionNode = valueNode.childForFieldName("function");
+      if (functionNode && nodeText2(functionNode, context) === "require") {
+        processRequireCall(declarator, valueNode, context);
+        continue;
+      }
+    }
+    if (context.currentScope.length === 0) {
+      const name = extractIdentifierName(nameNode, context);
+      if (name) {
+        const exported = isExported2(node.parent);
+        const symbolId = `${context.filePath}::${name}`;
+        context.symbols.push({
+          id: symbolId,
+          name,
+          kind: "variable",
+          filePath: context.filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          exported
+        });
+      }
+    }
+  }
+}
+function processRequireCall(declarator, callNode, context) {
+  const nameNode = declarator.childForFieldName("name");
+  const args = callNode.childForFieldName("arguments");
+  if (!args) return;
+  const stringArg = findChildByType3(args, "string");
+  if (!stringArg) return;
+  const modulePath = nodeText2(stringArg, context).slice(1, -1);
+  const resolvedPath = resolveJavaScriptImport(modulePath, context.filePath, context.projectRoot);
+  if (!resolvedPath) return;
+  if (nameNode) {
+    if (nameNode.type === "identifier") {
+      const name = nodeText2(nameNode, context);
+      const targetId = `${resolvedPath}::${name}`;
+      const sourceId = `${context.filePath}::__file__`;
+      context.imports.set(name, targetId);
+      context.edges.push({
+        source: sourceId,
+        target: targetId,
+        kind: "imports",
+        filePath: context.filePath,
+        line: callNode.startPosition.row + 1
+      });
+    } else if (nameNode.type === "object_pattern") {
+      const properties = nameNode.children.filter((c) => c.type === "pair_pattern" || c.type === "shorthand_property_identifier_pattern");
+      for (const prop of properties) {
+        let importedName;
+        if (prop.type === "shorthand_property_identifier_pattern") {
+          importedName = nodeText2(prop, context);
+        } else {
+          const keyNode = prop.childForFieldName("key");
+          if (keyNode) {
+            importedName = nodeText2(keyNode, context);
+          } else {
+            continue;
+          }
+        }
+        const targetId = `${resolvedPath}::${importedName}`;
+        const sourceId = `${context.filePath}::__file__`;
+        context.imports.set(importedName, targetId);
+        context.edges.push({
+          source: sourceId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: callNode.startPosition.row + 1
+        });
+      }
+    }
+  }
+}
+function processImportStatement3(node, context) {
+  const source = node.childForFieldName("source");
+  if (!source) return;
+  const importPath = nodeText2(source, context).slice(1, -1);
+  const resolvedPath = resolveJavaScriptImport(importPath, context.filePath, context.projectRoot);
+  if (!resolvedPath) return;
+  const importClause = findChildByType3(node, "import_clause");
+  if (!importClause) {
+    return;
+  }
+  const namedImports = findChildByType3(importClause, "named_imports");
+  const defaultImport = findChildByType3(importClause, "identifier");
+  const namespaceImport = findChildByType3(importClause, "namespace_import");
+  const sourceId = `${context.filePath}::__file__`;
+  if (defaultImport) {
+    const name = nodeText2(defaultImport, context);
+    const targetId = `${resolvedPath}::default`;
+    context.imports.set(name, targetId);
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+  if (namedImports) {
+    const specifiers = namedImports.children.filter((c) => c.type === "import_specifier");
+    for (const specifier of specifiers) {
+      const nameNode = specifier.childForFieldName("name");
+      const aliasNode = specifier.childForFieldName("alias");
+      if (nameNode) {
+        const importedName = nodeText2(nameNode, context);
+        const localName = aliasNode ? nodeText2(aliasNode, context) : importedName;
+        const targetId = `${resolvedPath}::${importedName}`;
+        context.imports.set(localName, targetId);
+        context.edges.push({
+          source: sourceId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: node.startPosition.row + 1
+        });
+      }
+    }
+  }
+  if (namespaceImport) {
+    const aliasNode = findChildByType3(namespaceImport, "identifier");
+    if (aliasNode) {
+      const localName = nodeText2(aliasNode, context);
+      const targetId = `${resolvedPath}::*`;
+      context.imports.set(localName, targetId);
+      context.edges.push({
+        source: sourceId,
+        target: targetId,
+        kind: "imports",
+        filePath: context.filePath,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+}
+function processExportStatement2(node, context) {
+  const declaration = findChildByType3(node, "lexical_declaration") || findChildByType3(node, "variable_declaration") || findChildByType3(node, "function_declaration") || findChildByType3(node, "class_declaration");
+  if (declaration) {
+    processNode3(declaration, context);
+  }
+}
+function processCallExpression3(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let calleeName = null;
+  if (functionNode.type === "identifier") {
+    calleeName = nodeText2(functionNode, context);
+  } else if (functionNode.type === "member_expression") {
+    const property = functionNode.childForFieldName("property");
+    if (property) {
+      calleeName = nodeText2(property, context);
+    }
+  }
+  if (!calleeName) return;
+  const builtins = ["console", "require", "setTimeout", "setInterval", "parseInt", "parseFloat", "JSON", "Object", "Array", "String", "Number", "Boolean"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId3(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol2(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processNewExpression2(node, context) {
+  const constructorNode = findChildByType3(node, "identifier");
+  if (!constructorNode) return;
+  const className = nodeText2(constructorNode, context);
+  const callerId = getCurrentSymbolId3(context);
+  if (!callerId) return;
+  const classId = resolveSymbol2(className, context);
+  if (classId) {
+    context.edges.push({
+      source: callerId,
+      target: classId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processJSXElement(node, context) {
+  let tagName = null;
+  if (node.type === "jsx_self_closing_element") {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) {
+      tagName = nodeText2(nameNode, context);
+    }
+  } else if (node.type === "jsx_element") {
+    const openingElement = findChildByType3(node, "jsx_opening_element");
+    if (openingElement) {
+      const nameNode = openingElement.childForFieldName("name");
+      if (nameNode) {
+        tagName = nodeText2(nameNode, context);
+      }
+    }
+  }
+  if (!tagName) return;
+  if (!/^[A-Z]/.test(tagName)) return;
+  const callerId = getCurrentSymbolId3(context);
+  if (!callerId) return;
+  const componentId = resolveSymbol2(tagName, context);
+  if (componentId) {
+    context.edges.push({
+      source: callerId,
+      target: componentId,
+      kind: "references",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function resolveJavaScriptImport(importPath, currentFile, projectRoot) {
+  if (importPath.startsWith(".")) {
+    const currentDir = dirname3(join4(projectRoot, currentFile));
+    const targetPath = join4(currentDir, importPath);
+    const extensions = [".js", ".jsx", ".mjs", ".cjs"];
+    const indexFiles = ["index.js", "index.jsx", "index.mjs"];
+    if (extname2(importPath)) {
+      const fullPath = targetPath;
+      if (existsSync3(fullPath)) {
+        return fullPath.substring(projectRoot.length + 1);
+      }
+      return null;
+    }
+    for (const ext of extensions) {
+      const candidate = `${targetPath}${ext}`;
+      if (existsSync3(candidate)) {
+        return candidate.substring(projectRoot.length + 1);
+      }
+    }
+    for (const indexFile of indexFiles) {
+      const candidate = join4(targetPath, indexFile);
+      if (existsSync3(candidate)) {
+        return candidate.substring(projectRoot.length + 1);
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function resolveSymbol2(name, context) {
+  if (context.imports.has(name)) {
+    return context.imports.get(name) || null;
+  }
+  const currentFileId = `${context.filePath}::${name}`;
+  const symbol = context.symbols.find((s) => s.id === currentFileId);
+  if (symbol) {
+    return currentFileId;
+  }
+  if (context.currentScope.length > 0) {
+    const scopedId = `${context.filePath}::${context.currentScope.join(".")}.${name}`;
+    const scopedSymbol = context.symbols.find((s) => s.id === scopedId);
+    if (scopedSymbol) {
+      return scopedId;
+    }
+  }
+  return null;
+}
+function isExported2(node) {
+  if (!node) return false;
+  let current = node;
+  while (current) {
+    if (current.type === "export_statement") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function extractIdentifierName(node, context) {
+  if (node.type === "identifier") {
+    return nodeText2(node, context);
+  } else if (node.type === "object_pattern") {
+    const properties = node.children.filter((c) => c.type === "shorthand_property_identifier_pattern");
+    if (properties.length > 0) {
+      return nodeText2(properties[0], context);
+    }
+  }
+  return null;
+}
+function findChildByType3(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function nodeText2(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId3(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join(".")}`;
+}
+var javascriptParser = {
+  name: "javascript",
+  extensions: [".js", ".jsx", ".mjs", ".cjs"],
+  parseFile: parseJavaScriptFile
+};
+
+// src/parser/go.ts
+import Parser4 from "tree-sitter";
+import Go from "tree-sitter-go";
+import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
+var parser = new Parser4();
+parser.setLanguage(Go);
+function parseGoFile(filePath, sourceCode, projectRoot) {
+  const tree = parser.parse(sourceCode);
+  const moduleName = readGoModuleName(projectRoot);
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    packageName: "",
+    imports: /* @__PURE__ */ new Map(),
+    moduleName
+  };
+  extractPackageName(tree.rootNode, context);
+  walkNode4(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function extractPackageName(node, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "package_clause") {
+      const pkgIdentifier = findChildByType4(child, "package_identifier");
+      if (pkgIdentifier) {
+        context.packageName = nodeText3(pkgIdentifier, context);
+      }
+      break;
+    }
+  }
+}
+function walkNode4(node, context) {
+  processNode4(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode4(child, context);
+    }
+  }
+}
+function processNode4(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_declaration":
+      processFunctionDeclaration3(node, context);
+      break;
+    case "method_declaration":
+      processMethodDeclaration(node, context);
+      break;
+    case "type_declaration":
+      processTypeDeclaration(node, context);
+      break;
+    case "const_declaration":
+      processConstDeclaration(node, context);
+      break;
+    case "var_declaration":
+      processVarDeclaration(node, context);
+      break;
+    case "import_declaration":
+      processImportDeclaration(node, context);
+      break;
+    case "call_expression":
+      processCallExpression4(node, context);
+      break;
+  }
+}
+function processFunctionDeclaration3(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText3(nameNode, context);
+  const exported = isExported3(name);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode4(body, context);
+  }
+  context.currentScope.pop();
+}
+function processMethodDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  const receiverNode = node.childForFieldName("receiver");
+  if (!nameNode || !receiverNode) return;
+  const name = nodeText3(nameNode, context);
+  const receiverType = extractReceiverType(receiverNode, context);
+  if (!receiverType) return;
+  const exported = isExported3(name);
+  const symbolId = `${context.filePath}::${receiverType}.${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope: receiverType
+  });
+  context.currentScope.push(`${receiverType}.${name}`);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode4(body, context);
+  }
+  context.currentScope.pop();
+}
+function processTypeDeclaration(node, context) {
+  const typeSpecs = findChildrenByType(node, "type_spec");
+  for (const typeSpec of typeSpecs) {
+    const nameNode = typeSpec.childForFieldName("name");
+    const typeNode = typeSpec.childForFieldName("type");
+    if (!nameNode || !typeNode) continue;
+    const name = nodeText3(nameNode, context);
+    const exported = isExported3(name);
+    let kind = "type_alias";
+    if (typeNode.type === "struct_type") {
+      kind = "class";
+      const fieldList = findChildByType4(typeNode, "field_declaration_list");
+      if (fieldList) {
+        for (let i = 0; i < fieldList.childCount; i++) {
+          const field = fieldList.child(i);
+          if (field && field.type === "field_declaration") {
+            const fieldName = field.childForFieldName("name");
+            const fieldType = field.childForFieldName("type");
+            if (!fieldName && fieldType) {
+              const embeddedTypeName = extractTypeName(fieldType, context);
+              if (embeddedTypeName) {
+                const embeddedId = resolveSymbol3(embeddedTypeName, context);
+                if (embeddedId) {
+                  const symbolId2 = `${context.filePath}::${name}`;
+                  context.edges.push({
+                    source: symbolId2,
+                    target: embeddedId,
+                    kind: "inherits",
+                    filePath: context.filePath,
+                    line: field.startPosition.row + 1
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    } else if (typeNode.type === "interface_type") {
+      kind = "interface";
+    }
+    const symbolId = `${context.filePath}::${name}`;
+    context.symbols.push({
+      id: symbolId,
+      name,
+      kind,
+      filePath: context.filePath,
+      startLine: typeSpec.startPosition.row + 1,
+      endLine: typeSpec.endPosition.row + 1,
+      exported
+    });
+  }
+}
+function processConstDeclaration(node, context) {
+  const constSpecs = findChildrenByType(node, "const_spec");
+  for (const constSpec of constSpecs) {
+    const nameNode = constSpec.childForFieldName("name");
+    if (!nameNode) continue;
+    const names = extractIdentifierNames(nameNode, context);
+    for (const name of names) {
+      const exported = isExported3(name);
+      const symbolId = `${context.filePath}::${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "constant",
+        filePath: context.filePath,
+        startLine: constSpec.startPosition.row + 1,
+        endLine: constSpec.endPosition.row + 1,
+        exported
+      });
+    }
+  }
+}
+function processVarDeclaration(node, context) {
+  if (context.currentScope.length > 0) return;
+  const varSpecs = findChildrenByType(node, "var_spec");
+  for (const varSpec of varSpecs) {
+    const nameNode = varSpec.childForFieldName("name");
+    if (!nameNode) continue;
+    const names = extractIdentifierNames(nameNode, context);
+    for (const name of names) {
+      const exported = isExported3(name);
+      const symbolId = `${context.filePath}::${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "variable",
+        filePath: context.filePath,
+        startLine: varSpec.startPosition.row + 1,
+        endLine: varSpec.endPosition.row + 1,
+        exported
+      });
+    }
+  }
+}
+function processImportDeclaration(node, context) {
+  let importSpecs = [];
+  const importSpecList = findChildByType4(node, "import_spec_list");
+  if (importSpecList) {
+    importSpecs = findChildrenByType(importSpecList, "import_spec");
+  } else {
+    importSpecs = findChildrenByType(node, "import_spec");
+  }
+  for (const importSpec of importSpecs) {
+    const pathNode = importSpec.childForFieldName("path");
+    if (!pathNode) continue;
+    const importPath = nodeText3(pathNode, context).slice(1, -1);
+    const nameNode = importSpec.childForFieldName("name");
+    let alias = "";
+    if (nameNode) {
+      alias = nodeText3(nameNode, context);
+    } else {
+      const segments = importPath.split("/");
+      alias = segments[segments.length - 1];
+    }
+    context.imports.set(alias, importPath);
+    const resolvedFiles = resolveGoImport(importPath, context.projectRoot, context.moduleName);
+    if (resolvedFiles.length > 0) {
+      const sourceId = `${context.filePath}::__file__`;
+      for (const targetFile of resolvedFiles) {
+        const targetId = `${targetFile}::__file__`;
+        context.edges.push({
+          source: sourceId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: importSpec.startPosition.row + 1
+        });
+      }
+    }
+  }
+}
+function processCallExpression4(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let calleeName = null;
+  if (functionNode.type === "identifier") {
+    calleeName = nodeText3(functionNode, context);
+  } else if (functionNode.type === "selector_expression") {
+    const field = functionNode.childForFieldName("field");
+    if (field) {
+      calleeName = nodeText3(field, context);
+    }
+  }
+  if (!calleeName) return;
+  const builtins = ["make", "len", "cap", "append", "copy", "delete", "panic", "recover", "print", "println", "new"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId4(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol3(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function readGoModuleName(projectRoot) {
+  let currentDir = projectRoot;
+  for (let i = 0; i < 5; i++) {
+    const goModPath = join5(currentDir, "go.mod");
+    if (existsSync4(goModPath)) {
+      try {
+        const content = readFileSync2(goModPath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("module ")) {
+            return trimmed.substring(7).trim();
+          }
+        }
+      } catch (error) {
+        console.error(`Error reading go.mod: ${error}`);
+      }
+    }
+    const parentDir = dirname4(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+function resolveGoImport(importPath, projectRoot, moduleName) {
+  if (!importPath.includes(".") && !importPath.includes("/")) {
+    return [];
+  }
+  if (moduleName && importPath.startsWith(moduleName)) {
+    const relativePath = importPath.substring(moduleName.length + 1);
+    const packageDir2 = join5(projectRoot, relativePath);
+    return findGoFilesInDir(packageDir2, projectRoot);
+  }
+  const segments = importPath.split("/");
+  const packageDir = join5(projectRoot, ...segments);
+  if (existsSync4(packageDir)) {
+    return findGoFilesInDir(packageDir, projectRoot);
+  }
+  return [];
+}
+function findGoFilesInDir(dir, projectRoot) {
+  if (!existsSync4(dir)) return [];
+  try {
+    const files = readdirSync2(dir);
+    const goFiles = files.filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+    return goFiles.map((f) => {
+      const fullPath = join5(dir, f);
+      return fullPath.substring(projectRoot.length + 1);
+    });
+  } catch (error) {
+    console.error(`[findGoFilesInDir] Error:`, error);
+    return [];
+  }
+}
+function isExported3(name) {
+  return name.length > 0 && name[0] === name[0].toUpperCase();
+}
+function extractReceiverType(receiverNode, context) {
+  const paramDecl = findChildByType4(receiverNode, "parameter_declaration");
+  if (!paramDecl) return null;
+  const typeNode = paramDecl.childForFieldName("type");
+  if (!typeNode) return null;
+  return extractTypeName(typeNode, context);
+}
+function extractTypeName(typeNode, context) {
+  if (typeNode.type === "pointer_type") {
+    for (let i = 0; i < typeNode.childCount; i++) {
+      const child = typeNode.child(i);
+      if (child && child.type === "type_identifier") {
+        return nodeText3(child, context);
+      }
+    }
+    return null;
+  } else if (typeNode.type === "type_identifier") {
+    return nodeText3(typeNode, context);
+  }
+  return null;
+}
+function extractIdentifierNames(node, context) {
+  if (node.type === "identifier") {
+    return [nodeText3(node, context)];
+  } else if (node.type === "identifier_list") {
+    const names = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && child.type === "identifier") {
+        names.push(nodeText3(child, context));
+      }
+    }
+    return names;
+  }
+  return [];
+}
+function resolveSymbol3(name, context) {
+  const currentFileId = `${context.filePath}::${name}`;
+  const symbol = context.symbols.find((s) => s.id === currentFileId);
+  if (symbol) {
+    return currentFileId;
+  }
+  if (context.currentScope.length > 0) {
+    for (let i = context.currentScope.length - 1; i >= 0; i--) {
+      const scopedId = `${context.filePath}::${context.currentScope[i]}.${name}`;
+      const scopedSymbol = context.symbols.find((s) => s.id === scopedId);
+      if (scopedSymbol) {
+        return scopedId;
+      }
+    }
+  }
+  return null;
+}
+function findChildByType4(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function findChildrenByType(node, type) {
+  const results = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      results.push(child);
+    }
+  }
+  return results;
+}
+function nodeText3(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId4(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope[context.currentScope.length - 1]}`;
+}
+var goParser = {
+  name: "go",
+  extensions: [".go"],
+  parseFile: parseGoFile
+};
+
+// src/parser/detect.ts
+var parsers = [
+  typescriptParser,
+  pythonParser,
+  javascriptParser,
+  goParser
+];
+function getParserForFile(filePath) {
+  const ext = extname3(filePath).toLowerCase();
+  return parsers.find((p) => p.extensions.includes(ext)) || null;
+}
+
+// src/parser/index.ts
+var MAX_FILE_SIZE = 1e6;
+function shouldParseFile(fullPath) {
+  try {
+    const stats = statSync2(fullPath);
+    if (stats.size > MAX_FILE_SIZE) {
+      console.error(`[Parser] Skipping ${fullPath} \u2014 file too large (${(stats.size / 1024).toFixed(0)}KB)`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function parseProject(projectRoot) {
+  const files = scanDirectory(projectRoot);
+  const parsedFiles = [];
+  for (const file of files) {
+    try {
+      const fullPath = join6(projectRoot, file);
+      if (!shouldParseFile(fullPath)) {
+        continue;
+      }
+      const parser2 = getParserForFile(file);
+      if (!parser2) {
+        console.error(`No parser found for file: ${file}`);
+        continue;
+      }
+      const sourceCode = readFileSync3(fullPath, "utf-8");
+      const parsed = parser2.parseFile(file, sourceCode, projectRoot);
+      parsedFiles.push(parsed);
+    } catch (err) {
+      console.error(`Error parsing file ${file}:`, err instanceof Error ? err.message : err);
+    }
+  }
+  return parsedFiles;
+}
+
+// src/graph/index.ts
+import { DirectedGraph } from "graphology";
+function buildGraph(parsedFiles) {
+  const graph = new DirectedGraph();
+  for (const file of parsedFiles) {
+    for (const symbol of file.symbols) {
+      if (!graph.hasNode(symbol.id)) {
+        graph.addNode(symbol.id, {
+          name: symbol.name,
+          kind: symbol.kind,
+          filePath: symbol.filePath,
+          startLine: symbol.startLine,
+          endLine: symbol.endLine,
+          exported: symbol.exported,
+          scope: symbol.scope
+        });
+      }
+    }
+  }
+  const fileNodes = /* @__PURE__ */ new Set();
+  for (const file of parsedFiles) {
+    for (const edge of file.edges) {
+      if (edge.source.endsWith("::__file__") && !fileNodes.has(edge.source)) {
+        fileNodes.add(edge.source);
+        const filePath = edge.source.replace("::__file__", "");
+        graph.addNode(edge.source, {
+          name: "__file__",
+          kind: "import",
+          filePath,
+          startLine: 1,
+          endLine: 1,
+          exported: false
+        });
+      }
+    }
+  }
+  for (const file of parsedFiles) {
+    for (const edge of file.edges) {
+      if (graph.hasNode(edge.source) && graph.hasNode(edge.target)) {
+        graph.mergeEdge(edge.source, edge.target, {
+          kind: edge.kind,
+          filePath: edge.filePath,
+          line: edge.line
+        });
+      }
+    }
+  }
+  return graph;
+}
+
+// src/graph/queries.ts
+function getDependencies(graph, symbolId) {
+  if (!graph.hasNode(symbolId)) return [];
+  const dependencies = [];
+  const neighbors = graph.outNeighbors(symbolId);
+  for (const neighborId of neighbors) {
+    const attrs = graph.getNodeAttributes(neighborId);
+    dependencies.push({
+      id: neighborId,
+      name: attrs.name,
+      kind: attrs.kind,
+      filePath: attrs.filePath,
+      startLine: attrs.startLine,
+      endLine: attrs.endLine,
+      exported: attrs.exported,
+      scope: attrs.scope
+    });
+  }
+  return dependencies;
+}
+function getDependents(graph, symbolId) {
+  if (!graph.hasNode(symbolId)) return [];
+  const dependents = [];
+  const neighbors = graph.inNeighbors(symbolId);
+  for (const neighborId of neighbors) {
+    const attrs = graph.getNodeAttributes(neighborId);
+    dependents.push({
+      id: neighborId,
+      name: attrs.name,
+      kind: attrs.kind,
+      filePath: attrs.filePath,
+      startLine: attrs.startLine,
+      endLine: attrs.endLine,
+      exported: attrs.exported,
+      scope: attrs.scope
+    });
+  }
+  return dependents;
+}
+function getImpact(graph, symbolId) {
+  if (!graph.hasNode(symbolId)) {
+    return {
+      directDependents: [],
+      transitiveDependents: [],
+      affectedFiles: []
+    };
+  }
+  const directDependents = getDependents(graph, symbolId);
+  const visited = /* @__PURE__ */ new Set([symbolId]);
+  const queue = [symbolId];
+  const allDependents = [];
+  const fileSet = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const neighbors = graph.inNeighbors(current);
+    for (const neighborId of neighbors) {
+      if (!visited.has(neighborId)) {
+        visited.add(neighborId);
+        queue.push(neighborId);
+        const attrs = graph.getNodeAttributes(neighborId);
+        allDependents.push({
+          id: neighborId,
+          name: attrs.name,
+          kind: attrs.kind,
+          filePath: attrs.filePath,
+          startLine: attrs.startLine,
+          endLine: attrs.endLine,
+          exported: attrs.exported,
+          scope: attrs.scope
+        });
+        fileSet.add(attrs.filePath);
+      }
+    }
+  }
+  return {
+    directDependents,
+    transitiveDependents: allDependents,
+    affectedFiles: Array.from(fileSet).sort()
+  };
+}
+function getCrossFileEdges(graph) {
+  const crossFileEdges = [];
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceAttrs = graph.getNodeAttributes(source);
+    const targetAttrs = graph.getNodeAttributes(target);
+    if (sourceAttrs.filePath !== targetAttrs.filePath) {
+      crossFileEdges.push({
+        source,
+        target,
+        sourceFile: sourceAttrs.filePath,
+        targetFile: targetAttrs.filePath,
+        kind: attrs.kind
+      });
+    }
+  });
+  return crossFileEdges;
+}
+function getFileSummary(graph) {
+  const fileMap = /* @__PURE__ */ new Map();
+  graph.forEachNode((node, attrs) => {
+    if (!fileMap.has(attrs.filePath)) {
+      fileMap.set(attrs.filePath, {
+        symbolCount: 0,
+        incomingRefs: /* @__PURE__ */ new Set(),
+        outgoingRefs: /* @__PURE__ */ new Set()
+      });
+    }
+    fileMap.get(attrs.filePath).symbolCount++;
+  });
+  graph.forEachEdge((edge, attrs, source, target) => {
+    const sourceAttrs = graph.getNodeAttributes(source);
+    const targetAttrs = graph.getNodeAttributes(target);
+    if (sourceAttrs.filePath !== targetAttrs.filePath) {
+      const sourceFile = fileMap.get(sourceAttrs.filePath);
+      const targetFile = fileMap.get(targetAttrs.filePath);
+      if (sourceFile) {
+        sourceFile.outgoingRefs.add(targetAttrs.filePath);
+      }
+      if (targetFile) {
+        targetFile.incomingRefs.add(sourceAttrs.filePath);
+      }
+    }
+  });
+  const result = [];
+  for (const [filePath, data] of fileMap.entries()) {
+    result.push({
+      filePath,
+      symbolCount: data.symbolCount,
+      incomingRefs: data.incomingRefs.size,
+      outgoingRefs: data.outgoingRefs.size
+    });
+  }
+  return result.sort((a, b) => a.filePath.localeCompare(b.filePath));
+}
+function searchSymbols(graph, query) {
+  const queryLower = query.toLowerCase();
+  const results = [];
+  graph.forEachNode((nodeId, attrs) => {
+    if (attrs.name.toLowerCase().includes(queryLower)) {
+      results.push({
+        id: nodeId,
+        name: attrs.name,
+        kind: attrs.kind,
+        filePath: attrs.filePath,
+        startLine: attrs.startLine,
+        endLine: attrs.endLine,
+        exported: attrs.exported,
+        scope: attrs.scope
+      });
+    }
+  });
+  return results;
+}
+function getArchitectureSummary(graph) {
+  const fileSummary = getFileSummary(graph);
+  const fileSet = /* @__PURE__ */ new Set();
+  graph.forEachNode((node, attrs) => {
+    fileSet.add(attrs.filePath);
+  });
+  const fileConnections = fileSummary.map((f) => ({
+    filePath: f.filePath,
+    connections: f.incomingRefs + f.outgoingRefs
+  }));
+  fileConnections.sort((a, b) => b.connections - a.connections);
+  const orphanFiles = fileSummary.filter((f) => f.incomingRefs === 0 && f.outgoingRefs === 0).map((f) => f.filePath);
+  return {
+    fileCount: fileSet.size,
+    symbolCount: graph.order,
+    edgeCount: graph.size,
+    mostConnectedFiles: fileConnections.slice(0, 5),
+    orphanFiles
+  };
+}
+
+// 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 watcher = chokidar.watch(projectRoot, {
+    ignored: [
+      "**/node_modules/**",
+      "**/vendor/**",
+      // Go dependencies
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.turbo/**",
+      "**/.*"
+      // Hidden files and directories
+    ],
+    ignoreInitial: true,
+    // Don't fire events for existing files
+    persistent: true,
+    followSymlinks: false,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      // Wait 300ms after last change before firing
+      pollInterval: 100
+    }
+  });
+  console.error("[Watcher] Attaching event listeners...");
+  watcher.on("change", (absolutePath) => {
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    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"];
+    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"];
+    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")
+      ).length;
+    }
+    console.error(`[Watcher] Watching ${fileCount} TypeScript/JavaScript/Python/Go files in ${dirs.length} directories`);
+  });
+  watcher.on("all", (event, path) => {
+    console.error(`[Watcher] ALL event: ${event} ${path}`);
+  });
+  return watcher;
+}
+
+// src/viz/server.ts
+import express from "express";
+import open from "open";
+import { fileURLToPath } from "url";
+import { dirname as dirname5, join as join7 } from "path";
+import { WebSocketServer } from "ws";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname5(__filename);
+var activeServer = null;
+function startVizServer(initialVizData, graph, projectRoot, port = 3333, shouldOpen = true) {
+  if (activeServer) {
+    console.error(`Visualization server already running at ${activeServer.url}`);
+    return {
+      server: activeServer.server,
+      url: activeServer.url,
+      alreadyRunning: true
+    };
+  }
+  const app = express();
+  let vizData = initialVizData;
+  const publicDir = join7(__dirname, "viz", "public");
+  app.use(express.static(publicDir));
+  app.get("/api/graph", (req, res) => {
+    res.json(vizData);
+  });
+  const server = app.listen(port, "127.0.0.1", () => {
+    const url2 = `http://127.0.0.1:${port}`;
+    console.error(`
+Depwire visualization running at ${url2}`);
+    console.error("Press Ctrl+C to stop\n");
+    activeServer = { server, port, 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 = parseProject(projectRoot);
+        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 = parseProject(projectRoot);
+        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: (filePath) => {
+      console.error(`File deleted: ${filePath} \u2014 re-parsing project...`);
+      try {
+        const parsedFiles = parseProject(projectRoot);
+        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:${port}`;
+  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 join8 } 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 = join8(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 dirname6 } from "path";
+
+// src/mcp/connect.ts
+import simpleGit from "simple-git";
+import { existsSync as existsSync5 } from "fs";
+import { join as join9, basename as basename2, 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",
+    join9(homedir(), ".ssh"),
+    join9(homedir(), ".gnupg"),
+    join9(homedir(), ".aws"),
+    join9(homedir(), ".config"),
+    join9(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 = join9(tmpdir(), "depwire-repos");
+      const cloneDir = join9(reposDir, projectName);
+      console.error(`Connecting to GitHub repo: ${source}`);
+      const git = simpleGit();
+      if (existsSync5(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 ? join9(cloneDir, subdirectory) : cloneDir;
+    } else {
+      const validation2 = validateProjectPath(source);
+      if (!validation2.valid) {
+        return {
+          error: "Access denied",
+          message: validation2.error
+        };
+      }
+      if (!existsSync5(source)) {
+        return {
+          error: "Directory not found",
+          message: `Directory does not exist: ${source}`
+        };
+      }
+      projectRoot = subdirectory ? join9(source, subdirectory) : source;
+      projectName = basename2(projectRoot);
+    }
+    const validation = validateProjectPath(projectRoot);
+    if (!validation.valid) {
+      return {
+        error: "Access denied",
+        message: validation.error
+      };
+    }
+    if (!existsSync5(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/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. Returns file location, type, line numbers, and export status.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "The symbol name to look up (e.g., 'UserService', 'handleAuth')"
+          }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "get_dependencies",
+      description: "Get all symbols that a given symbol depends on (what does this symbol use/import/call?).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "Symbol name or ID to analyze"
+          }
+        },
+        required: ["symbol"]
+      }
+    },
+    {
+      name: "get_dependents",
+      description: "Get all symbols that depend on a given symbol (what uses this symbol?).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "Symbol name or ID to analyze"
+          }
+        },
+        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. Use this before making changes to understand the blast radius.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "The symbol name or ID to analyze"
+          }
+        },
+        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)"
+          }
+        }
+      }
+    }
+  ];
+}
+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 (!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);
+            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 handleGetSymbolInfo(name, graph) {
+  const matches = searchSymbols(graph, name);
+  const exactMatches = matches.filter((m) => m.name.toLowerCase() === name.toLowerCase());
+  const results = exactMatches.length > 0 ? exactMatches : matches.slice(0, 10);
+  return {
+    matches: results.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
+    })),
+    count: results.length
+  };
+}
+function handleGetDependencies(symbol, graph) {
+  const matches = searchSymbols(graph, symbol);
+  if (matches.length === 0) {
+    return {
+      error: `Symbol '${symbol}' not found`,
+      suggestion: "Try using search_symbols to find available symbols"
+    };
+  }
+  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.filePath}::${target.name}`,
+    dependencies: grouped,
+    totalCount
+  };
+}
+function handleGetDependents(symbol, graph) {
+  const matches = searchSymbols(graph, symbol);
+  if (matches.length === 0) {
+    return {
+      error: `Symbol '${symbol}' not found`,
+      suggestion: "Try using search_symbols to find available symbols"
+    };
+  }
+  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.filePath}::${target.name}`,
+    dependents: grouped,
+    totalCount
+  };
+}
+function handleImpactAnalysis(symbol, graph) {
+  const matches = searchSymbols(graph, symbol);
+  if (matches.length === 0) {
+    return {
+      error: `Symbol '${symbol}' not found`,
+      suggestion: "Try using search_symbols to find available symbols"
+    };
+  }
+  const target = matches[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: {
+      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("/") ? dirname6(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 } = 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 }]
+  };
+}
+
+// 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 {
+  parseProject,
+  buildGraph,
+  getImpact,
+  searchSymbols,
+  getArchitectureSummary,
+  prepareVizData,
+  watchProject,
+  startVizServer,
+  createEmptyState,
+  updateFileInGraph,
+  startMcpServer
+};