codeviz 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,9 +1,3026 @@
+import {
+  AggregateNode,
+  BundledEdge,
+  CallEdge,
+  CodeMap,
+  DEFAULT_ANIMATION_CONFIG,
+  DEFAULT_CODEMAP_CONFIG,
+  DEFAULT_DARK_SIGMA_THEME,
+  DEFAULT_LAYOUT_CONFIG,
+  DEFAULT_LIGHT_SIGMA_THEME,
+  DEFAULT_SIGMA_THEME,
+  DEFAULT_ZOOM_LEVELS,
+  EDGE_SIZES,
+  FileNode,
+  Flow,
+  ImportEdge,
+  NODE_SIZES,
+  OverlayLayer,
+  OverlayPort,
+  PortalOverlayLayer,
+  SVGOverlayLayer,
+  ScopeNode,
+  SigmaRenderer,
+  SymbolNode,
+  ThemeProvider,
+  assignClusterColors,
+  assignInitialPositions,
+  boundingBoxFromCorners,
+  boundingBoxesOverlap,
+  brightenColor,
+  buildDirectoryGraph,
+  calculateNodeSize,
+  calculateOverlayPosition,
+  clampPosition,
+  codeGraphToGraphology,
+  codeMapToReactFlowEdges,
+  codeMapToReactFlowNodes,
+  computeDirectoryForces,
+  computeEdges,
+  computeHierarchy,
+  computeLayout,
+  computeZoomLevels,
+  createBoundingBox,
+  createEdgeReducer,
+  createNodeReducer,
+  createOverlayPort,
+  createScopeColorGetter,
+  darkTheme,
+  darken,
+  detectCommunities,
+  detectLanguage,
+  dimColor,
+  distance,
+  edgeTypes,
+  expandBoundingBox,
+  formatLoc,
+  formatNumber,
+  generateCallEdgeId,
+  generateDirectoryId,
+  generateFileId,
+  generateImportEdgeId,
+  generateScopeDepthColors,
+  generateSymbolId,
+  getAnchorOffset,
+  getBasename,
+  getBoundingBoxCenter,
+  getChildScopes,
+  getClusterStats,
+  getContrastRatio,
+  getDefaultExpandedScopes,
+  getDefaultTheme,
+  getDirectory,
+  getDirectoryConnectionWeight,
+  getDirectoryPosition,
+  getEdgeLabel,
+  getEdgesAtZoomLevel,
+  getEntityId,
+  getExtension,
+  getFA2Settings,
+  getFileIcon,
+  getFilename,
+  getFilesInDirectory,
+  getIconName,
+  getLayoutDuration,
+  getLuminance,
+  getMediumFileLabel,
+  getNodeCluster,
+  getNodeKey,
+  getNodeMass,
+  getNodeOpacityAtLevel,
+  getNodeSizeAtLevel,
+  getNodesInCluster,
+  getParentDirectories,
+  getPathDepth,
+  getPositionsAtDepth,
+  getRootScopes,
+  getScaledNodeSize,
+  getScopeByDirectoryId,
+  getScopeDepthColor,
+  getShortFileLabel,
+  getSigmaTheme,
+  getSymbolIcon,
+  getSymbolKindLabel,
+  getTextColorForBackground,
+  getTheme,
+  getThemeIds,
+  getVisibleEdges,
+  getVisibleNodes,
+  getVisibleScopes,
+  getZoomLevel,
+  getZoomLevelFromZoom,
+  graphToScreen,
+  hexToRgb,
+  hslToHex,
+  hslToRgb,
+  isCodeFile,
+  isPointInBoundingBox,
+  lerp,
+  lightTheme,
+  lighten,
+  matchesPattern,
+  mergeTheme,
+  mix,
+  nexusToGraphology,
+  nodeTypes,
+  normalizePath,
+  normalizePositions,
+  positionAllNodes,
+  positionNodesInScope,
+  registerTheme,
+  removeAllOverlaps,
+  removeOverlapsInScope,
+  rgbToHex,
+  rgbToHsl,
+  rgbaToCss,
+  saturate,
+  scaleSize,
+  screenToGraph,
+  shouldUseDarkText,
+  shrinkBoundingBox,
+  structureToGraphology,
+  truncateLabel,
+  uniformPadding,
+  unionBoundingBoxes,
+  useCurrentTheme,
+  useIsDarkTheme,
+  useLayout,
+  useOverlayPort,
+  useSigma,
+  useTheme,
+  withOpacity
+} from "./chunk-HMMRZXQ4.mjs";
+
+// src/analyzer/index.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+
+// src/analyzer/scanner.ts
+import * as fs from "fs";
+import * as path from "path";
+import ignore from "ignore";
+
+// src/analyzer/grammars/extensions.ts
+var EXTENSION_TO_LANGUAGE = {
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // Java
+  ".java": "java",
+  // Kotlin
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  // C
+  ".c": "c",
+  ".h": "c",
+  // C++
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".c++": "cpp",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".hxx": "cpp",
+  ".h++": "cpp",
+  // C#
+  ".cs": "c_sharp",
+  // Ruby
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  // PHP
+  ".php": "php",
+  ".phtml": "php",
+  ".php3": "php",
+  ".php4": "php",
+  ".php5": "php",
+  ".phps": "php",
+  // Swift
+  ".swift": "swift",
+  // Scala
+  ".scala": "scala",
+  ".sc": "scala",
+  // Shell/Bash
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".fish": "fish",
+  // Lua
+  ".lua": "lua",
+  // Perl
+  ".pl": "perl",
+  ".pm": "perl",
+  // R
+  ".r": "r",
+  ".R": "r",
+  // Haskell
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  // Elixir
+  ".ex": "elixir",
+  ".exs": "elixir",
+  // Erlang
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  // Clojure
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".edn": "clojure",
+  // OCaml
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  // F#
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  // Julia
+  ".jl": "julia",
+  // Dart
+  ".dart": "dart",
+  // Objective-C
+  ".m": "objc",
+  ".mm": "objc",
+  // Groovy
+  ".groovy": "groovy",
+  ".gradle": "groovy",
+  // SQL
+  ".sql": "sql",
+  // GraphQL
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  // HTML
+  ".html": "html",
+  ".htm": "html",
+  // CSS
+  ".css": "css",
+  // SCSS/Sass
+  ".scss": "scss",
+  ".sass": "scss",
+  // YAML
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // TOML
+  ".toml": "toml",
+  // JSON (tree-sitter-json)
+  ".json": "json",
+  // XML
+  ".xml": "xml",
+  ".xsd": "xml",
+  ".xsl": "xml",
+  ".xslt": "xml",
+  ".svg": "xml",
+  // Markdown
+  ".md": "markdown",
+  ".markdown": "markdown",
+  // LaTeX
+  ".tex": "latex",
+  ".latex": "latex",
+  // Dockerfile
+  dockerfile: "dockerfile",
+  // Makefile
+  makefile: "make",
+  ".mk": "make",
+  // CMake
+  ".cmake": "cmake",
+  // Terraform/HCL
+  ".tf": "hcl",
+  ".hcl": "hcl",
+  ".tfvars": "hcl",
+  // Zig
+  ".zig": "zig",
+  // Nim
+  ".nim": "nim",
+  // V
+  ".v": "v",
+  // Elm
+  ".elm": "elm",
+  // PureScript
+  ".purs": "purescript",
+  // ReasonML
+  ".re": "reason",
+  ".rei": "reason",
+  // Nix
+  ".nix": "nix",
+  // Solidity
+  ".sol": "solidity",
+  // GLSL (shaders)
+  ".glsl": "glsl",
+  ".vert": "glsl",
+  ".frag": "glsl",
+  // WGSL
+  ".wgsl": "wgsl",
+  // Protocol Buffers
+  ".proto": "proto",
+  // Thrift
+  ".thrift": "thrift"
+};
+var FILENAME_TO_LANGUAGE = {
+  dockerfile: "dockerfile",
+  makefile: "make",
+  gnumakefile: "make",
+  cmakelists: "cmake",
+  rakefile: "ruby",
+  gemfile: "ruby",
+  podfile: "ruby",
+  vagrantfile: "ruby",
+  brewfile: "ruby"
+};
+function getLanguageForFile(filePath) {
+  const basename2 = filePath.split(/[/\\]/).pop() || "";
+  const lowerBasename = basename2.toLowerCase();
+  const basenameNoExt = lowerBasename.replace(/\.[^.]+$/, "");
+  if (FILENAME_TO_LANGUAGE[basenameNoExt]) {
+    return FILENAME_TO_LANGUAGE[basenameNoExt];
+  }
+  const lastDot = basename2.lastIndexOf(".");
+  if (lastDot === -1) {
+    return FILENAME_TO_LANGUAGE[lowerBasename] || null;
+  }
+  const ext = basename2.slice(lastDot).toLowerCase();
+  return EXTENSION_TO_LANGUAGE[ext] || null;
+}
+
+// src/analyzer/languages/index.ts
+var LanguageRegistry = class {
+  loaders = /* @__PURE__ */ new Map();
+  loaded = /* @__PURE__ */ new Map();
+  extensionMap = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerBuiltinLanguages();
+  }
+  /**
+   * Register built-in language loaders
+   */
+  registerBuiltinLanguages() {
+    this.registerLoader({
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      load: async () => {
+        const lang = await import("tree-sitter-typescript");
+        return lang.default.typescript;
+      }
+    });
+    this.registerLoader({
+      name: "javascript",
+      extensions: [".js", ".jsx", ".mjs", ".cjs"],
+      load: async () => {
+        const lang = await import("tree-sitter-javascript");
+        return lang.default;
+      }
+    });
+    this.registerLoader({
+      name: "python",
+      extensions: [".py", ".pyi"],
+      load: async () => {
+        const lang = await import("tree-sitter-python");
+        return lang.default;
+      }
+    });
+  }
+  /**
+   * Register a language loader
+   */
+  registerLoader(loader) {
+    this.loaders.set(loader.name, loader);
+    for (const ext of loader.extensions) {
+      this.extensionMap.set(ext, loader.name);
+    }
+  }
+  /**
+   * Get language by name, loading if necessary
+   */
+  async getLanguage(name) {
+    if (this.loaded.has(name)) {
+      return this.loaded.get(name);
+    }
+    const loader = this.loaders.get(name);
+    if (!loader) {
+      return null;
+    }
+    const grammar = await loader.load();
+    const language = {
+      name: loader.name,
+      extensions: loader.extensions,
+      grammar
+    };
+    this.loaded.set(name, language);
+    return language;
+  }
+  /**
+   * Get language by file extension
+   */
+  async getLanguageForExtension(extension) {
+    const langName = this.extensionMap.get(extension);
+    if (!langName) {
+      return null;
+    }
+    return this.getLanguage(langName);
+  }
+  /**
+   * Get language for a file path
+   */
+  async getLanguageForFile(filePath) {
+    const ext = this.getExtension(filePath);
+    if (!ext) {
+      return null;
+    }
+    return this.getLanguageForExtension(ext);
+  }
+  /**
+   * Extract file extension from path
+   */
+  getExtension(filePath) {
+    const lastDot = filePath.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === filePath.length - 1) {
+      return null;
+    }
+    return filePath.slice(lastDot);
+  }
+  /**
+   * Get list of supported languages
+   */
+  getSupportedLanguages() {
+    return Array.from(this.loaders.keys());
+  }
+  /**
+   * Get list of supported extensions
+   */
+  getSupportedExtensions() {
+    return Array.from(this.extensionMap.keys());
+  }
+  /**
+   * Check if a file extension is supported (native only)
+   */
+  isSupported(extension) {
+    return this.extensionMap.has(extension);
+  }
+  /**
+   * Check if a file extension is supported by WASM grammars
+   */
+  isWasmSupported(extension) {
+    return extension in EXTENSION_TO_LANGUAGE;
+  }
+  /**
+   * Check if a file is supported based on its path
+   * Considers both native tree-sitter and WASM-based grammars
+   */
+  isFileSupported(filePath) {
+    const ext = this.getExtension(filePath);
+    if (ext !== null && this.isSupported(ext)) {
+      return true;
+    }
+    const langName = getLanguageForFile(filePath);
+    return langName !== null;
+  }
+};
+var registry = null;
+function getLanguageRegistry() {
+  if (!registry) {
+    registry = new LanguageRegistry();
+  }
+  return registry;
+}
+function resetLanguageRegistry() {
+  registry = null;
+}
+
+// src/analyzer/scanner.ts
+var DEFAULT_CONFIG = {
+  include: [],
+  exclude: [],
+  respectGitignore: true,
+  maxDepth: Infinity,
+  maxFiles: 1e4
+};
+var MAX_FILE_SIZE = 1024 * 1024;
+var DirectoryScanner = class {
+  config;
+  ignoreStack = [];
+  files = [];
+  directories = [];
+  skipped = [];
+  fileCount = 0;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      rootPath: path.resolve(config.rootPath)
+    };
+  }
+  /**
+   * Scan the directory tree
+   */
+  async scan() {
+    this.files = [];
+    this.directories = [];
+    this.skipped = [];
+    this.fileCount = 0;
+    this.ignoreStack = [];
+    if (!fs.existsSync(this.config.rootPath)) {
+      throw new Error(`Root path does not exist: ${this.config.rootPath}`);
+    }
+    const stats = fs.statSync(this.config.rootPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Root path is not a directory: ${this.config.rootPath}`);
+    }
+    await this.scanDirectory(this.config.rootPath, 0, null);
+    return {
+      directories: this.directories,
+      files: this.files,
+      skipped: this.skipped,
+      rootPath: this.config.rootPath
+    };
+  }
+  /**
+   * Recursively scan a directory
+   */
+  async scanDirectory(dirPath, depth, parentId) {
+    if (depth > this.config.maxDepth) {
+      return;
+    }
+    if (this.config.respectGitignore) {
+      await this.loadGitignore(dirPath);
+    }
+    const relativePath = path.relative(this.config.rootPath, dirPath);
+    const dirId = generateDirectoryId(relativePath || ".");
+    const dirName = path.basename(dirPath) || path.basename(this.config.rootPath);
+    const dirNode = {
+      id: dirId,
+      name: dirName,
+      path: relativePath || ".",
+      parentId,
+      children: [],
+      files: [],
+      metrics: {
+        fileCount: 0,
+        totalLoc: 0
+      },
+      depth
+    };
+    this.directories.push(dirNode);
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      this.skipped.push({ path: relativePath, reason: "permission" });
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (this.fileCount >= this.config.maxFiles) {
+        this.skipped.push({
+          path: path.join(relativePath, entry.name),
+          reason: "max-files"
+        });
+        continue;
+      }
+      const entryPath = path.join(dirPath, entry.name);
+      const entryRelativePath = path.join(relativePath, entry.name);
+      if (this.isIgnored(entryRelativePath, entry.isDirectory())) {
+        this.skipped.push({ path: entryRelativePath, reason: "gitignore" });
+        continue;
+      }
+      if (this.isExcluded(entryRelativePath)) {
+        this.skipped.push({ path: entryRelativePath, reason: "excluded" });
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (this.shouldSkipDirectory(entry.name)) {
+          this.skipped.push({ path: entryRelativePath, reason: "excluded" });
+          continue;
+        }
+        dirNode.children.push(generateDirectoryId(entryRelativePath));
+        await this.scanDirectory(entryPath, depth + 1, dirId);
+      } else if (entry.isFile()) {
+        const fileNode = await this.processFile(entryPath, entryRelativePath, dirId);
+        if (fileNode) {
+          dirNode.files.push(fileNode.id);
+        }
+      }
+    }
+    if (this.config.respectGitignore) {
+      this.popGitignore(dirPath);
+    }
+  }
+  /**
+   * Process a single file
+   */
+  async processFile(filePath, relativePath, parentId) {
+    const registry2 = getLanguageRegistry();
+    if (!registry2.isFileSupported(filePath)) {
+      this.skipped.push({ path: relativePath, reason: "not-code" });
+      return null;
+    }
+    let stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch {
+      this.skipped.push({ path: relativePath, reason: "permission" });
+      return null;
+    }
+    if (stats.size > MAX_FILE_SIZE) {
+      this.skipped.push({ path: relativePath, reason: "too-large" });
+      return null;
+    }
+    const language = detectLanguage(filePath) || "unknown";
+    const extension = getExtension(filePath) || "";
+    const fileId = generateFileId(relativePath);
+    const fileNode = {
+      id: fileId,
+      name: path.basename(filePath),
+      path: relativePath,
+      extension,
+      directoryId: parentId,
+      language,
+      symbols: [],
+      // Populated during symbol extraction
+      metrics: {
+        loc: 0,
+        // Populated during symbol extraction
+        totalLines: 0,
+        exportCount: 0,
+        importCount: 0
+      }
+    };
+    this.files.push(fileNode);
+    this.fileCount++;
+    return fileNode;
+  }
+  /**
+   * Load .gitignore file from directory
+   */
+  async loadGitignore(dirPath) {
+    const gitignorePath = path.join(dirPath, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      try {
+        const content = fs.readFileSync(gitignorePath, "utf-8");
+        const ig = ignore().add(content);
+        this.ignoreStack.push({ path: dirPath, ig });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Pop gitignore when leaving directory
+   */
+  popGitignore(dirPath) {
+    if (this.ignoreStack.length > 0 && this.ignoreStack[this.ignoreStack.length - 1].path === dirPath) {
+      this.ignoreStack.pop();
+    }
+  }
+  /**
+   * Check if a path is ignored by any gitignore in the stack
+   */
+  isIgnored(relativePath, isDirectory) {
+    for (const { ig, path: igPath } of this.ignoreStack) {
+      const relativeToGitignore = path.relative(
+        path.relative(this.config.rootPath, igPath),
+        relativePath
+      );
+      if (relativeToGitignore && !relativeToGitignore.startsWith("..")) {
+        if (ig.ignores(isDirectory ? relativeToGitignore + "/" : relativeToGitignore)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if path matches exclude patterns
+   */
+  isExcluded(relativePath) {
+    if (this.config.exclude.length === 0) {
+      return false;
+    }
+    for (const pattern of this.config.exclude) {
+      if (this.matchGlob(relativePath, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob matching
+   */
+  matchGlob(filePath, pattern) {
+    const regex = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${regex}$`).test(filePath);
+  }
+  /**
+   * Check if directory should be skipped (common non-code directories)
+   */
+  shouldSkipDirectory(name) {
+    const skipDirs = [
+      "node_modules",
+      ".git",
+      ".svn",
+      ".hg",
+      "__pycache__",
+      ".pytest_cache",
+      ".mypy_cache",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      "coverage",
+      ".nyc_output",
+      "vendor",
+      ".venv",
+      "venv",
+      "env",
+      ".env",
+      ".idea",
+      ".vscode"
+    ];
+    return skipDirs.includes(name);
+  }
+};
+async function scanDirectory(config) {
+  const scanner = new DirectoryScanner(config);
+  return scanner.scan();
+}
+
+// src/analyzer/symbols.ts
+import * as fs3 from "fs";
+
+// src/analyzer/parser.ts
+import Parser2 from "tree-sitter";
+
+// src/analyzer/grammars/index.ts
+import { Parser, Language } from "web-tree-sitter";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var WasmGrammarLoader = class {
+  parser = null;
+  initialized = false;
+  initPromise = null;
+  grammars = /* @__PURE__ */ new Map();
+  grammarPaths = /* @__PURE__ */ new Map();
+  discoveredGrammars = /* @__PURE__ */ new Set();
+  /**
+   * Initialize the WASM parser (lazy, singleton)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.doInitialize();
+    return this.initPromise;
+  }
+  async doInitialize() {
+    try {
+      await Parser.init();
+      this.parser = new Parser();
+      this.initialized = true;
+      await this.discoverGrammars();
+    } catch (error) {
+      this.initialized = false;
+      this.initPromise = null;
+      throw new Error(
+        `Failed to initialize WASM parser: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Discover available WASM grammars from known locations
+   */
+  async discoverGrammars() {
+    const searchPaths = this.getGrammarSearchPaths();
+    for (const searchPath of searchPaths) {
+      if (!fs2.existsSync(searchPath)) continue;
+      try {
+        const files = fs2.readdirSync(searchPath);
+        for (const file of files) {
+          if (file.endsWith(".wasm") && file.startsWith("tree-sitter-")) {
+            const langName = file.replace("tree-sitter-", "").replace(".wasm", "");
+            const fullPath = path2.join(searchPath, file);
+            this.grammarPaths.set(langName, fullPath);
+            this.discoveredGrammars.add(langName);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get paths to search for WASM grammars
+   */
+  getGrammarSearchPaths() {
+    const paths = [];
+    const bundledPath = path2.join(__dirname, "wasm");
+    paths.push(bundledPath);
+    const cwd = process.cwd();
+    const userPath = path2.join(cwd, ".codeviz", "grammars");
+    paths.push(userPath);
+    const nodeModulesPath = path2.join(cwd, "node_modules");
+    if (fs2.existsSync(nodeModulesPath)) {
+      const wasmsPkgPath = path2.join(nodeModulesPath, "tree-sitter-wasms", "out");
+      if (fs2.existsSync(wasmsPkgPath)) {
+        paths.push(wasmsPkgPath);
+      }
+      const potentialPackages = [
+        "tree-sitter-go",
+        "tree-sitter-rust",
+        "tree-sitter-java",
+        "tree-sitter-c",
+        "tree-sitter-ruby",
+        "tree-sitter-cpp",
+        "tree-sitter-c-sharp",
+        "tree-sitter-php",
+        "tree-sitter-swift",
+        "tree-sitter-kotlin"
+      ];
+      for (const pkg of potentialPackages) {
+        const pkgPath = path2.join(nodeModulesPath, pkg);
+        if (fs2.existsSync(pkgPath)) {
+          paths.push(pkgPath);
+        }
+      }
+    }
+    return paths;
+  }
+  /**
+   * Check if a grammar is available for a language
+   */
+  async hasGrammar(language) {
+    await this.initialize();
+    return this.grammarPaths.has(language) || this.grammars.has(language);
+  }
+  /**
+   * Load a grammar by language name
+   */
+  async loadGrammar(language) {
+    await this.initialize();
+    if (this.grammars.has(language)) {
+      return this.grammars.get(language);
+    }
+    const grammarPath = this.grammarPaths.get(language);
+    if (!grammarPath) {
+      return null;
+    }
+    try {
+      const grammar = await Language.load(grammarPath);
+      this.grammars.set(language, grammar);
+      return grammar;
+    } catch (error) {
+      console.warn(
+        `Failed to load grammar for ${language}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Get the parser instance (must be initialized first)
+   */
+  getParser() {
+    return this.parser;
+  }
+  /**
+   * Parse content with a specific language grammar
+   */
+  async parse(content, language) {
+    const grammar = await this.loadGrammar(language);
+    if (!grammar || !this.parser) {
+      return null;
+    }
+    this.parser.setLanguage(grammar);
+    return this.parser.parse(content);
+  }
+  /**
+   * List all available grammar languages
+   */
+  async listAvailableGrammars() {
+    await this.initialize();
+    return Array.from(this.discoveredGrammars);
+  }
+  /**
+   * Add a grammar path manually
+   */
+  addGrammarPath(language, wasmPath) {
+    if (fs2.existsSync(wasmPath)) {
+      this.grammarPaths.set(language, wasmPath);
+      this.discoveredGrammars.add(language);
+    }
+  }
+  /**
+   * Check if the loader is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Reset the loader (useful for testing)
+   */
+  reset() {
+    this.parser = null;
+    this.initialized = false;
+    this.initPromise = null;
+    this.grammars.clear();
+    this.grammarPaths.clear();
+    this.discoveredGrammars.clear();
+  }
+};
+var loaderInstance = null;
+function getWasmGrammarLoader() {
+  if (!loaderInstance) {
+    loaderInstance = new WasmGrammarLoader();
+  }
+  return loaderInstance;
+}
+
+// src/analyzer/parser.ts
+var ParserManager = class {
+  parsers = /* @__PURE__ */ new Map();
+  treeCache = /* @__PURE__ */ new Map();
+  maxCacheSize;
+  constructor(maxCacheSize = 1e3) {
+    this.maxCacheSize = maxCacheSize;
+  }
+  /**
+   * Get or create a parser for the specified language
+   */
+  async getParser(language) {
+    const langName = language.name;
+    if (this.parsers.has(langName)) {
+      return this.parsers.get(langName);
+    }
+    const parser = new Parser2();
+    parser.setLanguage(language.grammar);
+    this.parsers.set(langName, parser);
+    return parser;
+  }
+  /**
+   * Parse source code and return the syntax tree
+   */
+  async parse(filePath, content, language) {
+    const cached = this.treeCache.get(filePath);
+    if (cached) {
+      return cached;
+    }
+    const parser = await this.getParser(language);
+    const startTime = performance.now();
+    const tree = parser.parse(content);
+    const parseTime = performance.now() - startTime;
+    const result = {
+      tree,
+      language: language.name,
+      filePath,
+      parseTime
+    };
+    this.addToCache(filePath, result);
+    return result;
+  }
+  /**
+   * Parse with error handling - returns result or error
+   */
+  async safeParse(filePath, content, language) {
+    try {
+      const result = await this.parse(filePath, content, language);
+      return { result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        error: {
+          message,
+          filePath,
+          language: language.name
+        }
+      };
+    }
+  }
+  /**
+   * Add parsed tree to cache with LRU eviction
+   */
+  addToCache(filePath, tree) {
+    if (this.treeCache.size >= this.maxCacheSize) {
+      const firstKey = this.treeCache.keys().next().value;
+      if (firstKey) {
+        this.treeCache.delete(firstKey);
+      }
+    }
+    this.treeCache.set(filePath, tree);
+  }
+  /**
+   * Clear the cache for a specific file (e.g., when file changes)
+   */
+  invalidate(filePath) {
+    this.treeCache.delete(filePath);
+  }
+  /**
+   * Clear all cached trees
+   */
+  clearCache() {
+    this.treeCache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.treeCache.size,
+      maxSize: this.maxCacheSize
+    };
+  }
+};
+var defaultParserManager = null;
+function getParserManager() {
+  if (!defaultParserManager) {
+    defaultParserManager = new ParserManager();
+  }
+  return defaultParserManager;
+}
+function resetParserManager() {
+  if (defaultParserManager) {
+    defaultParserManager.clearCache();
+    defaultParserManager = null;
+  }
+}
+var NATIVE_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "javascript", "python"]);
+var HybridParserManager = class {
+  nativeManager;
+  treeCache = /* @__PURE__ */ new Map();
+  maxCacheSize;
+  constructor(maxCacheSize = 1e3) {
+    this.nativeManager = new ParserManager(maxCacheSize);
+    this.maxCacheSize = maxCacheSize;
+  }
+  /**
+   * Check if a language has a native parser
+   */
+  hasNativeParser(language) {
+    return NATIVE_LANGUAGES.has(language);
+  }
+  /**
+   * Check if a WASM grammar is available for a language
+   */
+  async hasWasmGrammar(language) {
+    const wasmLoader = getWasmGrammarLoader();
+    return wasmLoader.hasGrammar(language);
+  }
+  /**
+   * Detect language from file path
+   */
+  detectLanguage(filePath) {
+    return getLanguageForFile(filePath);
+  }
+  /**
+   * Parse a file using the appropriate parser
+   * Returns null if no parser is available for the language
+   */
+  async parse(filePath, content, nativeLanguage) {
+    const cached = this.treeCache.get(filePath);
+    if (cached) {
+      return cached;
+    }
+    const langName = nativeLanguage?.name || this.detectLanguage(filePath);
+    if (!langName) {
+      return null;
+    }
+    if (nativeLanguage && this.hasNativeParser(langName)) {
+      const parsed = await this.nativeManager.parse(filePath, content, nativeLanguage);
+      const result = {
+        tree: parsed.tree,
+        parserType: "native",
+        language: langName,
+        filePath,
+        parseTime: parsed.parseTime
+      };
+      this.addToCache(filePath, result);
+      return result;
+    }
+    const wasmLoader = getWasmGrammarLoader();
+    if (await wasmLoader.hasGrammar(langName)) {
+      const startTime = performance.now();
+      const tree = await wasmLoader.parse(content, langName);
+      const parseTime = performance.now() - startTime;
+      if (tree) {
+        const result = {
+          tree,
+          parserType: "wasm",
+          language: langName,
+          filePath,
+          parseTime
+        };
+        this.addToCache(filePath, result);
+        return result;
+      }
+    }
+    return null;
+  }
+  /**
+   * Parse with error handling
+   */
+  async safeParse(filePath, content, nativeLanguage) {
+    try {
+      const result = await this.parse(filePath, content, nativeLanguage);
+      if (!result) {
+        const langName = nativeLanguage?.name || this.detectLanguage(filePath) || "unknown";
+        return {
+          error: {
+            message: `No parser available for language: ${langName}`,
+            filePath,
+            language: langName
+          }
+        };
+      }
+      return { result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        error: {
+          message,
+          filePath,
+          language: nativeLanguage?.name || this.detectLanguage(filePath) || void 0
+        }
+      };
+    }
+  }
+  /**
+   * Check if a file can be parsed (has available parser)
+   */
+  async canParse(filePath) {
+    const langName = this.detectLanguage(filePath);
+    if (!langName) {
+      return false;
+    }
+    if (this.hasNativeParser(langName)) {
+      return true;
+    }
+    return this.hasWasmGrammar(langName);
+  }
+  /**
+   * Get the parser type that would be used for a file
+   */
+  async getParserType(filePath) {
+    const langName = this.detectLanguage(filePath);
+    if (!langName) {
+      return null;
+    }
+    if (this.hasNativeParser(langName)) {
+      return "native";
+    }
+    if (await this.hasWasmGrammar(langName)) {
+      return "wasm";
+    }
+    return null;
+  }
+  /**
+   * Add to cache with LRU eviction
+   */
+  addToCache(filePath, result) {
+    if (this.treeCache.size >= this.maxCacheSize) {
+      const firstKey = this.treeCache.keys().next().value;
+      if (firstKey) {
+        this.treeCache.delete(firstKey);
+      }
+    }
+    this.treeCache.set(filePath, result);
+  }
+  /**
+   * Clear cache for a specific file
+   */
+  invalidate(filePath) {
+    this.treeCache.delete(filePath);
+    this.nativeManager.invalidate(filePath);
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.treeCache.clear();
+    this.nativeManager.clearCache();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const nativeStats = this.nativeManager.getCacheStats();
+    return {
+      hybridSize: this.treeCache.size,
+      nativeSize: nativeStats.size,
+      maxSize: this.maxCacheSize
+    };
+  }
+};
+var defaultHybridManager = null;
+function getHybridParserManager() {
+  if (!defaultHybridManager) {
+    defaultHybridManager = new HybridParserManager();
+  }
+  return defaultHybridManager;
+}
+
+// src/analyzer/languages/base.ts
+function nodeToLocation(node) {
+  return {
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startColumn: node.startPosition.column,
+    endColumn: node.endPosition.column
+  };
+}
+function getNodeText(node) {
+  return node.text;
+}
+function findChild(node, type) {
+  for (const child of node.children) {
+    if (child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function findChildren(node, type) {
+  return node.children.filter((child) => child.type === type);
+}
+function findChildByTypes(node, types) {
+  for (const child of node.children) {
+    if (types.includes(child.type)) {
+      return child;
+    }
+  }
+  return null;
+}
+function collectNodes(root, types) {
+  const result = [];
+  function walk(node) {
+    if (types.includes(node.type)) {
+      result.push(node);
+    }
+    for (const child of node.children) {
+      walk(child);
+    }
+  }
+  walk(root);
+  return result;
+}
+function calculateMetrics(content, commentPatterns) {
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  let blankLines = 0;
+  let commentLines = 0;
+  let inBlockComment = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      blankLines++;
+      continue;
+    }
+    if (commentPatterns.blockStart && commentPatterns.blockEnd) {
+      if (inBlockComment) {
+        commentLines++;
+        if (commentPatterns.blockEnd.test(trimmed)) {
+          inBlockComment = false;
+        }
+        continue;
+      }
+      if (commentPatterns.blockStart.test(trimmed)) {
+        commentLines++;
+        if (!commentPatterns.blockEnd.test(trimmed)) {
+          inBlockComment = true;
+        }
+        continue;
+      }
+    }
+    if (commentPatterns.line && commentPatterns.line.test(trimmed)) {
+      commentLines++;
+      continue;
+    }
+  }
+  const loc = totalLines - blankLines - commentLines;
+  return { loc, totalLines, blankLines, commentLines };
+}
+function rawSymbolsToNodes(rawSymbols, fileId, filePath) {
+  return rawSymbols.map((raw) => {
+    const id = generateSymbolId(filePath, raw.name, raw.location.startLine);
+    return {
+      id,
+      name: raw.name,
+      kind: raw.kind,
+      fileId,
+      location: raw.location,
+      exported: raw.exported,
+      metrics: {
+        loc: raw.loc || raw.location.endLine - raw.location.startLine + 1
+      }
+    };
+  });
+}
+function extractDocstring(node) {
+  const parent = node.parent;
+  if (!parent) return void 0;
+  const nodeIndex = parent.children.indexOf(node);
+  if (nodeIndex <= 0) return void 0;
+  const prevNode = parent.children[nodeIndex - 1];
+  if (prevNode.type === "comment" || prevNode.type === "block_comment") {
+    return cleanDocstring(prevNode.text);
+  }
+  return void 0;
+}
+function cleanDocstring(text) {
+  return text.replace(/^\/\*\*?/, "").replace(/\*\/$/, "").replace(/^\/\/\s?/, "").replace(/^\s*\*\s?/gm, "").replace(/^#\s?/, "").replace(/^"""/gm, "").replace(/"""$/gm, "").trim();
+}
+function isTopLevel(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_body" || current.type === "block" || current.type === "class_body" || current.type === "statement_block") {
+      return false;
+    }
+    if (current.type === "program" || current.type === "module") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return true;
+}
+function findContainingScope(node, scopeTypes) {
+  let current = node.parent;
+  while (current) {
+    if (scopeTypes.includes(current.type)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+// src/analyzer/languages/typescript.ts
+var TS_COMMENT_PATTERNS = {
+  line: /^\/\//,
+  blockStart: /^\/\*/,
+  blockEnd: /\*\/$/
+};
+function extractTSSymbols(tree, content) {
+  const symbols = [];
+  const root = tree.rootNode;
+  extractFunctions(root, symbols);
+  extractClasses(root, symbols);
+  extractInterfaces(root, symbols);
+  extractTypes(root, symbols);
+  extractEnums(root, symbols);
+  extractVariables(root, symbols);
+  const baseMetrics = calculateMetrics(content, TS_COMMENT_PATTERNS);
+  const exportCount = symbols.filter((s) => s.exported).length;
+  const importCount = extractTSImports(tree).length;
+  return {
+    symbols,
+    metrics: {
+      ...baseMetrics,
+      exportCount,
+      importCount
+    }
+  };
+}
+function extractFunctions(root, symbols) {
+  const funcDecls = collectNodes(root, [
+    "function_declaration",
+    "function",
+    "generator_function_declaration",
+    "generator_function"
+  ]);
+  for (const node of funcDecls) {
+    const nameNode = findChild(node, "identifier");
+    if (!nameNode) continue;
+    symbols.push({
+      name: getNodeText(nameNode),
+      kind: "function",
+      location: nodeToLocation(node),
+      exported: isExported(node),
+      docstring: extractDocstring(node)
+    });
+  }
+  const varDecls = collectNodes(root, ["lexical_declaration", "variable_declaration"]);
+  for (const decl of varDecls) {
+    const declarators = findChildren(decl, "variable_declarator");
+    for (const declarator of declarators) {
+      const nameNode = findChild(declarator, "identifier");
+      const valueNode = findChildByTypes(declarator, ["arrow_function", "function"]);
+      if (nameNode && valueNode) {
+        symbols.push({
+          name: getNodeText(nameNode),
+          kind: "function",
+          location: nodeToLocation(decl),
+          exported: isExported(decl),
+          docstring: extractDocstring(decl)
+        });
+      }
+    }
+  }
+}
+function extractClasses(root, symbols) {
+  const classDecls = collectNodes(root, [
+    "class_declaration",
+    "class",
+    "abstract_class_declaration"
+  ]);
+  for (const node of classDecls) {
+    const nameNode = findChildByTypes(node, ["identifier", "type_identifier"]);
+    if (!nameNode) continue;
+    const className = getNodeText(nameNode);
+    symbols.push({
+      name: className,
+      kind: "class",
+      location: nodeToLocation(node),
+      exported: isExported(node),
+      docstring: extractDocstring(node)
+    });
+    const classBody = findChild(node, "class_body");
+    if (classBody) {
+      extractMethods(classBody, symbols, className);
+    }
+  }
+}
+function extractMethods(classBody, symbols, className) {
+  const methodTypes = [
+    "method_definition",
+    "public_field_definition",
+    "field_definition"
+  ];
+  for (const child of classBody.children) {
+    if (!methodTypes.includes(child.type)) continue;
+    if (child.type === "method_definition") {
+      const nameNode = findChild(child, "property_identifier");
+      if (nameNode) {
+        symbols.push({
+          name: getNodeText(nameNode),
+          kind: "method",
+          location: nodeToLocation(child),
+          exported: true,
+          // Methods are accessible through the class
+          parentName: className,
+          docstring: extractDocstring(child)
+        });
+      }
+    }
+    if (child.type === "public_field_definition" || child.type === "field_definition") {
+      const nameNode = findChild(child, "property_identifier");
+      const valueNode = findChild(child, "arrow_function");
+      if (nameNode && valueNode) {
+        symbols.push({
+          name: getNodeText(nameNode),
+          kind: "method",
+          location: nodeToLocation(child),
+          exported: true,
+          parentName: className,
+          docstring: extractDocstring(child)
+        });
+      }
+    }
+  }
+}
+function extractInterfaces(root, symbols) {
+  const interfaces = collectNodes(root, ["interface_declaration"]);
+  for (const node of interfaces) {
+    const nameNode = findChild(node, "type_identifier");
+    if (!nameNode) continue;
+    symbols.push({
+      name: getNodeText(nameNode),
+      kind: "interface",
+      location: nodeToLocation(node),
+      exported: isExported(node),
+      docstring: extractDocstring(node)
+    });
+  }
+}
+function extractTypes(root, symbols) {
+  const typeAliases = collectNodes(root, ["type_alias_declaration"]);
+  for (const node of typeAliases) {
+    const nameNode = findChild(node, "type_identifier");
+    if (!nameNode) continue;
+    symbols.push({
+      name: getNodeText(nameNode),
+      kind: "type",
+      location: nodeToLocation(node),
+      exported: isExported(node),
+      docstring: extractDocstring(node)
+    });
+  }
+}
+function extractEnums(root, symbols) {
+  const enums = collectNodes(root, ["enum_declaration"]);
+  for (const node of enums) {
+    const nameNode = findChild(node, "identifier");
+    if (!nameNode) continue;
+    symbols.push({
+      name: getNodeText(nameNode),
+      kind: "enum",
+      location: nodeToLocation(node),
+      exported: isExported(node),
+      docstring: extractDocstring(node)
+    });
+  }
+}
+function extractVariables(root, symbols) {
+  const varDecls = collectNodes(root, ["lexical_declaration", "variable_declaration"]);
+  for (const decl of varDecls) {
+    if (!isTopLevel(decl)) continue;
+    const declarators = findChildren(decl, "variable_declarator");
+    for (const declarator of declarators) {
+      const nameNode = findChild(declarator, "identifier");
+      const valueNode = findChildByTypes(declarator, ["arrow_function", "function"]);
+      if (valueNode) continue;
+      if (nameNode) {
+        symbols.push({
+          name: getNodeText(nameNode),
+          kind: "variable",
+          location: nodeToLocation(decl),
+          exported: isExported(decl),
+          docstring: extractDocstring(decl)
+        });
+      }
+    }
+  }
+}
+function isExported(node) {
+  const parent = node.parent;
+  if (parent?.type === "export_statement") {
+    return true;
+  }
+  for (const child of node.children) {
+    if (child.type === "export") {
+      return true;
+    }
+  }
+  return false;
+}
+function extractTSImports(tree) {
+  const imports = [];
+  const root = tree.rootNode;
+  const importStatements = collectNodes(root, ["import_statement"]);
+  for (const node of importStatements) {
+    const source = extractImportSource(node);
+    if (!source) continue;
+    const isTypeOnly = hasTypeOnlyModifier(node);
+    const importedSymbols = extractImportedSymbols(node);
+    imports.push({
+      source,
+      importType: isTypeOnly ? "type-only" : "static",
+      importedSymbols: importedSymbols.names,
+      isDefault: importedSymbols.hasDefault,
+      isNamespace: importedSymbols.isNamespace,
+      location: nodeToLocation(node)
+    });
+  }
+  const callExpressions = collectNodes(root, ["call_expression"]);
+  for (const call of callExpressions) {
+    const fnNode = call.children[0];
+    if (fnNode?.type === "import") {
+      const args = findChild(call, "arguments");
+      if (args) {
+        const stringNode = findChildByTypes(args, ["string", "template_string"]);
+        if (stringNode) {
+          imports.push({
+            source: extractStringContent(stringNode),
+            importType: "dynamic",
+            importedSymbols: [],
+            isDefault: false,
+            isNamespace: true,
+            location: nodeToLocation(call)
+          });
+        }
+      }
+    }
+  }
+  for (const call of callExpressions) {
+    const fnNode = call.children[0];
+    if (fnNode?.type === "identifier" && getNodeText(fnNode) === "require") {
+      const args = findChild(call, "arguments");
+      if (args) {
+        const stringNode = findChildByTypes(args, ["string", "template_string"]);
+        if (stringNode) {
+          imports.push({
+            source: extractStringContent(stringNode),
+            importType: "static",
+            importedSymbols: [],
+            isDefault: false,
+            isNamespace: true,
+            location: nodeToLocation(call)
+          });
+        }
+      }
+    }
+  }
+  return imports;
+}
+function extractImportSource(node) {
+  const stringNode = findChildByTypes(node, ["string", "template_string"]);
+  if (!stringNode) return null;
+  return extractStringContent(stringNode);
+}
+function extractStringContent(node) {
+  const text = getNodeText(node);
+  return text.slice(1, -1);
+}
+function hasTypeOnlyModifier(node) {
+  for (const child of node.children) {
+    if (child.type === "type" && getNodeText(child) === "type") {
+      return true;
+    }
+  }
+  return false;
+}
+function extractImportedSymbols(node) {
+  const names = [];
+  let hasDefault = false;
+  let isNamespace = false;
+  const importClause = findChild(node, "import_clause");
+  if (!importClause) {
+    return { names, hasDefault, isNamespace };
+  }
+  for (const child of importClause.children) {
+    if (child.type === "identifier") {
+      hasDefault = true;
+      names.push(getNodeText(child));
+    }
+    if (child.type === "namespace_import") {
+      isNamespace = true;
+      const asNode = findChild(child, "identifier");
+      if (asNode) {
+        names.push(getNodeText(asNode));
+      }
+    }
+    if (child.type === "named_imports") {
+      const specifiers = findChildren(child, "import_specifier");
+      for (const spec of specifiers) {
+        const nameNode = findChild(spec, "identifier");
+        if (nameNode) {
+          names.push(getNodeText(nameNode));
+        }
+      }
+    }
+  }
+  return { names, hasDefault, isNamespace };
+}
+function extractTSCalls(tree, symbols) {
+  const calls = [];
+  const root = tree.rootNode;
+  const symbolNames = new Set(symbols.map((s) => s.name));
+  const callExpressions = collectNodes(root, ["call_expression", "new_expression"]);
+  for (const call of callExpressions) {
+    const callInfo = extractCallInfo(call, symbolNames);
+    if (callInfo) {
+      const scope = findContainingScope(call, [
+        "function_declaration",
+        "generator_function_declaration",
+        "generator_function",
+        "method_definition",
+        "arrow_function",
+        "function"
+      ]);
+      if (scope) {
+        const callerName = getScopeName(scope);
+        if (callerName) {
+          calls.push({
+            callerName,
+            calleeName: callInfo.name,
+            callType: callInfo.type,
+            location: nodeToLocation(call)
+          });
+        }
+      }
+    }
+  }
+  return calls;
+}
+function extractCallInfo(node, symbolNames) {
+  if (node.type === "new_expression") {
+    const constructorNode = node.children[1];
+    if (constructorNode?.type === "identifier") {
+      const name = getNodeText(constructorNode);
+      if (symbolNames.has(name)) {
+        return { name, type: "constructor" };
+      }
+    }
+    return null;
+  }
+  const fnNode = node.children[0];
+  if (fnNode?.type === "identifier") {
+    const name = getNodeText(fnNode);
+    if (symbolNames.has(name)) {
+      return { name, type: "direct" };
+    }
+    return null;
+  }
+  if (fnNode?.type === "member_expression") {
+    const objectNode = findChild(fnNode, "this");
+    const propertyNode = findChild(fnNode, "property_identifier");
+    if (objectNode && propertyNode) {
+      return {
+        name: getNodeText(propertyNode),
+        type: "method"
+      };
+    }
+  }
+  return null;
+}
+function getScopeName(scope) {
+  if (scope.type === "function_declaration" || scope.type === "function" || scope.type === "generator_function_declaration" || scope.type === "generator_function") {
+    const nameNode = findChild(scope, "identifier");
+    return nameNode ? getNodeText(nameNode) : null;
+  }
+  if (scope.type === "method_definition") {
+    const nameNode = findChild(scope, "property_identifier");
+    return nameNode ? getNodeText(nameNode) : null;
+  }
+  if (scope.type === "arrow_function") {
+    const parent = scope.parent;
+    if (parent?.type === "variable_declarator") {
+      const nameNode = findChild(parent, "identifier");
+      return nameNode ? getNodeText(nameNode) : null;
+    }
+  }
+  return null;
+}
+
+// src/analyzer/languages/python.ts
+var PYTHON_COMMENT_PATTERNS = {
+  line: /^#/,
+  blockStart: /^"""/,
+  blockEnd: /"""$/
+};
+function extractPythonSymbols(tree, content) {
+  const symbols = [];
+  const root = tree.rootNode;
+  extractFunctions2(root, symbols);
+  extractClasses2(root, symbols);
+  extractVariables2(root, symbols);
+  const baseMetrics = calculateMetrics(content, PYTHON_COMMENT_PATTERNS);
+  const exportCount = symbols.filter((s) => s.exported).length;
+  const importCount = extractPythonImports(tree).length;
+  return {
+    symbols,
+    metrics: {
+      ...baseMetrics,
+      exportCount,
+      importCount
+    }
+  };
+}
+function extractFunctions2(root, symbols) {
+  const funcDefs = collectNodes(root, ["function_definition"]);
+  for (const node of funcDefs) {
+    if (isMethod(node)) continue;
+    const nameNode = findChild(node, "identifier");
+    if (!nameNode) continue;
+    const name = getNodeText(nameNode);
+    const isPrivate = name.startsWith("_") && !name.startsWith("__");
+    symbols.push({
+      name,
+      kind: "function",
+      location: nodeToLocation(node),
+      exported: !isPrivate,
+      // All top-level non-private symbols are exported
+      docstring: extractPythonDocstring(node)
+    });
+  }
+}
+function extractClasses2(root, symbols) {
+  const classDefs = collectNodes(root, ["class_definition"]);
+  for (const node of classDefs) {
+    const nameNode = findChild(node, "identifier");
+    if (!nameNode) continue;
+    const className = getNodeText(nameNode);
+    const isPrivate = className.startsWith("_") && !className.startsWith("__");
+    symbols.push({
+      name: className,
+      kind: "class",
+      location: nodeToLocation(node),
+      exported: !isPrivate,
+      docstring: extractPythonDocstring(node)
+    });
+    const body = findChild(node, "block");
+    if (body) {
+      extractMethods2(body, symbols, className);
+    }
+  }
+}
+function extractMethods2(classBody, symbols, className) {
+  const methods = collectNodes(classBody, ["function_definition"]);
+  for (const method of methods) {
+    const nameNode = findChild(method, "identifier");
+    if (!nameNode) continue;
+    const name = getNodeText(nameNode);
+    const isDunder = name.startsWith("__") && name.endsWith("__");
+    const isPrivate = name.startsWith("_") && !isDunder;
+    symbols.push({
+      name,
+      kind: "method",
+      location: nodeToLocation(method),
+      exported: !isPrivate,
+      // Methods are accessible through the class
+      parentName: className,
+      docstring: extractPythonDocstring(method)
+    });
+  }
+}
+function extractVariables2(root, symbols) {
+  for (const child of root.children) {
+    if (child.type === "expression_statement") {
+      const assignment = findChild(child, "assignment");
+      if (assignment) {
+        const leftNode = assignment.children[0];
+        if (leftNode?.type === "identifier") {
+          const name = getNodeText(leftNode);
+          const isPrivate = name.startsWith("_");
+          symbols.push({
+            name,
+            kind: "variable",
+            location: nodeToLocation(child),
+            exported: !isPrivate,
+            docstring: void 0
+          });
+        }
+      }
+    }
+  }
+}
+function isMethod(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "class_definition") {
+      return true;
+    }
+    if (current.type === "function_definition") {
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function extractPythonDocstring(node) {
+  const body = findChild(node, "block");
+  if (!body) return void 0;
+  for (const child of body.children) {
+    if (child.type === "expression_statement") {
+      const stringNode = findChild(child, "string");
+      if (stringNode) {
+        return cleanPythonDocstring(getNodeText(stringNode));
+      }
+    }
+    if (child.type !== "comment") {
+      break;
+    }
+  }
+  return void 0;
+}
+function cleanPythonDocstring(text) {
+  return text.replace(/^["']{3}/, "").replace(/["']{3}$/, "").trim();
+}
+function extractPythonImports(tree) {
+  const imports = [];
+  const root = tree.rootNode;
+  const importStatements = collectNodes(root, ["import_statement"]);
+  for (const node of importStatements) {
+    const modules = extractImportedModules(node);
+    for (const moduleName of modules) {
+      imports.push({
+        source: moduleName,
+        importType: "static",
+        importedSymbols: [],
+        isDefault: false,
+        isNamespace: true,
+        location: nodeToLocation(node)
+      });
+    }
+  }
+  const fromStatements = collectNodes(root, ["import_from_statement"]);
+  for (const node of fromStatements) {
+    const moduleInfo = extractFromImport(node);
+    if (moduleInfo) {
+      imports.push({
+        source: moduleInfo.module,
+        importType: "static",
+        importedSymbols: moduleInfo.symbols,
+        isDefault: false,
+        isNamespace: moduleInfo.isWildcard,
+        location: nodeToLocation(node)
+      });
+    }
+  }
+  return imports;
+}
+function extractImportedModules(node) {
+  const modules = [];
+  for (const child of node.children) {
+    if (child.type === "dotted_name") {
+      modules.push(getNodeText(child));
+    }
+    if (child.type === "aliased_import") {
+      const dottedName = findChild(child, "dotted_name");
+      if (dottedName) {
+        modules.push(getNodeText(dottedName));
+      }
+    }
+  }
+  return modules;
+}
+function extractFromImport(node) {
+  let module = "";
+  const symbols = [];
+  let isWildcard = false;
+  let foundModule = false;
+  for (const child of node.children) {
+    if (child.type === "import") {
+      foundModule = true;
+    }
+    if (!foundModule && child.type === "dotted_name") {
+      module = getNodeText(child);
+    }
+    if (child.type === "relative_import") {
+      const dots = collectNodes(child, ["import_prefix"]);
+      const dottedName = findChild(child, "dotted_name");
+      const prefix = dots.length > 0 ? getNodeText(dots[0]) : "";
+      const modulePart = dottedName ? getNodeText(dottedName) : "";
+      module = prefix + modulePart;
+      foundModule = true;
+    }
+  }
+  let afterImport = false;
+  for (const child of node.children) {
+    if (child.type === "import") {
+      afterImport = true;
+      continue;
+    }
+    if (!afterImport) continue;
+    if (child.type === "wildcard_import") {
+      isWildcard = true;
+    }
+    if (child.type === "dotted_name") {
+      symbols.push(getNodeText(child));
+    }
+    if (child.type === "aliased_import") {
+      const name = findChild(child, "dotted_name");
+      if (name) {
+        symbols.push(getNodeText(name));
+      }
+    }
+    if (child.type === "identifier") {
+      symbols.push(getNodeText(child));
+    }
+  }
+  if (!module && !isWildcard) {
+    return null;
+  }
+  return { module, symbols, isWildcard };
+}
+function extractPythonCalls(tree, symbols) {
+  const calls = [];
+  const root = tree.rootNode;
+  const symbolNames = new Set(symbols.map((s) => s.name));
+  const callNodes = collectNodes(root, ["call"]);
+  for (const call of callNodes) {
+    const callInfo = extractCallInfo2(call, symbolNames);
+    if (callInfo) {
+      const scope = findContainingScope(call, ["function_definition"]);
+      if (scope) {
+        const callerName = getScopeName2(scope);
+        if (callerName) {
+          calls.push({
+            callerName,
+            calleeName: callInfo.name,
+            callType: callInfo.type,
+            location: nodeToLocation(call)
+          });
+        }
+      }
+    }
+  }
+  return calls;
+}
+function extractCallInfo2(node, symbolNames) {
+  const fnNode = node.children[0];
+  if (fnNode?.type === "identifier") {
+    const name = getNodeText(fnNode);
+    if (symbolNames.has(name)) {
+      const isClass = /^[A-Z]/.test(name);
+      return {
+        name,
+        type: isClass ? "constructor" : "direct"
+      };
+    }
+    return null;
+  }
+  if (fnNode?.type === "attribute") {
+    const objectNode = fnNode.children[0];
+    const identifiers = fnNode.children.filter((c) => c.type === "identifier");
+    const attrNode = identifiers.length > 1 ? identifiers[identifiers.length - 1] : null;
+    if (objectNode?.type === "identifier" && getNodeText(objectNode) === "self") {
+      if (attrNode) {
+        return {
+          name: getNodeText(attrNode),
+          type: "method"
+        };
+      }
+    }
+  }
+  return null;
+}
+function getScopeName2(scope) {
+  const nameNode = findChild(scope, "identifier");
+  return nameNode ? getNodeText(nameNode) : null;
+}
+
+// src/analyzer/languages/generic.ts
+var SYMBOL_PATTERNS = {
+  function: [
+    /^function_declaration$/,
+    /^function_definition$/,
+    /^function_item$/,
+    // Rust
+    /^func_literal$/,
+    // Go
+    /^method_declaration$/,
+    /^function_expression$/,
+    /^arrow_function$/,
+    /^lambda_expression$/,
+    /^anonymous_function$/
+  ],
+  method: [
+    /^method_definition$/,
+    /^method_declaration$/,
+    /^instance_method$/,
+    /^class_method$/,
+    /^static_method$/
+  ],
+  class: [
+    /^class_declaration$/,
+    /^class_definition$/,
+    /^class$/,
+    // Ruby
+    /^class_specifier$/,
+    // C++
+    /^struct_item$/,
+    // Rust
+    /^struct_declaration$/,
+    // C
+    /^struct_specifier$/,
+    // C
+    /^impl_item$/
+    // Rust
+  ],
+  interface: [
+    /^interface_declaration$/,
+    /^interface_definition$/,
+    /^trait_item$/,
+    // Rust
+    /^protocol_declaration$/
+    // Swift
+  ],
+  type: [
+    /^type_alias_declaration$/,
+    /^type_declaration$/,
+    /^type_definition$/,
+    /^type_spec$/,
+    // Go
+    /^typedef_declaration$/
+    // C
+  ],
+  enum: [
+    /^enum_declaration$/,
+    /^enum_definition$/,
+    /^enum_item$/,
+    // Rust
+    /^enum_specifier$/
+    // C
+  ],
+  variable: [
+    /^variable_declaration$/,
+    /^const_declaration$/,
+    /^let_declaration$/,
+    /^const_item$/,
+    // Rust
+    /^static_item$/,
+    // Rust
+    /^var_declaration$/,
+    // Go
+    /^short_var_declaration$/
+    // Go
+  ],
+  constant: [
+    /^const_declaration$/,
+    /^const_item$/,
+    // Rust
+    /^constant_declaration$/
+  ],
+  property: [
+    /^field_declaration$/,
+    /^property_declaration$/,
+    /^field_definition$/
+  ],
+  namespace: [
+    /^module_declaration$/,
+    /^module$/,
+    // Ruby
+    /^mod_item$/,
+    // Rust
+    /^package_declaration$/,
+    // Java
+    /^namespace_declaration$/
+  ]
+};
+var IMPORT_PATTERNS = [
+  /^import_declaration$/,
+  /^import_statement$/,
+  /^import_from_statement$/,
+  /^use_declaration$/,
+  // Rust
+  /^use_statement$/,
+  /^include_directive$/,
+  // C/C++
+  /^preproc_include$/,
+  // C/C++
+  /^require_expression$/,
+  /^require_statement$/,
+  /^import_spec$/
+  // Go
+];
+var NAME_NODE_TYPES = [
+  "identifier",
+  "name",
+  "type_identifier",
+  "property_identifier",
+  "field_identifier",
+  "constant_identifier",
+  "simple_identifier",
+  "constant"
+  // Ruby class/module names
+];
+var COMMENT_NODE_TYPES = [
+  "comment",
+  "line_comment",
+  "block_comment",
+  "doc_comment",
+  "multiline_comment"
+];
+function nodeToLocation2(node) {
+  return {
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    startColumn: node.startPosition.column,
+    endColumn: node.endPosition.column
+  };
+}
+function findName(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && NAME_NODE_TYPES.includes(child.type)) {
+      return child.text;
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && NAME_NODE_TYPES.includes(child.type)) {
+      return child.text;
+    }
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      for (let j = 0; j < child.childCount; j++) {
+        const grandchild = child.child(j);
+        if (grandchild && NAME_NODE_TYPES.includes(grandchild.type)) {
+          return grandchild.text;
+        }
+      }
+    }
+  }
+  return null;
+}
+function getSymbolKind(nodeType) {
+  for (const [kind, patterns] of Object.entries(SYMBOL_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (pattern.test(nodeType)) {
+        return kind;
+      }
+    }
+  }
+  return null;
+}
+function isImportNode(nodeType) {
+  return IMPORT_PATTERNS.some((pattern) => pattern.test(nodeType));
+}
+function extractImportSource2(node) {
+  const systemLib = node.descendantsOfType("system_lib_string")[0];
+  if (systemLib) {
+    const text = systemLib.text;
+    return text.replace(/^<|>$/g, "");
+  }
+  const stringLiteral = node.descendantsOfType("string_literal")[0];
+  if (stringLiteral) {
+    const text = stringLiteral.text;
+    return text.replace(/^["']|["']$/g, "");
+  }
+  const stringNode = node.descendantsOfType("string")[0];
+  if (stringNode) {
+    const text = stringNode.text;
+    return text.replace(/^["']|["']$/g, "");
+  }
+  const stringContent = node.descendantsOfType("string_content")[0];
+  if (stringContent) {
+    return stringContent.text;
+  }
+  const interpretedString = node.descendantsOfType("interpreted_string_literal")[0];
+  if (interpretedString) {
+    const text = interpretedString.text;
+    return text.replace(/^["']|["']$/g, "");
+  }
+  const dottedName = node.descendantsOfType("dotted_name")[0];
+  if (dottedName) {
+    return dottedName.text;
+  }
+  const scopedId = node.descendantsOfType("scoped_identifier")[0];
+  if (scopedId) {
+    return scopedId.text;
+  }
+  const identifier = node.descendantsOfType("identifier")[0];
+  if (identifier) {
+    return identifier.text;
+  }
+  return null;
+}
+function isTopLevel2(node) {
+  let current = node.parent;
+  while (current) {
+    const type = current.type;
+    if (type.includes("body") || type.includes("block") || type === "compound_statement") {
+      if (!current.parent || current.parent.type === "source_file") {
+        return true;
+      }
+      return false;
+    }
+    if (type === "source_file" || type === "program" || type === "module" || type === "translation_unit") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return true;
+}
+function walkTree(node, callback) {
+  callback(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkTree(child, callback);
+    }
+  }
+}
+function calculateMetrics2(content, tree) {
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  let blankLines = 0;
+  let commentLines = 0;
+  for (const line of lines) {
+    if (line.trim() === "") {
+      blankLines++;
+    }
+  }
+  walkTree(tree.rootNode, (node) => {
+    if (COMMENT_NODE_TYPES.includes(node.type)) {
+      const startLine = node.startPosition.row;
+      const endLine = node.endPosition.row;
+      commentLines += endLine - startLine + 1;
+    }
+  });
+  const loc = Math.max(0, totalLines - blankLines - commentLines);
+  return {
+    loc,
+    totalLines,
+    blankLines,
+    commentLines
+  };
+}
+function extractGeneric(tree, content) {
+  const symbols = [];
+  const imports = [];
+  walkTree(tree.rootNode, (node) => {
+    const nodeType = node.type;
+    const kind = getSymbolKind(nodeType);
+    if (kind) {
+      if (kind !== "method" && !isTopLevel2(node)) {
+        return;
+      }
+      const name = findName(node);
+      if (name) {
+        symbols.push({
+          name,
+          kind,
+          location: nodeToLocation2(node),
+          exported: true
+          // Can't reliably detect exports in generic mode
+        });
+      }
+    }
+    if (isImportNode(nodeType)) {
+      const source = extractImportSource2(node);
+      if (source) {
+        imports.push({
+          source,
+          location: nodeToLocation2(node)
+        });
+      }
+    }
+  });
+  const metrics = calculateMetrics2(content, tree);
+  return {
+    symbols,
+    imports,
+    metrics
+  };
+}
+
+// src/analyzer/symbols.ts
+async function extractSymbols(filePath, content, fileId) {
+  const registry2 = getLanguageRegistry();
+  const language = await registry2.getLanguageForFile(filePath);
+  if (language) {
+    const parserManager = getParserManager();
+    const parseResult = await parserManager.safeParse(filePath, content, language);
+    if ("error" in parseResult) {
+      return {
+        symbols: [],
+        metrics: { loc: 0, totalLines: 0, exportCount: 0, importCount: 0 },
+        parseErrors: [parseResult.error.message]
+      };
+    }
+    const tree = parseResult.result.tree;
+    let extractionResult;
+    switch (language.name) {
+      case "typescript":
+      case "javascript":
+        extractionResult = extractTSSymbols(tree, content);
+        break;
+      case "python":
+        extractionResult = extractPythonSymbols(tree, content);
+        break;
+      default:
+        break;
+    }
+    if (extractionResult) {
+      const symbols2 = rawSymbolsToNodes(extractionResult.symbols, fileId, filePath);
+      return {
+        symbols: symbols2,
+        metrics: {
+          loc: extractionResult.metrics.loc,
+          totalLines: extractionResult.metrics.totalLines,
+          exportCount: extractionResult.metrics.exportCount,
+          importCount: extractionResult.metrics.importCount
+        }
+      };
+    }
+  }
+  const hybridManager = getHybridParserManager();
+  const hybridResult = await hybridManager.safeParse(filePath, content);
+  if ("error" in hybridResult) {
+    return {
+      symbols: [],
+      metrics: { loc: 0, totalLines: 0, exportCount: 0, importCount: 0 },
+      parseErrors: [hybridResult.error.message]
+    };
+  }
+  if (hybridResult.result.parserType !== "wasm") {
+    return {
+      symbols: [],
+      metrics: { loc: 0, totalLines: 0, exportCount: 0, importCount: 0 },
+      parseErrors: [`No extractor available for: ${hybridResult.result.language}`]
+    };
+  }
+  const genericResult = extractGeneric(
+    hybridResult.result.tree,
+    content
+  );
+  const rawSymbols = genericResult.symbols.map((sym) => ({
+    name: sym.name,
+    kind: sym.kind,
+    location: sym.location,
+    exported: sym.exported
+  }));
+  const symbols = rawSymbolsToNodes(rawSymbols, fileId, filePath);
+  return {
+    symbols,
+    metrics: {
+      loc: genericResult.metrics.loc,
+      totalLines: genericResult.metrics.totalLines,
+      exportCount: symbols.filter((s) => s.exported).length,
+      importCount: genericResult.imports.length
+    }
+  };
+}
+async function extractSymbolsFromFile(filePath, fileId) {
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    return extractSymbols(filePath, content, fileId);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      symbols: [],
+      metrics: { loc: 0, totalLines: 0, exportCount: 0, importCount: 0 },
+      parseErrors: [`Failed to read file: ${message}`]
+    };
+  }
+}
+
+// src/analyzer/imports.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+async function extractImports(filePath, content) {
+  const registry2 = getLanguageRegistry();
+  const language = await registry2.getLanguageForFile(filePath);
+  if (!language) {
+    return [];
+  }
+  const parserManager = getParserManager();
+  const parseResult = await parserManager.safeParse(filePath, content, language);
+  if ("error" in parseResult) {
+    return [];
+  }
+  const tree = parseResult.result.tree;
+  let rawImports;
+  switch (language.name) {
+    case "typescript":
+    case "javascript":
+      rawImports = extractTSImports(tree);
+      break;
+    case "python":
+      rawImports = extractPythonImports(tree);
+      break;
+    default:
+      return [];
+  }
+  return rawImports.map((raw) => ({
+    source: raw.source,
+    importType: raw.importType,
+    importedSymbols: raw.importedSymbols,
+    location: raw.location
+  }));
+}
+function resolveImport(importInfo, fromFileId, fromFilePath, rootPath, fileIndex) {
+  const { source, importType, importedSymbols, location } = importInfo;
+  const isRelative = source.startsWith("./") || source.startsWith("../");
+  const isBareSpecifier = !isRelative && !source.startsWith("/");
+  if (isBareSpecifier) {
+    return createUnresolvedImport(fromFileId, source, importType, importedSymbols, location);
+  }
+  const resolvedPath = resolveRelativeImport(fromFilePath, source, rootPath);
+  if (resolvedPath) {
+    const normalizedPath = normalizePathForIndex(resolvedPath, rootPath);
+    const toFileId = fileIndex.get(normalizedPath);
+    if (toFileId) {
+      return {
+        edge: {
+          id: `import-${fromFileId}-${toFileId}-${location.startLine}`,
+          sourceId: fromFileId,
+          targetId: toFileId,
+          importType,
+          importedSymbols,
+          resolved: true
+        },
+        resolved: true,
+        resolvedPath
+      };
+    }
+  }
+  return createUnresolvedImport(fromFileId, source, importType, importedSymbols, location);
+}
+function createUnresolvedImport(fromFileId, source, importType, importedSymbols, location) {
+  const externalId = `external:${source}`;
+  return {
+    edge: {
+      id: `import-${fromFileId}-${externalId}-${location.startLine}`,
+      sourceId: fromFileId,
+      targetId: externalId,
+      importType,
+      importedSymbols,
+      resolved: false
+    },
+    resolved: false
+  };
+}
+function resolveRelativeImport(fromFilePath, importSource, _rootPath) {
+  const fromDir = path3.dirname(fromFilePath);
+  const baseResolved = path3.resolve(fromDir, importSource);
+  const candidates = generateResolutionCandidates(baseResolved);
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function generateResolutionCandidates(basePath) {
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const indexFiles = extensions.map((ext) => `index${ext}`);
+  const candidates = [];
+  candidates.push(basePath);
+  for (const ext of extensions) {
+    candidates.push(basePath + ext);
+  }
+  for (const indexFile of indexFiles) {
+    candidates.push(path3.join(basePath, indexFile));
+  }
+  return candidates;
+}
+function normalizePathForIndex(filePath, rootPath) {
+  const relativePath = path3.relative(rootPath, filePath);
+  return relativePath.replace(/\\/g, "/");
+}
+function buildFileIndex(files) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const normalized = file.path.replace(/\\/g, "/");
+    index.set(normalized, file.id);
+    const withoutExt = removeExtension(normalized);
+    if (withoutExt !== normalized && !index.has(withoutExt)) {
+      index.set(withoutExt, file.id);
+    }
+  }
+  return index;
+}
+function removeExtension(filePath) {
+  const ext = path3.extname(filePath);
+  if (ext) {
+    return filePath.slice(0, -ext.length);
+  }
+  return filePath;
+}
+async function resolveFileImports(filePath, content, fileId, rootPath, fileIndex) {
+  const imports = await extractImports(filePath, content);
+  return imports.map(
+    (importInfo) => resolveImport(importInfo, fileId, filePath, rootPath, fileIndex)
+  );
+}
+
+// src/analyzer/calls.ts
+async function extractCalls(filePath, content, symbols) {
+  const registry2 = getLanguageRegistry();
+  const language = await registry2.getLanguageForFile(filePath);
+  if (!language) {
+    return [];
+  }
+  const parserManager = getParserManager();
+  const parseResult = await parserManager.safeParse(filePath, content, language);
+  if ("error" in parseResult) {
+    return [];
+  }
+  const tree = parseResult.result.tree;
+  const rawSymbols = symbols.map((s) => ({
+    name: s.name,
+    kind: s.kind,
+    location: s.location,
+    exported: s.exported,
+    parentName: void 0
+  }));
+  switch (language.name) {
+    case "typescript":
+    case "javascript":
+      return extractTSCalls(tree, rawSymbols);
+    case "python":
+      return extractPythonCalls(tree, rawSymbols);
+    default:
+      return [];
+  }
+}
+function resolveCall(call, fileSymbols, symbolIndex, callCounts) {
+  const callerSymbol = fileSymbols.find(
+    (s) => s.name === call.callerName && (s.kind === "function" || s.kind === "method")
+  );
+  if (!callerSymbol) {
+    return null;
+  }
+  let calleeSymbol;
+  if (call.callType === "method") {
+    const callerClass = fileSymbols.find(
+      (s) => s.kind === "class" && fileSymbols.some(
+        (m) => m.kind === "method" && m.name === call.callerName && m.fileId === s.fileId
+      )
+    );
+    if (callerClass) {
+      calleeSymbol = fileSymbols.find(
+        (s) => s.kind === "method" && s.name === call.calleeName && s.fileId === callerClass.fileId
+      );
+    }
+  } else {
+    calleeSymbol = symbolIndex.get(call.calleeName);
+    if (!calleeSymbol) {
+      calleeSymbol = fileSymbols.find((s) => s.name === call.calleeName);
+    }
+  }
+  const edgeKey = calleeSymbol ? `${callerSymbol.id}-${calleeSymbol.id}` : `${callerSymbol.id}-unresolved:${call.calleeName}`;
+  const currentCount = callCounts.get(edgeKey) || 0;
+  callCounts.set(edgeKey, currentCount + 1);
+  if (!calleeSymbol) {
+    return {
+      edge: {
+        id: `call-${callerSymbol.id}-unresolved-${call.calleeName}`,
+        sourceId: callerSymbol.id,
+        targetId: `unresolved:${call.calleeName}`,
+        callCount: callCounts.get(edgeKey) || 1,
+        resolved: false
+      },
+      resolved: false
+    };
+  }
+  return {
+    edge: {
+      id: `call-${callerSymbol.id}-${calleeSymbol.id}`,
+      sourceId: callerSymbol.id,
+      targetId: calleeSymbol.id,
+      callCount: callCounts.get(edgeKey) || 1,
+      resolved: true
+    },
+    resolved: true
+  };
+}
+async function resolveFileCalls(filePath, content, fileSymbols, globalSymbolIndex) {
+  const rawCalls = await extractCalls(filePath, content, fileSymbols);
+  const resolvedCalls = [];
+  const callCounts = /* @__PURE__ */ new Map();
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const call of rawCalls) {
+    const resolved = resolveCall(call, fileSymbols, globalSymbolIndex, callCounts);
+    if (resolved && !seenEdges.has(resolved.edge.id)) {
+      seenEdges.add(resolved.edge.id);
+      resolvedCalls.push(resolved);
+    }
+  }
+  for (const resolvedCall of resolvedCalls) {
+    const actualEdgeKey = resolvedCall.edge.sourceId + "-" + (resolvedCall.resolved ? resolvedCall.edge.targetId : resolvedCall.edge.targetId.replace("unresolved:", ""));
+    resolvedCall.edge.callCount = callCounts.get(actualEdgeKey) || 1;
+  }
+  return resolvedCalls;
+}
+function buildGlobalSymbolIndex(allSymbols) {
+  const index = /* @__PURE__ */ new Map();
+  for (const symbol of allSymbols) {
+    if (symbol.exported) {
+      if (!index.has(symbol.name)) {
+        index.set(symbol.name, symbol);
+      }
+    }
+  }
+  return index;
+}
+
+// src/analyzer/index.ts
+var DEFAULT_CONFIG2 = {
+  include: [],
+  exclude: [],
+  respectGitignore: true,
+  languages: [],
+  extractCalls: true,
+  maxFiles: 1e4
+};
+async function analyzeCodebase(config) {
+  const startTime = performance.now();
+  const errors = [];
+  const fullConfig = {
+    ...DEFAULT_CONFIG2,
+    ...config,
+    rootPath: path4.resolve(config.rootPath)
+  };
+  const { onProgress } = config;
+  onProgress?.({ phase: "scanning", current: 0, total: 1 });
+  const scanConfig = {
+    rootPath: fullConfig.rootPath,
+    include: fullConfig.include,
+    exclude: fullConfig.exclude,
+    respectGitignore: fullConfig.respectGitignore,
+    maxFiles: fullConfig.maxFiles
+  };
+  let scanResult;
+  try {
+    scanResult = await scanDirectory(scanConfig);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to scan directory: ${message}`);
+  }
+  const { directories, files, skipped } = scanResult;
+  const fileIndex = buildFileIndex(
+    files.map((f) => ({ id: f.id, path: f.path }))
+  );
+  const parseStartTime = performance.now();
+  const allSymbols = [];
+  const fileSymbolMap = /* @__PURE__ */ new Map();
+  const fileContentMap = /* @__PURE__ */ new Map();
+  const detectedLanguages = /* @__PURE__ */ new Set();
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const filePath = path4.join(fullConfig.rootPath, file.path);
+    onProgress?.({
+      phase: "parsing",
+      current: i + 1,
+      total: files.length,
+      currentFile: file.path
+    });
+    try {
+      const content = fs5.readFileSync(filePath, "utf-8");
+      fileContentMap.set(file.id, content);
+      const result = await extractSymbols(filePath, content, file.id);
+      file.metrics = result.metrics;
+      file.symbols = result.symbols.map((s) => s.id);
+      if (file.language !== "unknown") {
+        detectedLanguages.add(file.language);
+      }
+      allSymbols.push(...result.symbols);
+      fileSymbolMap.set(file.id, result.symbols);
+      if (result.parseErrors) {
+        for (const error of result.parseErrors) {
+          errors.push({ file: file.path, message: error, phase: "parse" });
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push({ file: file.path, message, phase: "parse" });
+    }
+  }
+  const parseTime = performance.now() - parseStartTime;
+  const importEdges = [];
+  const callEdges = [];
+  let resolvedImports = 0;
+  let resolvedCalls = 0;
+  const globalSymbolIndex = buildGlobalSymbolIndex(allSymbols);
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const filePath = path4.join(fullConfig.rootPath, file.path);
+    const content = fileContentMap.get(file.id);
+    const fileSymbols = fileSymbolMap.get(file.id) || [];
+    onProgress?.({
+      phase: "resolving",
+      current: i + 1,
+      total: files.length,
+      currentFile: file.path
+    });
+    if (!content) continue;
+    try {
+      const imports = await resolveFileImports(
+        filePath,
+        content,
+        file.id,
+        fullConfig.rootPath,
+        fileIndex
+      );
+      for (const imp of imports) {
+        importEdges.push(imp.edge);
+        if (imp.resolved) {
+          resolvedImports++;
+        }
+      }
+      if (fullConfig.extractCalls) {
+        const calls = await resolveFileCalls(
+          filePath,
+          content,
+          fileSymbols,
+          globalSymbolIndex
+        );
+        for (const call of calls) {
+          callEdges.push(call.edge);
+          if (call.resolved) {
+            resolvedCalls++;
+          }
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push({ file: file.path, message, phase: "resolve" });
+    }
+  }
+  aggregateDirectoryMetrics(directories, files);
+  const totalTime = performance.now() - startTime;
+  const graph = {
+    directories,
+    files,
+    symbols: allSymbols,
+    imports: importEdges,
+    calls: callEdges,
+    metadata: {
+      rootPath: fullConfig.rootPath,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalFiles: files.length,
+      totalDirectories: directories.length,
+      totalSymbols: allSymbols.length,
+      languages: Array.from(detectedLanguages),
+      analysisDurationMs: totalTime
+    }
+  };
+  const stats = {
+    totalFiles: files.length,
+    totalDirectories: directories.length,
+    totalSymbols: allSymbols.length,
+    totalImports: importEdges.length,
+    totalCalls: callEdges.length,
+    resolvedImports,
+    resolvedCalls,
+    parseTime,
+    totalTime,
+    skippedFiles: skipped.length
+  };
+  return { graph, stats, errors };
+}
+function aggregateDirectoryMetrics(directories, files) {
+  const dirMap = /* @__PURE__ */ new Map();
+  for (const dir of directories) {
+    dirMap.set(dir.id, dir);
+  }
+  const filesByDir = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dirFiles = filesByDir.get(file.directoryId) || [];
+    dirFiles.push(file);
+    filesByDir.set(file.directoryId, dirFiles);
+  }
+  const sortedDirs = [...directories].sort((a, b) => b.depth - a.depth);
+  for (const dir of sortedDirs) {
+    const dirFiles = filesByDir.get(dir.id) || [];
+    let totalLoc = dirFiles.reduce((sum, f) => sum + f.metrics.loc, 0);
+    let totalFiles = dirFiles.length;
+    for (const childId of dir.children) {
+      const child = dirMap.get(childId);
+      if (child) {
+        totalLoc += child.metrics.totalLoc;
+        totalFiles += child.metrics.fileCount;
+      }
+    }
+    dir.metrics = {
+      fileCount: totalFiles,
+      totalLoc
+    };
+  }
+}
+function resetAnalyzer() {
+  resetParserManager();
+  resetLanguageRegistry();
+}
+
 // src/index.ts
 var VERSION = "0.1.0";
-function createCodeViz(_config) {
-  console.log("codeviz", VERSION);
-}
 export {
+  AggregateNode as AggregateNodeComponent,
+  BundledEdge as BundledEdgeComponent,
+  CallEdge as CallEdgeComponent,
+  CodeMap as CodeMapComponent,
+  DEFAULT_ANIMATION_CONFIG,
+  DEFAULT_CODEMAP_CONFIG,
+  DEFAULT_DARK_SIGMA_THEME,
+  DEFAULT_LAYOUT_CONFIG,
+  DEFAULT_LIGHT_SIGMA_THEME,
+  DEFAULT_SIGMA_THEME,
+  DEFAULT_ZOOM_LEVELS,
+  EDGE_SIZES,
+  FileNode as FileNodeComponent,
+  Flow,
+  ImportEdge as ImportEdgeComponent,
+  NODE_SIZES,
+  OverlayLayer,
+  OverlayPort,
+  PortalOverlayLayer,
+  SVGOverlayLayer,
+  ScopeNode as ScopeNodeComponent,
+  SigmaRenderer,
+  SymbolNode as SymbolNodeComponent,
+  ThemeProvider,
   VERSION,
-  createCodeViz
+  analyzeCodebase,
+  assignClusterColors,
+  assignInitialPositions,
+  boundingBoxFromCorners,
+  boundingBoxesOverlap,
+  brightenColor,
+  buildDirectoryGraph,
+  buildFileIndex,
+  buildGlobalSymbolIndex,
+  calculateNodeSize,
+  calculateOverlayPosition,
+  clampPosition,
+  codeGraphToGraphology,
+  codeMapToReactFlowEdges,
+  codeMapToReactFlowNodes,
+  computeDirectoryForces,
+  computeEdges,
+  computeHierarchy,
+  computeLayout,
+  computeZoomLevels,
+  createBoundingBox,
+  createEdgeReducer,
+  createNodeReducer,
+  createOverlayPort,
+  createScopeColorGetter,
+  darkTheme,
+  darken,
+  detectCommunities,
+  detectLanguage,
+  dimColor,
+  distance,
+  edgeTypes,
+  expandBoundingBox,
+  extractCalls,
+  extractImports,
+  extractSymbols,
+  extractSymbolsFromFile,
+  formatLoc,
+  formatNumber,
+  generateCallEdgeId,
+  generateDirectoryId,
+  generateFileId,
+  generateImportEdgeId,
+  generateScopeDepthColors,
+  generateSymbolId,
+  getAnchorOffset,
+  getBasename,
+  getBoundingBoxCenter,
+  getChildScopes,
+  getClusterStats,
+  getContrastRatio,
+  getDefaultExpandedScopes,
+  getDefaultTheme,
+  getDirectory,
+  getDirectoryConnectionWeight,
+  getDirectoryPosition,
+  getEdgeLabel,
+  getEdgesAtZoomLevel,
+  getEntityId,
+  getExtension,
+  getFA2Settings,
+  getFileIcon,
+  getFilename,
+  getFilesInDirectory,
+  getIconName,
+  getLanguageRegistry,
+  getLayoutDuration,
+  getLuminance,
+  getMediumFileLabel,
+  getNodeCluster,
+  getNodeKey,
+  getNodeMass,
+  getNodeOpacityAtLevel,
+  getNodeSizeAtLevel,
+  getNodesInCluster,
+  getParentDirectories,
+  getParserManager,
+  getPathDepth,
+  getPositionsAtDepth,
+  getRootScopes,
+  getScaledNodeSize,
+  getScopeByDirectoryId,
+  getScopeDepthColor,
+  getShortFileLabel,
+  getSigmaTheme,
+  getSymbolIcon,
+  getSymbolKindLabel,
+  getTextColorForBackground,
+  getTheme,
+  getThemeIds,
+  getVisibleEdges,
+  getVisibleNodes,
+  getVisibleScopes,
+  getZoomLevel,
+  getZoomLevelFromZoom,
+  graphToScreen,
+  hexToRgb,
+  hslToHex,
+  hslToRgb,
+  isCodeFile,
+  isPointInBoundingBox,
+  lerp,
+  lightTheme,
+  lighten,
+  matchesPattern,
+  mergeTheme,
+  mix,
+  nexusToGraphology,
+  nodeTypes,
+  normalizePath,
+  normalizePositions,
+  positionAllNodes,
+  positionNodesInScope,
+  registerTheme,
+  removeAllOverlaps,
+  removeOverlapsInScope,
+  resetAnalyzer,
+  resetLanguageRegistry,
+  resetParserManager,
+  resolveFileCalls,
+  resolveImport,
+  rgbToHex,
+  rgbToHsl,
+  rgbaToCss,
+  saturate,
+  scaleSize,
+  scanDirectory,
+  screenToGraph,
+  shouldUseDarkText,
+  shrinkBoundingBox,
+  structureToGraphology,
+  truncateLabel,
+  uniformPadding,
+  unionBoundingBoxes,
+  useCurrentTheme,
+  useIsDarkTheme,
+  useLayout,
+  useOverlayPort,
+  useSigma,
+  useTheme,
+  withOpacity
 };