@opentrace/components 0.1.1-rc.47 → 0.1.1-rc.62

package/dist/pipeline.cjs

@@ -0,0 +1,3481 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const LANGUAGE_MAP = {
+  ".py": "python",
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".rb": "ruby",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".swift": "swift"
+};
+function getExtension(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot === -1 || dot === path.length - 1) return "";
+  return path.slice(dot);
+}
+function parentDir$1(path) {
+  const slash = path.lastIndexOf("/");
+  if (slash <= 0) return "";
+  return path.slice(0, slash);
+}
+function detectLanguage(ext) {
+  return LANGUAGE_MAP[ext] ?? null;
+}
+function ensureDirChain(repoId, dirPath, dirNodes, rels) {
+  if (!dirPath || dirNodes.has(dirPath)) return;
+  const parent = parentDir$1(dirPath);
+  ensureDirChain(repoId, parent, dirNodes, rels);
+  const dirId = `${repoId}/${dirPath}`;
+  const name = dirPath.includes("/") ? dirPath.slice(dirPath.lastIndexOf("/") + 1) : dirPath;
+  dirNodes.set(dirPath, {
+    id: dirId,
+    type: "Directory",
+    name,
+    properties: { path: dirPath }
+  });
+  const targetId = parent ? `${repoId}/${parent}` : repoId;
+  rels.push({
+    id: `${dirId}->DEFINED_IN->${targetId}`,
+    type: "DEFINED_IN",
+    source_id: dirId,
+    target_id: targetId
+  });
+}
+const MANIFEST_BASENAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "go.mod",
+  "requirements.txt",
+  "pyproject.toml",
+  "Cargo.toml"
+]);
+const LOCK_BASENAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "go.sum",
+  "poetry.lock",
+  "Cargo.lock",
+  "uv.lock"
+]);
+function isManifestFile(path) {
+  const basename = path.split("/").pop() ?? "";
+  if (LOCK_BASENAMES.has(basename)) return false;
+  return MANIFEST_BASENAMES.has(basename);
+}
+function parseManifest(path, content) {
+  const basename = path.split("/").pop() ?? "";
+  switch (basename) {
+    case "package.json":
+      return parsePackageJson(content, path);
+    case "go.mod":
+      return parseGoMod(content, path);
+    case "requirements.txt":
+      return parseRequirementsTxt(content, path);
+    case "pyproject.toml":
+      return parsePyprojectToml(content, path);
+    case "Cargo.toml":
+      return parseCargoToml(content, path);
+    default:
+      return {
+        dependencies: [],
+        errors: [`Unsupported manifest: ${basename}`]
+      };
+  }
+}
+function packageId(registry, name) {
+  return `pkg:${registry}:${name}`;
+}
+function packageSourceUrl(registry, name) {
+  switch (registry) {
+    case "npm":
+      return `https://www.npmjs.com/package/${name}`;
+    case "pypi":
+      return `https://pypi.org/project/${name}/`;
+    case "go":
+      return `https://pkg.go.dev/${name}`;
+    case "crates":
+      return `https://crates.io/crates/${name}`;
+    case "rubygems":
+      return `https://rubygems.org/gems/${name}`;
+    default:
+      return void 0;
+  }
+}
+function parsePackageJson(content, source) {
+  const errors = [];
+  const deps = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (e) {
+    return { dependencies: [], errors: [`Failed to parse ${source}: ${e}`] };
+  }
+  const sections = [
+    ["dependencies", "runtime"],
+    ["devDependencies", "dev"],
+    ["peerDependencies", "peer"],
+    ["optionalDependencies", "optional"]
+  ];
+  for (const [key, depType] of sections) {
+    const section = parsed[key];
+    if (!section || typeof section !== "object") continue;
+    for (const [name, version] of Object.entries(
+      section
+    )) {
+      deps.push({
+        name,
+        version: typeof version === "string" ? version : "",
+        registry: "npm",
+        source,
+        dependencyType: depType
+      });
+    }
+  }
+  return { dependencies: deps, errors };
+}
+function parseGoMod(content, source) {
+  const deps = [];
+  const errors = [];
+  const blockRe = /require\s*\(([\s\S]*?)\)/g;
+  let match;
+  while ((match = blockRe.exec(content)) !== null) {
+    const block = match[1];
+    for (const line of block.split("\n")) {
+      const dep = parseGoRequireLine(line, source);
+      if (dep) deps.push(dep);
+    }
+  }
+  const singleRe = /^require\s+(\S+)\s+(\S+)(.*)$/gm;
+  while ((match = singleRe.exec(content)) !== null) {
+    const depType = match[3]?.includes("// indirect") ? "indirect" : "runtime";
+    deps.push({
+      name: match[1],
+      version: match[2],
+      registry: "go",
+      source,
+      dependencyType: depType
+    });
+  }
+  return { dependencies: deps, errors };
+}
+function parseGoRequireLine(line, source) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("//")) return null;
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 2) return null;
+  const depType = trimmed.includes("// indirect") ? "indirect" : "runtime";
+  return {
+    name: parts[0],
+    version: parts[1],
+    registry: "go",
+    source,
+    dependencyType: depType
+  };
+}
+function parseRequirementsTxt(content, source) {
+  const deps = [];
+  const errors = [];
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("-") || line.startsWith("http"))
+      continue;
+    const match = line.match(
+      /^([A-Za-z0-9_.-]+)(?:\[.*?\])?\s*([<>=!~]+\s*\S+)?/
+    );
+    if (!match) continue;
+    const rawName = match[1];
+    const version = match[2]?.trim() ?? "*";
+    deps.push({
+      name: normalizePyName(rawName),
+      version,
+      registry: "pypi",
+      source,
+      dependencyType: "runtime"
+    });
+  }
+  return { dependencies: deps, errors };
+}
+function parsePyprojectToml(content, source) {
+  const deps = [];
+  const errors = [];
+  const lines = content.split("\n");
+  let i = 0;
+  let currentSection = "";
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.startsWith("[")) {
+      currentSection = line;
+      i++;
+      continue;
+    }
+    if (currentSection === "[project]" && line.startsWith("dependencies")) {
+      const eqIdx = line.indexOf("=");
+      if (eqIdx === -1) {
+        i++;
+        continue;
+      }
+      const afterEq = line.slice(eqIdx + 1).trim();
+      if (afterEq.startsWith("[")) {
+        const arrayContent = collectTomlArray(lines, i, eqIdx + 1);
+        for (const item of parseTomlStringArray(arrayContent)) {
+          const dep = parsePep508(item, source);
+          if (dep) deps.push(dep);
+        }
+      }
+      i++;
+      continue;
+    }
+    if (currentSection === "[tool.poetry.dependencies]") {
+      const eqIdx = line.indexOf("=");
+      if (eqIdx > 0 && !line.startsWith("#") && !line.startsWith("[")) {
+        const name = line.slice(0, eqIdx).trim();
+        if (name === "python") {
+          i++;
+          continue;
+        }
+        const value = line.slice(eqIdx + 1).trim();
+        const version = value.replace(/^["']|["']$/g, "");
+        deps.push({
+          name: normalizePyName(name),
+          version,
+          registry: "pypi",
+          source,
+          dependencyType: "runtime"
+        });
+      }
+    }
+    if (currentSection.startsWith("[project.optional-dependencies")) {
+      if (line.includes("=") && !line.startsWith("#")) {
+        const eqIdx = line.indexOf("=");
+        const afterEq = line.slice(eqIdx + 1).trim();
+        if (afterEq.startsWith("[")) {
+          const arrayContent = collectTomlArray(lines, i, eqIdx + 1);
+          for (const item of parseTomlStringArray(arrayContent)) {
+            const dep = parsePep508(item, source, "optional");
+            if (dep) deps.push(dep);
+          }
+        }
+      }
+    }
+    i++;
+  }
+  return { dependencies: deps, errors };
+}
+function collectTomlArray(lines, startLine, charOffset) {
+  let result = lines[startLine].slice(charOffset).trim();
+  if (bracketsClosed(result)) return result;
+  for (let i = startLine + 1; i < lines.length; i++) {
+    result += "\n" + lines[i];
+    if (bracketsClosed(result)) break;
+  }
+  return result;
+}
+function bracketsClosed(s) {
+  let depth = 0;
+  for (const ch of s) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    if (depth === 0 && s.indexOf("[") !== -1) return true;
+  }
+  return false;
+}
+function parseTomlStringArray(raw) {
+  const items = [];
+  const re = /["']([^"']+)["']/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    items.push(m[1]);
+  }
+  return items;
+}
+function parsePep508(spec, source, depType = "runtime") {
+  const trimmed = spec.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(
+    /^([A-Za-z0-9_.-]+)(?:\[.*?\])?\s*([<>=!~]+.*)?$/
+  );
+  if (!match) return null;
+  return {
+    name: normalizePyName(match[1]),
+    version: match[2]?.trim() ?? "*",
+    registry: "pypi",
+    source,
+    dependencyType: depType
+  };
+}
+function normalizePyName(name) {
+  return name.toLowerCase().replace(/_/g, "-");
+}
+function parseCargoToml(content, source) {
+  const deps = [];
+  const errors = [];
+  const lines = content.split("\n");
+  let currentSection = "";
+  const depSections = {
+    "[dependencies]": "runtime",
+    "[dev-dependencies]": "dev",
+    "[build-dependencies]": "dev"
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.startsWith("[")) {
+      currentSection = line;
+      continue;
+    }
+    if (line.startsWith("#") || !line) continue;
+    const depType = depSections[currentSection];
+    if (!depType) continue;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx <= 0) continue;
+    const name = line.slice(0, eqIdx).trim();
+    const value = line.slice(eqIdx + 1).trim();
+    let version = "*";
+    if (value.startsWith('"') || value.startsWith("'")) {
+      version = value.replace(/^["']|["']$/g, "");
+    } else if (value.startsWith("{")) {
+      const verMatch = value.match(/version\s*=\s*["']([^"']+)["']/);
+      if (verMatch) version = verMatch[1];
+    }
+    deps.push({
+      name,
+      version,
+      registry: "crates",
+      source,
+      dependencyType: depType
+    });
+  }
+  return { dependencies: deps, errors };
+}
+function npmPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+  }
+  return specifier.split("/")[0];
+}
+const PARSEABLE_LANGUAGES = /* @__PURE__ */ new Set([
+  "python",
+  "typescript",
+  "javascript",
+  "go",
+  "rust",
+  "java",
+  "kotlin",
+  "csharp",
+  "c",
+  "cpp",
+  "ruby",
+  "swift"
+]);
+function* execute$3(input, ctx) {
+  const { repo } = input;
+  const repoId = `${repo.owner}/${repo.repo}`;
+  yield {
+    kind: "stage_start",
+    phase: "scanning",
+    message: `Scanning ${repo.files.length} files`
+  };
+  const repoProps = { ref: repo.ref };
+  if (repo.url) repoProps.source_uri = repo.url;
+  if (repo.provider) repoProps.provider = repo.provider;
+  const repoNode = {
+    id: repoId,
+    type: "Repository",
+    name: repoId,
+    properties: repoProps
+  };
+  const dirNodes = /* @__PURE__ */ new Map();
+  const fileNodes = [];
+  const structureRels = [];
+  const parseableFiles = [];
+  const packageNodes = /* @__PURE__ */ new Map();
+  const dependencyRels = [];
+  let goModulePath;
+  const knownPaths = /* @__PURE__ */ new Set();
+  const pathToFileId = /* @__PURE__ */ new Map();
+  const total = repo.files.length;
+  for (let i = 0; i < repo.files.length; i++) {
+    if (ctx.cancelled) break;
+    const file = repo.files[i];
+    const ext = getExtension(file.path);
+    const language = detectLanguage(ext);
+    const fileId = `${repoId}/${file.path}`;
+    const fileName = file.path.includes("/") ? file.path.slice(file.path.lastIndexOf("/") + 1) : file.path;
+    const fileProps = {
+      path: file.path,
+      extension: ext
+    };
+    if (language) fileProps.language = language;
+    if (repo.url) {
+      fileProps.source_uri = `${repo.url}/blob/${repo.ref}/${file.path}`;
+    }
+    fileNodes.push({
+      id: fileId,
+      type: "File",
+      name: fileName,
+      properties: fileProps
+    });
+    const dir = parentDir$1(file.path);
+    ensureDirChain(repoId, dir, dirNodes, structureRels);
+    const parentId = dir ? `${repoId}/${dir}` : repoId;
+    structureRels.push({
+      id: `${fileId}->DEFINED_IN->${parentId}`,
+      type: "DEFINED_IN",
+      source_id: fileId,
+      target_id: parentId
+    });
+    if (language && PARSEABLE_LANGUAGES.has(language)) {
+      parseableFiles.push(file);
+    }
+    knownPaths.add(file.path);
+    pathToFileId.set(file.path, fileId);
+    if (isManifestFile(file.path)) {
+      const manifestResult = parseManifest(file.path, file.content);
+      if (file.path.endsWith("go.mod") || file.path.includes("/go.mod")) {
+        const moduleMatch = file.content.match(/^module\s+(\S+)/m);
+        if (moduleMatch) goModulePath = moduleMatch[1];
+      }
+      for (const dep of manifestResult.dependencies) {
+        const pkgId = packageId(dep.registry, dep.name);
+        if (!packageNodes.has(pkgId)) {
+          const props = {
+            registry: dep.registry,
+            version: dep.version
+          };
+          const sourceUrl = packageSourceUrl(dep.registry, dep.name);
+          if (sourceUrl) props.source_uri = sourceUrl;
+          packageNodes.set(pkgId, {
+            id: pkgId,
+            type: "Package",
+            name: dep.name,
+            properties: props
+          });
+        }
+        dependencyRels.push({
+          id: `${repoId}->DEPENDS_ON->${pkgId}`,
+          type: "DEPENDS_ON",
+          source_id: repoId,
+          target_id: pkgId,
+          properties: {
+            version: dep.version,
+            dependency_type: dep.dependencyType,
+            source: dep.source
+          }
+        });
+      }
+    }
+    yield {
+      kind: "stage_progress",
+      phase: "scanning",
+      message: `Scanning ${file.path}`,
+      detail: { current: i + 1, total, fileName: file.path }
+    };
+  }
+  const structureNodes = [
+    repoNode,
+    ...dirNodes.values(),
+    ...fileNodes,
+    ...packageNodes.values()
+  ];
+  yield {
+    kind: "stage_stop",
+    phase: "scanning",
+    message: `Scanned ${fileNodes.length} files, ${dirNodes.size} directories, ${packageNodes.size} packages`,
+    nodes: structureNodes,
+    relationships: [...structureRels, ...dependencyRels]
+  };
+  return {
+    repo,
+    repoId,
+    repoNode,
+    dirNodes,
+    fileNodes,
+    structureRels,
+    parseableFiles,
+    packageNodes,
+    dependencyRels,
+    goModulePath,
+    knownPaths,
+    pathToFileId
+  };
+}
+function extractDocstring(bodyNode) {
+  if (!bodyNode) return void 0;
+  const first = bodyNode.namedChildren[0];
+  if (!first || first.type !== "expression_statement") return void 0;
+  const strNode = first.namedChildren[0];
+  if (!strNode || strNode.type !== "string") return void 0;
+  const raw = strNode.text;
+  const stripped = raw.replace(/^("""|''')\s?/, "").replace(/\s?("""|''')$/, "");
+  return stripped.trim() || void 0;
+}
+function extractPython(rootNode) {
+  const symbols = walkNode$2(rootNode);
+  return { symbols, language: "python", rootNode };
+}
+function walkNode$2(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    if (child.type === "class_definition") {
+      const sym = extractClass$2(child);
+      if (sym) symbols.push(sym);
+    } else if (child.type === "function_definition") {
+      const sym = extractFunction$3(child);
+      if (sym) symbols.push(sym);
+    } else if (child.type === "decorated_definition") {
+      for (const sub of child.children) {
+        if (sub.type === "class_definition") {
+          const sym = extractClass$2(sub);
+          if (sym) symbols.push(sym);
+        } else if (sub.type === "function_definition") {
+          const sym = extractFunction$3(sub);
+          if (sym) symbols.push(sym);
+        }
+      }
+    }
+  }
+  return symbols;
+}
+function extractClass$2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const bodyNode = node.childForFieldName("body");
+  const children = walkClassBody$1(node);
+  const superclasses = extractBaseClasses(node);
+  const docs = extractDocstring(bodyNode);
+  return {
+    name: nameNode.text,
+    kind: "class",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: null,
+    children,
+    calls: [],
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    superclasses: superclasses.length > 0 ? superclasses : void 0,
+    docs
+  };
+}
+function extractBaseClasses(node) {
+  const bases = [];
+  const argList = node.childForFieldName("superclasses");
+  if (!argList) return bases;
+  for (const child of argList.children) {
+    if (child.type === "identifier") {
+      bases.push(child.text);
+    } else if (child.type === "attribute") {
+      bases.push(child.text);
+    } else if (child.type === "keyword_argument") ;
+  }
+  return bases;
+}
+function walkClassBody$1(node) {
+  const body = node.childForFieldName("body");
+  if (!body) return [];
+  const methods = [];
+  for (const child of body.children) {
+    if (child.type === "function_definition") {
+      const sym = extractFunction$3(child);
+      if (sym) methods.push(sym);
+    } else if (child.type === "decorated_definition") {
+      for (const sub of child.children) {
+        if (sub.type === "function_definition") {
+          const sym = extractFunction$3(sub);
+          if (sym) methods.push(sym);
+        }
+      }
+    }
+  }
+  return methods;
+}
+function extractFunction$3(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const paramsNode = node.childForFieldName("parameters");
+  const signature = paramsNode ? paramsNode.text : null;
+  const paramTypes = paramsNode ? extractParamTypes(paramsNode) : null;
+  const bodyNode = node.childForFieldName("body");
+  const calls = bodyNode ? collectCalls$2(bodyNode) : [];
+  const docs = extractDocstring(bodyNode);
+  return {
+    name: nameNode.text,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar: null,
+    receiverType: null,
+    paramTypes,
+    docs
+  };
+}
+function extractParamTypes(paramsNode) {
+  const types = {};
+  for (const child of paramsNode.children) {
+    if (child.type === "typed_parameter" || child.type === "typed_default_parameter") {
+      let nameNode = null;
+      for (const sub of child.children) {
+        if (sub.type === "identifier") {
+          nameNode = sub;
+          break;
+        }
+      }
+      const typeNode = child.childForFieldName("type");
+      if (nameNode && typeNode) {
+        const paramName = nameNode.text;
+        if (paramName === "self" || paramName === "cls") continue;
+        const typeText = typeNode.text;
+        const leaf = typeText.includes(".") ? typeText.split(".").pop() : typeText;
+        types[paramName] = leaf;
+      }
+    }
+  }
+  return Object.keys(types).length > 0 ? types : null;
+}
+function collectCalls$2(node) {
+  const calls = [];
+  for (const child of node.children) {
+    if (child.type === "call") {
+      const funcNode = child.childForFieldName("function");
+      if (funcNode && funcNode.type === "identifier") {
+        calls.push({ name: funcNode.text, receiver: null, kind: "bare" });
+      } else if (funcNode && funcNode.type === "attribute") {
+        const objNode = funcNode.childForFieldName("object");
+        const attrNode = funcNode.childForFieldName("attribute");
+        if (objNode && attrNode) {
+          calls.push({
+            name: attrNode.text,
+            receiver: objNode.text,
+            kind: "attribute"
+          });
+        }
+      }
+    }
+    calls.push(...collectCalls$2(child));
+  }
+  return calls;
+}
+const CLASS_TYPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "abstract_class_declaration"
+]);
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "generator_function_declaration"
+]);
+const METHOD_TYPES = /* @__PURE__ */ new Set(["method_definition", "public_field_definition"]);
+function extractJSDoc(node) {
+  let prev = node.previousNamedSibling;
+  if ((!prev || prev.type !== "comment") && node.parent?.type === "export_statement") {
+    prev = node.parent.previousNamedSibling;
+  }
+  if (!prev || prev.type !== "comment") return void 0;
+  const text = prev.text;
+  if (!text.startsWith("/**")) return void 0;
+  const cleaned = text.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
+  return cleaned || void 0;
+}
+function extractTypeScript(rootNode, language = "typescript") {
+  const symbols = walkNode$1(rootNode);
+  return { symbols, language, rootNode };
+}
+function walkNode$1(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    if (CLASS_TYPES.has(child.type)) {
+      const sym = extractClass$1(child);
+      if (sym) symbols.push(sym);
+    } else if (FUNCTION_TYPES.has(child.type)) {
+      const sym = extractFunction$2(child);
+      if (sym) symbols.push(sym);
+    } else if (child.type === "lexical_declaration") {
+      symbols.push(...extractLexicalDeclaration(child));
+    } else if (child.type === "export_statement") {
+      symbols.push(...walkNode$1(child));
+    }
+  }
+  return symbols;
+}
+function extractClass$1(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const children = walkClassBody(node);
+  const { superclasses, interfaces } = extractClassHeritage(node);
+  const docs = extractJSDoc(node);
+  return {
+    name: nameNode.text,
+    kind: "class",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: null,
+    children,
+    calls: [],
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    superclasses: superclasses.length > 0 ? superclasses : void 0,
+    interfaces: interfaces.length > 0 ? interfaces : void 0,
+    docs
+  };
+}
+function extractClassHeritage(node) {
+  const superclasses = [];
+  const interfaces = [];
+  for (const child of node.children) {
+    if (child.type === "class_heritage") {
+      for (const clause of child.children) {
+        if (clause.type === "extends_clause") {
+          superclasses.push(...collectHeritageNames(clause));
+        } else if (clause.type === "implements_clause") {
+          interfaces.push(...collectHeritageNames(clause));
+        }
+      }
+    }
+  }
+  return { superclasses, interfaces };
+}
+function collectHeritageNames(clause) {
+  const names = [];
+  for (const child of clause.children) {
+    if (child.type === "identifier" || child.type === "type_identifier") {
+      names.push(child.text);
+    } else if (child.type === "generic_type") {
+      const nameNode = child.childForFieldName("name");
+      if (nameNode) names.push(nameNode.text);
+    }
+  }
+  return names;
+}
+function walkClassBody(node) {
+  const body = node.childForFieldName("body");
+  if (!body) return [];
+  const methods = [];
+  for (const child of body.children) {
+    if (METHOD_TYPES.has(child.type)) {
+      const sym = extractMethod$1(child);
+      if (sym) methods.push(sym);
+    }
+  }
+  return methods;
+}
+function extractFunction$2(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const paramsNode = node.childForFieldName("parameters");
+  const signature = paramsNode ? paramsNode.text : null;
+  const bodyNode = node.childForFieldName("body");
+  const calls = bodyNode ? collectCalls$1(bodyNode) : [];
+  const docs = extractJSDoc(node);
+  return {
+    name: nameNode.text,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    docs
+  };
+}
+function extractMethod$1(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const paramsNode = node.childForFieldName("parameters");
+  const signature = paramsNode ? paramsNode.text : null;
+  const bodyNode = node.childForFieldName("body");
+  const calls = bodyNode ? collectCalls$1(bodyNode) : [];
+  const docs = extractJSDoc(node);
+  return {
+    name: nameNode.text,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    docs
+  };
+}
+function extractLexicalDeclaration(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    if (child.type === "variable_declarator") {
+      const nameNode = child.childForFieldName("name");
+      const valueNode = child.childForFieldName("value");
+      if (!nameNode || !valueNode) continue;
+      const name = nameNode.text;
+      if (valueNode.type === "arrow_function" || valueNode.type === "function_expression") {
+        const sym = extractArrowFunction(name, node, valueNode);
+        if (sym) symbols.push(sym);
+      } else if (valueNode.type === "class") {
+        const sym = extractClassExpression(name, node, valueNode);
+        if (sym) symbols.push(sym);
+      }
+    }
+  }
+  return symbols;
+}
+function extractArrowFunction(name, declNode, valueNode) {
+  const paramsNode = valueNode.childForFieldName("parameters");
+  const signature = paramsNode ? paramsNode.text : null;
+  const bodyNode = valueNode.childForFieldName("body");
+  const calls = bodyNode ? collectCalls$1(bodyNode) : [];
+  const docs = extractJSDoc(declNode);
+  return {
+    name,
+    kind: "function",
+    startLine: declNode.startPosition.row + 1,
+    endLine: declNode.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    docs
+  };
+}
+function extractClassExpression(name, declNode, valueNode) {
+  const children = walkClassBody(valueNode);
+  const { superclasses, interfaces } = extractClassHeritage(valueNode);
+  const docs = extractJSDoc(declNode);
+  return {
+    name,
+    kind: "class",
+    startLine: declNode.startPosition.row + 1,
+    endLine: declNode.endPosition.row + 1,
+    signature: null,
+    children,
+    calls: [],
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    superclasses: superclasses.length > 0 ? superclasses : void 0,
+    interfaces: interfaces.length > 0 ? interfaces : void 0,
+    docs
+  };
+}
+function collectCalls$1(node) {
+  const calls = [];
+  if (node.type === "call_expression") {
+    const funcNode = node.childForFieldName("function");
+    if (funcNode && funcNode.type === "identifier") {
+      calls.push({ name: funcNode.text, receiver: null, kind: "bare" });
+    } else if (funcNode && funcNode.type === "member_expression") {
+      const objNode = funcNode.childForFieldName("object");
+      const propNode = funcNode.childForFieldName("property");
+      if (objNode && propNode) {
+        calls.push({
+          name: propNode.text,
+          receiver: objNode.text,
+          kind: "attribute"
+        });
+      }
+    }
+  }
+  for (const child of node.children) {
+    calls.push(...collectCalls$1(child));
+  }
+  return calls;
+}
+function extractGoDoc(node) {
+  const comments = [];
+  let prev = node.previousNamedSibling;
+  while (prev && prev.type === "comment") {
+    comments.push(prev.text);
+    prev = prev.previousNamedSibling;
+  }
+  if (comments.length === 0) return void 0;
+  const cleaned = comments.reverse().map((line) => line.replace(/^\/\/\s?/, "")).join("\n").trim();
+  return cleaned || void 0;
+}
+function extractGo(rootNode) {
+  const symbols = walkNode(rootNode);
+  return { symbols, language: "go", rootNode };
+}
+function walkNode(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    let sym = null;
+    if (child.type === "type_declaration") {
+      sym = extractTypeDecl(child);
+    } else if (child.type === "function_declaration") {
+      sym = extractFunction$1(child);
+    } else if (child.type === "method_declaration") {
+      sym = extractMethod(child);
+    }
+    if (sym) {
+      sym.docs = extractGoDoc(child);
+      symbols.push(sym);
+    }
+  }
+  return symbols;
+}
+function extractTypeDecl(node) {
+  for (const child of node.children) {
+    if (child.type === "type_spec") {
+      const nameNode = child.childForFieldName("name");
+      if (!nameNode) continue;
+      const typeNode = child.childForFieldName("type");
+      if (typeNode && (typeNode.type === "struct_type" || typeNode.type === "interface_type")) {
+        const isInterface = typeNode.type === "interface_type";
+        const methods = isInterface ? extractInterfaceMethods(typeNode) : [];
+        const subtype = isInterface ? "interface" : "struct";
+        const embedded = isInterface ? extractEmbeddedInterfaces(typeNode) : extractEmbeddedStructs(typeNode);
+        return {
+          name: nameNode.text,
+          kind: "class",
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          signature: null,
+          children: methods,
+          calls: [],
+          receiverVar: null,
+          receiverType: null,
+          paramTypes: null,
+          subtype,
+          interfaces: isInterface && embedded.length > 0 ? embedded : void 0,
+          superclasses: !isInterface && embedded.length > 0 ? embedded : void 0
+        };
+      }
+    }
+  }
+  return null;
+}
+function extractEmbeddedInterfaces(node) {
+  const names = [];
+  for (const child of node.children) {
+    if (child.type === "type_elem") {
+      for (const sub of child.children) {
+        if (sub.type === "type_identifier") {
+          names.push(sub.text);
+        } else if (sub.type === "qualified_type") {
+          names.push(sub.text);
+        }
+      }
+    }
+  }
+  return names;
+}
+function extractEmbeddedStructs(node) {
+  const names = [];
+  for (const child of node.children) {
+    if (child.type === "field_declaration_list") {
+      for (const field of child.children) {
+        if (field.type === "field_declaration") {
+          const nameNode = field.childForFieldName("name");
+          const typeNode = field.childForFieldName("type");
+          if (!nameNode && typeNode) {
+            if (typeNode.type === "type_identifier") {
+              names.push(typeNode.text);
+            } else if (typeNode.type === "pointer_type") {
+              for (const sub of typeNode.children) {
+                if (sub.type === "type_identifier") {
+                  names.push(sub.text);
+                  break;
+                }
+              }
+            } else if (typeNode.type === "qualified_type") {
+              names.push(typeNode.text);
+            }
+          }
+        }
+      }
+    }
+  }
+  return names;
+}
+function extractInterfaceMethods(node) {
+  const methods = [];
+  for (const child of node.children) {
+    if (child.type === "method_elem") {
+      const nameNode = child.childForFieldName("name");
+      if (nameNode) {
+        const paramsNode = child.childForFieldName("parameters");
+        methods.push({
+          name: nameNode.text,
+          kind: "function",
+          startLine: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+          signature: paramsNode ? paramsNode.text : null,
+          children: [],
+          calls: [],
+          receiverVar: null,
+          receiverType: null,
+          paramTypes: null
+        });
+      }
+    }
+  }
+  return methods;
+}
+function extractFunction$1(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const paramsNode = node.childForFieldName("parameters");
+  const signature = paramsNode ? paramsNode.text : null;
+  const bodyNode = node.childForFieldName("body");
+  const calls = bodyNode ? collectCalls(bodyNode) : [];
+  return {
+    name: nameNode.text,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null
+  };
+}
+function extractMethod(node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const paramsNode = node.childForFieldName("parameters");
+  const receiverNode = node.childForFieldName("receiver");
+  const parts = [];
+  let receiverVar = null;
+  let receiverType = null;
+  if (receiverNode) {
+    parts.push(receiverNode.text);
+    [receiverVar, receiverType] = parseReceiver(receiverNode);
+  }
+  if (paramsNode) {
+    parts.push(paramsNode.text);
+  }
+  const signature = parts.length > 0 ? parts.join(" ") : null;
+  const bodyNode = node.childForFieldName("body");
+  const calls = bodyNode ? collectCalls(bodyNode) : [];
+  return {
+    name: nameNode.text,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls,
+    receiverVar,
+    receiverType,
+    paramTypes: null
+  };
+}
+function parseReceiver(receiverNode) {
+  for (const child of receiverNode.children) {
+    if (child.type === "parameter_declaration") {
+      let varName = null;
+      let typeName = null;
+      const nameChild = child.childForFieldName("name");
+      if (nameChild) varName = nameChild.text;
+      const typeChild = child.childForFieldName("type");
+      if (typeChild) {
+        if (typeChild.type === "pointer_type") {
+          for (const sub of typeChild.children) {
+            if (sub.type === "type_identifier") {
+              typeName = sub.text;
+              break;
+            }
+          }
+        } else if (typeChild.type === "type_identifier") {
+          typeName = typeChild.text;
+        }
+      }
+      return [varName, typeName];
+    }
+  }
+  return [null, null];
+}
+function collectCalls(node) {
+  const calls = [];
+  for (const child of node.children) {
+    if (child.type === "call_expression") {
+      const funcNode = child.childForFieldName("function");
+      if (funcNode && funcNode.type === "identifier") {
+        calls.push({ name: funcNode.text, receiver: null, kind: "bare" });
+      } else if (funcNode && funcNode.type === "selector_expression") {
+        const operand = funcNode.childForFieldName("operand");
+        const field = funcNode.childForFieldName("field");
+        if (operand && field) {
+          calls.push({
+            name: field.text,
+            receiver: operand.text,
+            kind: "attribute"
+          });
+        }
+      }
+    }
+    calls.push(...collectCalls(child));
+  }
+  return calls;
+}
+const SUBTYPE_MAP = {
+  // C/C++
+  struct_specifier: "struct",
+  enum_specifier: "enum",
+  // C#
+  struct_declaration: "struct",
+  interface_declaration: "interface",
+  enum_declaration: "enum",
+  // Kotlin
+  object_declaration: "object",
+  // Ruby
+  module: "module",
+  // Rust
+  struct_item: "struct",
+  enum_item: "enum",
+  trait_item: "trait",
+  // Swift
+  protocol_declaration: "protocol"
+};
+const LANGUAGE_CONFIGS = {
+  c: {
+    classTypes: /* @__PURE__ */ new Set(["struct_specifier", "enum_specifier"]),
+    functionTypes: /* @__PURE__ */ new Set(["function_definition"]),
+    containerTypes: /* @__PURE__ */ new Set()
+  },
+  cpp: {
+    classTypes: /* @__PURE__ */ new Set([
+      "class_specifier",
+      "struct_specifier",
+      "enum_specifier"
+    ]),
+    functionTypes: /* @__PURE__ */ new Set(["function_definition"]),
+    containerTypes: /* @__PURE__ */ new Set(["class_specifier", "namespace_definition"])
+  },
+  csharp: {
+    classTypes: /* @__PURE__ */ new Set([
+      "class_declaration",
+      "interface_declaration",
+      "struct_declaration",
+      "enum_declaration"
+    ]),
+    functionTypes: /* @__PURE__ */ new Set(["method_declaration", "local_function_statement"]),
+    containerTypes: /* @__PURE__ */ new Set([
+      "class_declaration",
+      "interface_declaration",
+      "namespace_declaration"
+    ])
+  },
+  java: {
+    classTypes: /* @__PURE__ */ new Set([
+      "class_declaration",
+      "interface_declaration",
+      "enum_declaration"
+    ]),
+    functionTypes: /* @__PURE__ */ new Set(["method_declaration", "constructor_declaration"]),
+    containerTypes: /* @__PURE__ */ new Set(["class_declaration", "interface_declaration"])
+  },
+  kotlin: {
+    classTypes: /* @__PURE__ */ new Set(["class_declaration", "object_declaration"]),
+    functionTypes: /* @__PURE__ */ new Set(["function_declaration"]),
+    containerTypes: /* @__PURE__ */ new Set(["class_declaration", "object_declaration"])
+  },
+  ruby: {
+    classTypes: /* @__PURE__ */ new Set(["class", "module"]),
+    functionTypes: /* @__PURE__ */ new Set(["method", "singleton_method"]),
+    containerTypes: /* @__PURE__ */ new Set(["class", "module"])
+  },
+  rust: {
+    classTypes: /* @__PURE__ */ new Set(["struct_item", "enum_item", "trait_item"]),
+    functionTypes: /* @__PURE__ */ new Set(["function_item", "function_signature_item"]),
+    containerTypes: /* @__PURE__ */ new Set(["impl_item", "trait_item"])
+  },
+  swift: {
+    classTypes: /* @__PURE__ */ new Set([
+      "class_declaration",
+      "protocol_declaration",
+      "struct_declaration",
+      "enum_declaration"
+    ]),
+    functionTypes: /* @__PURE__ */ new Set(["function_declaration", "init_declaration"]),
+    containerTypes: /* @__PURE__ */ new Set([
+      "class_declaration",
+      "protocol_declaration",
+      "struct_declaration"
+    ])
+  }
+};
+function extractPrecedingDoc(node) {
+  const prev = node.previousNamedSibling;
+  if (!prev) return void 0;
+  if ((prev.type === "comment" || prev.type === "block_comment") && prev.text.startsWith("/**")) {
+    const cleaned = prev.text.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
+    return cleaned || void 0;
+  }
+  if (prev.type === "comment" || prev.type === "line_comment") {
+    const comments = [];
+    let cur = prev;
+    while (cur && (cur.type === "comment" || cur.type === "line_comment")) {
+      comments.push(cur.text);
+      cur = cur.previousNamedSibling;
+    }
+    const cleaned = comments.reverse().map((line) => line.replace(/^\/\/\/?\s?/, "")).join("\n").trim();
+    return cleaned || void 0;
+  }
+  return void 0;
+}
+function extractGeneric(rootNode, language) {
+  const config = LANGUAGE_CONFIGS[language];
+  if (!config) {
+    return { symbols: [], language, rootNode };
+  }
+  const symbols = walkTopLevel(rootNode, config);
+  return { symbols, language, rootNode };
+}
+function walkTopLevel(node, config) {
+  const symbols = [];
+  for (const child of node.children) {
+    const sym = extractNode(child, config);
+    if (sym) {
+      symbols.push(sym);
+    } else if (config.containerTypes.has(child.type)) {
+      const body = findBody(child);
+      if (body) {
+        symbols.push(...walkTopLevel(body, config));
+      }
+    } else {
+      symbols.push(...walkTopLevel(child, config));
+    }
+  }
+  return symbols;
+}
+function extractNode(node, config) {
+  let sym = null;
+  if (config.classTypes.has(node.type)) {
+    sym = extractClass(node, config);
+  } else if (config.functionTypes.has(node.type)) {
+    sym = extractFunction(node);
+  }
+  if (sym) {
+    sym.docs = extractPrecedingDoc(node);
+  }
+  return sym;
+}
+function extractClass(node, config) {
+  const name = extractName(node);
+  if (!name) return null;
+  const body = findBody(node);
+  const children = body ? extractMethods(body, config) : [];
+  const subtype = SUBTYPE_MAP[node.type];
+  const { superclasses, interfaces } = extractInheritance(node);
+  return {
+    name,
+    kind: "class",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: null,
+    children,
+    calls: [],
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null,
+    subtype,
+    superclasses: superclasses.length > 0 ? superclasses : void 0,
+    interfaces: interfaces.length > 0 ? interfaces : void 0
+  };
+}
+function extractFunction(node) {
+  const name = extractName(node);
+  if (!name) return null;
+  let paramsNode = node.childForFieldName("parameters");
+  if (!paramsNode) {
+    const decl = node.childForFieldName("declarator");
+    if (decl?.type === "function_declarator") {
+      paramsNode = decl.childForFieldName("parameters");
+    }
+  }
+  const signature = paramsNode ? paramsNode.text : null;
+  return {
+    name,
+    kind: "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature,
+    children: [],
+    calls: [],
+    receiverVar: null,
+    receiverType: null,
+    paramTypes: null
+  };
+}
+function extractInheritance(node) {
+  const superclasses = [];
+  const interfaces = [];
+  const superclassField = node.childForFieldName("superclass");
+  if (superclassField) {
+    for (const child of superclassField.children) {
+      if (child.type === "type_identifier" || child.type === "constant" || child.type === "scope_resolution") {
+        superclasses.push(child.text);
+      }
+    }
+    if (superclasses.length === 0) {
+      const names = collectTypeIdentifiers(superclassField);
+      superclasses.push(...names);
+    }
+  }
+  const interfacesField = node.childForFieldName("interfaces");
+  if (interfacesField) {
+    interfaces.push(...collectTypeIdentifiers(interfacesField));
+  }
+  for (const child of node.children) {
+    if (child.type === "base_class_clause" || child.type === "base_list" || child.type === "delegation_specifiers" || child.type === "type_inheritance_clause") {
+      superclasses.push(...collectTypeIdentifiers(child));
+    }
+  }
+  return { superclasses, interfaces };
+}
+function collectTypeIdentifiers(node) {
+  const names = [];
+  for (const child of node.children) {
+    if (child.type === "type_identifier" || child.type === "identifier" || child.type === "simple_identifier") {
+      names.push(child.text);
+    } else if (child.namedChildCount > 0) {
+      names.push(...collectTypeIdentifiers(child));
+    }
+  }
+  return names;
+}
+function extractMethods(body, config) {
+  const methods = [];
+  for (const child of body.children) {
+    if (config.functionTypes.has(child.type)) {
+      const sym = extractFunction(child);
+      if (sym) methods.push(sym);
+    } else if (config.classTypes.has(child.type)) {
+      const sym = extractClass(child, config);
+      if (sym) methods.push(sym);
+    }
+  }
+  return methods;
+}
+function extractName(node) {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode) {
+    return nameNode.text;
+  }
+  const declarator = node.childForFieldName("declarator");
+  if (declarator) {
+    if (declarator.type === "function_declarator") {
+      const inner = declarator.childForFieldName("declarator");
+      if (inner) return inner.text;
+    }
+    if (declarator.type === "identifier" || declarator.type === "field_identifier") {
+      return declarator.text;
+    }
+    const qName = declarator.childForFieldName("name");
+    if (qName) return qName.text;
+    return declarator.text;
+  }
+  for (const child of node.children) {
+    if (child.type === "identifier" || child.type === "type_identifier" || child.type === "simple_identifier" || child.type === "constant") {
+      return child.text;
+    }
+  }
+  return null;
+}
+function findBody(node) {
+  const body = node.childForFieldName("body");
+  if (body) return body;
+  for (const child of node.children) {
+    if (child.type === "field_declaration_list" || child.type === "declaration_list" || child.type === "class_body" || child.type === "enum_body" || child.type === "interface_body" || child.type === "block") {
+      return child;
+    }
+  }
+  return null;
+}
+let parsers = /* @__PURE__ */ new Map();
+function initParsers(map) {
+  parsers = map;
+}
+function getExtractor(language) {
+  switch (language) {
+    case "python":
+      return extractPython;
+    case "typescript":
+    case "javascript":
+      return (rootNode) => extractTypeScript(rootNode, language);
+    case "go":
+      return extractGo;
+    case "c":
+    case "cpp":
+    case "csharp":
+    case "java":
+    case "kotlin":
+    case "ruby":
+    case "rust":
+    case "swift":
+      return (rootNode) => extractGeneric(rootNode, language);
+    default:
+      return null;
+  }
+}
+function getParserForLanguage(language, ext) {
+  if (language === "typescript" && ext === ".tsx") {
+    return parsers.get("tsx") ?? parsers.get("typescript");
+  }
+  if (language === "javascript" && ext === ".jsx") {
+    return parsers.get("jsx") ?? parsers.get("javascript");
+  }
+  return parsers.get(language);
+}
+function parseFile(filePath, fileContent, repoId) {
+  const ext = getExtension(filePath);
+  const language = detectLanguage(ext);
+  if (!language) {
+    return {
+      nodes: [],
+      relationships: [],
+      classesExtracted: 0,
+      functionsExtracted: 0
+    };
+  }
+  const parser = getParserForLanguage(language, ext);
+  if (!parser) {
+    return {
+      nodes: [],
+      relationships: [],
+      classesExtracted: 0,
+      functionsExtracted: 0
+    };
+  }
+  const extractor = getExtractor(language);
+  if (!extractor) {
+    return {
+      nodes: [],
+      relationships: [],
+      classesExtracted: 0,
+      functionsExtracted: 0
+    };
+  }
+  try {
+    const tree = parser.parse(fileContent);
+    if (!tree) {
+      return {
+        nodes: [],
+        relationships: [],
+        classesExtracted: 0,
+        functionsExtracted: 0,
+        error: `${filePath}: parse returned null`
+      };
+    }
+    const result = extractor(tree.rootNode);
+    const fileId = `${repoId}/${filePath}`;
+    const nodes = [];
+    const rels = [];
+    const stats = { classesExtracted: 0, functionsExtracted: 0 };
+    for (const sym of result.symbols) {
+      convertSymbol(sym, fileId, nodes, rels, stats);
+    }
+    return { nodes, relationships: rels, ...stats };
+  } catch (err) {
+    return {
+      nodes: [],
+      relationships: [],
+      classesExtracted: 0,
+      functionsExtracted: 0,
+      error: `${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function processSymbol(symbol, parentId, language, registries, callInfos, nodes, rels, emittedNodeIds) {
+  const fileId = parentId.split("::")[0];
+  const namePart = symbol.receiverType ? `${symbol.receiverType}.${symbol.name}` : symbol.name;
+  const nodeId = `${parentId}::${namePart}`;
+  if (emittedNodeIds.has(nodeId)) {
+    return null;
+  }
+  emittedNodeIds.add(nodeId);
+  if (symbol.kind === "class") {
+    const props = {
+      language,
+      start_line: symbol.startLine,
+      end_line: symbol.endLine
+    };
+    if (symbol.signature) props.signature = symbol.signature;
+    if (symbol.superclasses) props.superclasses = symbol.superclasses;
+    if (symbol.interfaces) props.interfaces = symbol.interfaces;
+    if (symbol.subtype) props.subtype = symbol.subtype;
+    if (symbol.docs) props.docs = symbol.docs;
+    nodes.push({
+      id: nodeId,
+      type: "Class",
+      name: symbol.name,
+      properties: props
+    });
+    rels.push({
+      id: `${nodeId}->DEFINED_IN->${parentId}`,
+      type: "DEFINED_IN",
+      source_id: nodeId,
+      target_id: parentId
+    });
+    const symbolNode = {
+      id: nodeId,
+      name: symbol.name,
+      kind: "class",
+      fileId,
+      parentId,
+      receiverVar: null,
+      receiverType: null,
+      paramTypes: null,
+      children: []
+    };
+    addToRegistry(registries.nameRegistry, symbol.name, symbolNode);
+    registries.fileRegistry.get(fileId)?.set(symbol.name, symbolNode);
+    addToRegistry(registries.classRegistry, symbol.name, symbolNode);
+    for (const child of symbol.children) {
+      const childSymbolNode = processSymbol(
+        child,
+        nodeId,
+        language,
+        registries,
+        callInfos,
+        nodes,
+        rels,
+        emittedNodeIds
+      );
+      if (childSymbolNode) symbolNode.children.push(childSymbolNode);
+    }
+    return symbolNode;
+  } else {
+    const props = {
+      language,
+      start_line: symbol.startLine,
+      end_line: symbol.endLine
+    };
+    if (symbol.signature) props.signature = symbol.signature;
+    if (symbol.docs) props.docs = symbol.docs;
+    nodes.push({
+      id: nodeId,
+      type: "Function",
+      name: symbol.name,
+      properties: props
+    });
+    rels.push({
+      id: `${nodeId}->DEFINED_IN->${parentId}`,
+      type: "DEFINED_IN",
+      source_id: nodeId,
+      target_id: parentId
+    });
+    const symbolNode = {
+      id: nodeId,
+      name: symbol.name,
+      kind: "function",
+      fileId,
+      parentId,
+      receiverVar: symbol.receiverVar,
+      receiverType: symbol.receiverType,
+      paramTypes: symbol.paramTypes,
+      children: []
+    };
+    addToRegistry(registries.nameRegistry, symbol.name, symbolNode);
+    registries.fileRegistry.get(fileId)?.set(symbol.name, symbolNode);
+    if (symbol.calls.length > 0) {
+      callInfos.push({
+        callerNode: symbolNode,
+        calls: symbol.calls,
+        fileId
+      });
+    }
+    return symbolNode;
+  }
+}
+function addToRegistry(registry, name, node) {
+  const existing = registry.get(name);
+  if (existing) {
+    existing.push(node);
+  } else {
+    registry.set(name, [node]);
+  }
+}
+function countSymbols(symbols) {
+  let classes = 0;
+  let functions = 0;
+  for (const sym of symbols) {
+    if (sym.kind === "class") {
+      classes++;
+      const childCounts = countSymbols(sym.children);
+      classes += childCounts.classes;
+      functions += childCounts.functions;
+    } else {
+      functions++;
+    }
+  }
+  return { classes, functions };
+}
+function convertSymbol(sym, parentId, nodes, rels, stats) {
+  const namePart = sym.receiverType ? `${sym.receiverType}.${sym.name}` : sym.name;
+  const symId = `${parentId}::${namePart}`;
+  const nodeType = sym.kind === "class" ? "Class" : "Function";
+  const props = {
+    start_line: sym.startLine,
+    end_line: sym.endLine
+  };
+  if (sym.signature) props.signature = sym.signature;
+  if (sym.docs) props.docs = sym.docs;
+  if (sym.superclasses) props.superclasses = sym.superclasses;
+  if (sym.interfaces) props.interfaces = sym.interfaces;
+  if (sym.subtype) props.subtype = sym.subtype;
+  nodes.push({
+    id: symId,
+    type: nodeType,
+    name: sym.name,
+    properties: props
+  });
+  rels.push({
+    id: `${symId}->DEFINED_IN->${parentId}`,
+    type: "DEFINED_IN",
+    source_id: symId,
+    target_id: parentId
+  });
+  if (sym.kind === "class") {
+    stats.classesExtracted++;
+    for (const child of sym.children) {
+      if (child.kind === "function" && child.name === sym.name) continue;
+      convertSymbol(child, symId, nodes, rels, stats);
+    }
+  } else {
+    stats.functionsExtracted++;
+  }
+}
+function analyzePythonImports(rootNode, filePath, knownFiles) {
+  const internal = {};
+  const external = {};
+  const fileDir = parentDir(filePath);
+  for (const child of rootNode.children) {
+    if (child.type === "import_statement") {
+      parsePythonImport(child, knownFiles, internal, external);
+    } else if (child.type === "import_from_statement") {
+      parsePythonFromImport(child, fileDir, knownFiles, internal, external);
+    }
+  }
+  return { internal, external };
+}
+function parsePythonImport(node, knownFiles, internal, external) {
+  for (const child of node.children) {
+    if (child.type === "dotted_name") {
+      const moduleName = child.text;
+      const candidates = moduleToPaths(moduleName);
+      let found = false;
+      for (const candidate of candidates) {
+        if (knownFiles.has(candidate)) {
+          const parts = moduleName.split(".");
+          internal[parts[parts.length - 1]] = candidate;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        const topLevel = moduleName.split(".")[0];
+        const name = normalizePyName(topLevel);
+        external[name] = packageId("pypi", name);
+      }
+    } else if (child.type === "aliased_import") {
+      const nameNode = child.childForFieldName("name");
+      const aliasNode = child.childForFieldName("alias");
+      if (nameNode && aliasNode) {
+        const moduleName = nameNode.text;
+        const alias = aliasNode.text;
+        const candidates = moduleToPaths(moduleName);
+        let found = false;
+        for (const candidate of candidates) {
+          if (knownFiles.has(candidate)) {
+            internal[alias] = candidate;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          const topLevel = moduleName.split(".")[0];
+          const name = normalizePyName(topLevel);
+          external[name] = packageId("pypi", name);
+        }
+      }
+    }
+  }
+}
+function parsePythonFromImport(node, fileDir, knownFiles, internal, external) {
+  const moduleNameNode = node.childForFieldName("module_name");
+  if (!moduleNameNode) return;
+  let moduleText = moduleNameNode.text;
+  let isRelative = false;
+  let baseDir = fileDir;
+  for (const child of node.children) {
+    if (child.type === "relative_import") {
+      isRelative = true;
+      for (const sub of child.children) {
+        if (sub.type === "dotted_name") {
+          moduleText = sub.text;
+        } else if (sub.type === "import_prefix") {
+          const dots = sub.text;
+          baseDir = fileDir;
+          for (let i = 0; i < dots.length - 1; i++) {
+            baseDir = parentDir(baseDir);
+          }
+          if (moduleText === moduleNameNode.text && moduleText.startsWith(".")) {
+            moduleText = "";
+          }
+        }
+      }
+      break;
+    }
+  }
+  let candidates;
+  if (isRelative) {
+    const basePath = moduleText ? baseDir ? `${baseDir}/${moduleText.replace(/\./g, "/")}` : moduleText.replace(/\./g, "/") : baseDir;
+    candidates = [`${basePath}.py`, `${basePath}/__init__.py`];
+  } else {
+    candidates = moduleToPaths(moduleText);
+  }
+  let found = false;
+  let resolvedPath = null;
+  for (const candidate of candidates) {
+    if (knownFiles.has(candidate)) {
+      const alias = moduleText ? moduleText.split(".").pop() : "";
+      if (alias) {
+        internal[alias] = candidate;
+      }
+      resolvedPath = candidate;
+      found = true;
+      break;
+    }
+  }
+  if (resolvedPath) {
+    for (const child of node.children) {
+      if (child.type === "dotted_name" && child !== node.childForFieldName("module_name")) {
+        internal[child.text] = resolvedPath;
+      } else if (child.type === "aliased_import") {
+        const nameNode = child.childForFieldName("name");
+        const aliasNode = child.childForFieldName("alias");
+        if (aliasNode) {
+          internal[aliasNode.text] = resolvedPath;
+        } else if (nameNode) {
+          internal[nameNode.text] = resolvedPath;
+        }
+      }
+    }
+  }
+  if (!found && !isRelative && moduleText) {
+    const topLevel = moduleText.split(".")[0];
+    const name = normalizePyName(topLevel);
+    external[name] = packageId("pypi", name);
+  }
+}
+function buildDirIndex(knownFiles) {
+  const index = /* @__PURE__ */ new Map();
+  const baseDirs = /* @__PURE__ */ new Map();
+  for (const filePath of knownFiles) {
+    if (!filePath.endsWith(".go")) continue;
+    const dir = parentDir(filePath);
+    if (!dir) continue;
+    if (!index.has(dir)) index.set(dir, filePath);
+    const dirBase = dir.split("/").pop();
+    let dirs = baseDirs.get(dirBase);
+    if (!dirs) {
+      dirs = /* @__PURE__ */ new Set();
+      baseDirs.set(dirBase, dirs);
+    }
+    dirs.add(dir);
+  }
+  for (const [dirBase, dirs] of baseDirs) {
+    if (dirs.size === 1) {
+      const dir = dirs.values().next().value;
+      index.set(dirBase, index.get(dir));
+    }
+  }
+  return index;
+}
+let cachedDirIndex = null;
+let cachedDirIndexSource = null;
+function getDirIndex(knownFiles) {
+  if (cachedDirIndex && cachedDirIndexSource === knownFiles) {
+    return cachedDirIndex;
+  }
+  cachedDirIndex = buildDirIndex(knownFiles);
+  cachedDirIndexSource = knownFiles;
+  return cachedDirIndex;
+}
+function resetDirIndexCache() {
+  cachedDirIndex = null;
+  cachedDirIndexSource = null;
+}
+function analyzeGoImports(rootNode, knownFiles, modulePath) {
+  const internal = {};
+  const external = {};
+  const dirIndex = getDirIndex(knownFiles);
+  for (const child of rootNode.children) {
+    if (child.type === "import_declaration") {
+      parseGoImportDecl(child, dirIndex, internal, external, modulePath);
+    }
+  }
+  return { internal, external };
+}
+function parseGoImportDecl(node, dirIndex, internal, external, modulePath) {
+  for (const child of node.children) {
+    if (child.type === "import_spec") {
+      parseGoImportSpec(child, dirIndex, internal, external, modulePath);
+    } else if (child.type === "import_spec_list") {
+      for (const spec of child.children) {
+        if (spec.type === "import_spec") {
+          parseGoImportSpec(spec, dirIndex, internal, external, modulePath);
+        }
+      }
+    }
+  }
+}
+function parseGoImportSpec(node, dirIndex, internal, external, modulePath) {
+  const pathNode = node.childForFieldName("path");
+  const nameNode = node.childForFieldName("name");
+  if (!pathNode) return;
+  const importPath = pathNode.text.replace(/^["']|["']$/g, "");
+  if (!importPath.includes(".")) return;
+  let alias;
+  if (nameNode) {
+    alias = nameNode.text;
+    if (alias === "_" || alias === ".") return;
+  } else {
+    alias = importPath.split("/").pop();
+  }
+  const fullMatch = dirIndex.get(importPath);
+  if (fullMatch) {
+    internal[alias] = fullMatch;
+    return;
+  }
+  if (modulePath && importPath.startsWith(modulePath + "/")) {
+    const repoRelDir = importPath.slice(modulePath.length + 1);
+    const relMatch = dirIndex.get(repoRelDir);
+    if (relMatch) {
+      internal[alias] = relMatch;
+      return;
+    }
+  }
+  const pkgName = importPath.split("/").pop();
+  const baseMatch = dirIndex.get(pkgName);
+  if (baseMatch) {
+    internal[alias] = baseMatch;
+    return;
+  }
+  const isOwnModule = modulePath && importPath.startsWith(modulePath);
+  if (!isOwnModule) {
+    const goModuleName = goModuleRoot(importPath);
+    external[goModuleName] = packageId("go", goModuleName);
+  }
+}
+function goModuleRoot(importPath) {
+  const parts = importPath.split("/");
+  const host = parts[0];
+  if (host === "github.com" || host === "gitlab.com" || host === "bitbucket.org" || host === "golang.org" || host === "google.golang.org" || host === "gopkg.in") {
+    return parts.slice(0, 3).join("/");
+  }
+  return parts.length >= 3 ? parts.slice(0, 3).join("/") : importPath;
+}
+function analyzeTypeScriptImports(rootNode, filePath, knownFiles) {
+  const internal = {};
+  const external = {};
+  const fileDir = parentDir(filePath);
+  for (const child of rootNode.children) {
+    if (child.type === "import_statement") {
+      parseTsImport(child, fileDir, knownFiles, internal, external);
+    } else if (child.type === "export_statement") {
+      parseTsReexport(child, fileDir, knownFiles, internal, external);
+    }
+  }
+  return { internal, external };
+}
+function parseTsImport(node, fileDir, knownFiles, internal, external) {
+  const sourceNode = node.childForFieldName("source");
+  if (!sourceNode) return;
+  const sourceText = sourceNode.text.replace(/^["']|["']$/g, "");
+  if (!sourceText.startsWith(".")) {
+    const pkgName = npmPackageName(sourceText);
+    external[pkgName] = packageId("npm", pkgName);
+    return;
+  }
+  const resolved = resolveRelativePath(fileDir, sourceText);
+  const extensions = [
+    "",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    "/index.ts",
+    "/index.tsx",
+    "/index.js"
+  ];
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    if (knownFiles.has(candidate)) {
+      const alias = sourceText.split("/").pop();
+      internal[alias] = candidate;
+      break;
+    }
+  }
+}
+function parseTsReexport(node, fileDir, knownFiles, internal, external) {
+  const sourceNode = node.childForFieldName("source");
+  if (!sourceNode) return;
+  const sourceText = sourceNode.text.replace(/^["']|["']$/g, "");
+  if (!sourceText.startsWith(".")) {
+    const pkgName = npmPackageName(sourceText);
+    external[pkgName] = packageId("npm", pkgName);
+    return;
+  }
+  const resolved = resolveRelativePath(fileDir, sourceText);
+  const extensions = [
+    "",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    "/index.ts",
+    "/index.tsx",
+    "/index.js"
+  ];
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    if (knownFiles.has(candidate)) {
+      const alias = sourceText.split("/").pop();
+      internal[alias] = candidate;
+      break;
+    }
+  }
+}
+function analyzeRustImports(rootNode, filePath, knownFiles) {
+  const internal = {};
+  const external = {};
+  const fileDir = parentDir(filePath);
+  for (const child of rootNode.children) {
+    if (child.type === "mod_item") {
+      const nameNode = child.childForFieldName("name");
+      if (!nameNode) continue;
+      const hasBody = child.children.some((c) => c.type === "declaration_list");
+      if (hasBody) continue;
+      const modName = nameNode.text;
+      const candidates = [
+        fileDir ? `${fileDir}/${modName}.rs` : `${modName}.rs`,
+        fileDir ? `${fileDir}/${modName}/mod.rs` : `${modName}/mod.rs`
+      ];
+      let found = false;
+      for (const candidate of candidates) {
+        if (knownFiles.has(candidate)) {
+          internal[modName] = candidate;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        external[modName] = packageId("crates", modName);
+      }
+    } else if (child.type === "use_declaration") {
+      parseRustUseDecl(child, fileDir, knownFiles, internal, external);
+    }
+  }
+  return { internal, external };
+}
+function parseRustUseDecl(node, fileDir, knownFiles, internal, external) {
+  for (const child of node.children) {
+    if (child.type === "scoped_identifier") {
+      const parts = child.text.split("::");
+      const root = parts[0];
+      resolveRustRoot(root, fileDir, knownFiles, internal, external);
+    } else if (child.type === "scoped_use_list") {
+      for (const sub of child.children) {
+        if (sub.type === "identifier" || sub.type === "scoped_identifier") {
+          const root = sub.text.split("::")[0];
+          resolveRustRoot(root, fileDir, knownFiles, internal, external);
+          break;
+        }
+      }
+    } else if (child.type === "identifier") {
+      resolveRustRoot(child.text, fileDir, knownFiles, internal, external);
+    }
+  }
+}
+function resolveRustRoot(root, fileDir, knownFiles, internal, external) {
+  if (root === "std" || root === "core" || root === "alloc" || root === "self" || root === "super" || root === "crate") {
+    return;
+  }
+  if (!internal[root]) {
+    const candidates = [
+      fileDir ? `${fileDir}/${root}.rs` : `${root}.rs`,
+      fileDir ? `${fileDir}/${root}/mod.rs` : `${root}/mod.rs`,
+      `src/${root}.rs`,
+      `src/${root}/mod.rs`
+    ];
+    for (const candidate of candidates) {
+      if (knownFiles.has(candidate)) {
+        internal[root] = candidate;
+        return;
+      }
+    }
+    external[root] = packageId("crates", root);
+  }
+}
+function analyzeRubyImports(rootNode, filePath, knownFiles) {
+  const internal = {};
+  const external = {};
+  const fileDir = parentDir(filePath);
+  for (const child of rootNode.children) {
+    if (child.type === "call") {
+      const funcNode = child.children[0];
+      if (!funcNode || funcNode.type !== "identifier") continue;
+      const funcName = funcNode.text;
+      if (funcName === "require_relative") {
+        const argNode = child.childForFieldName("arguments") ?? child.children.find((c) => c.type === "argument_list");
+        if (!argNode) continue;
+        const strNode = argNode.children.find((c) => c.type === "string");
+        if (!strNode) continue;
+        const contentNode = strNode.children.find(
+          (c) => c.type === "string_content"
+        );
+        if (!contentNode) continue;
+        const requirePath = contentNode.text;
+        const resolved = resolveRelativePath(fileDir, requirePath);
+        const candidates = [`${resolved}.rb`, resolved, `${resolved}/index.rb`];
+        for (const candidate of candidates) {
+          if (knownFiles.has(candidate)) {
+            const alias = requirePath.split("/").pop();
+            internal[alias] = candidate;
+            break;
+          }
+        }
+      } else if (funcName === "require") {
+        const argNode = child.childForFieldName("arguments") ?? child.children.find((c) => c.type === "argument_list");
+        if (!argNode) continue;
+        const strNode = argNode.children.find((c) => c.type === "string");
+        if (!strNode) continue;
+        const contentNode = strNode.children.find(
+          (c) => c.type === "string_content"
+        );
+        if (!contentNode) continue;
+        const gemName = contentNode.text;
+        const candidates = [
+          `${gemName}.rb`,
+          `lib/${gemName}.rb`,
+          `${gemName}/init.rb`
+        ];
+        let found = false;
+        for (const candidate of candidates) {
+          if (knownFiles.has(candidate)) {
+            internal[gemName] = candidate;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          const name = gemName.split("/")[0];
+          external[name] = packageId("rubygems", name);
+        }
+      }
+    }
+  }
+  return { internal, external };
+}
+function parentDir(path) {
+  const parts = path.split("/");
+  return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+}
+function moduleToPaths(moduleName) {
+  const path = moduleName.replace(/\./g, "/");
+  return [`${path}.py`, `${path}/__init__.py`];
+}
+function resolveRelativePath(baseDir, relative) {
+  const parts = relative.split("/");
+  const baseParts = baseDir ? baseDir.split("/") : [];
+  for (const part of parts) {
+    if (part === ".") continue;
+    else if (part === "..") {
+      if (baseParts.length > 0) baseParts.pop();
+    } else {
+      baseParts.push(part);
+    }
+  }
+  return baseParts.join("/");
+}
+function analyzeImports(rootNode, language, filePath, knownPaths, modulePath) {
+  switch (language) {
+    case "python":
+      return analyzePythonImports(rootNode, filePath, knownPaths);
+    case "go":
+      return analyzeGoImports(rootNode, knownPaths, modulePath);
+    case "typescript":
+    case "javascript":
+      return analyzeTypeScriptImports(rootNode, filePath, knownPaths);
+    case "rust":
+      return analyzeRustImports(rootNode, filePath, knownPaths);
+    case "ruby":
+      return analyzeRubyImports(rootNode, filePath, knownPaths);
+    default:
+      return { internal: {}, external: {} };
+  }
+}
+function* execute$2(input, ctx) {
+  const { parseableFiles, repoId, knownPaths, pathToFileId, goModulePath } = input;
+  const total = parseableFiles.length;
+  yield {
+    kind: "stage_start",
+    phase: "processing",
+    message: `Processing ${total} files`
+  };
+  const registries = {
+    nameRegistry: /* @__PURE__ */ new Map(),
+    fileRegistry: /* @__PURE__ */ new Map(),
+    classRegistry: /* @__PURE__ */ new Map(),
+    importRegistry: /* @__PURE__ */ new Map()
+  };
+  const allCallInfo = [];
+  const emittedNodeIds = /* @__PURE__ */ new Set();
+  const packageNodes = new Map(input.packageNodes);
+  const structureNodes = [
+    input.repoNode,
+    ...input.dirNodes.values(),
+    ...input.fileNodes,
+    ...input.packageNodes.values()
+  ];
+  let totalNodes = structureNodes.length;
+  let totalRels = input.structureRels.length + input.dependencyRels.length;
+  let filesProcessed = 0;
+  let classesExtracted = 0;
+  let functionsExtracted = 0;
+  const errors = [];
+  for (let i = 0; i < parseableFiles.length; i++) {
+    if (ctx.cancelled) break;
+    const file = parseableFiles[i];
+    const ext = getExtension(file.path);
+    const language = detectLanguage(ext);
+    const fileId = `${repoId}/${file.path}`;
+    if (!language) {
+      filesProcessed++;
+      continue;
+    }
+    const parser = getParserForLanguage(language, ext);
+    const extractor = getExtractor(language);
+    if (!parser || !extractor) {
+      filesProcessed++;
+      yield {
+        kind: "stage_progress",
+        phase: "processing",
+        message: `Processing ${file.path}`,
+        detail: { current: i + 1, total, fileName: file.path }
+      };
+      continue;
+    }
+    let extraction = null;
+    const nodes = [];
+    const rels = [];
+    try {
+      const tree = parser.parse(file.content);
+      if (!tree) {
+        errors.push(`${file.path}: parse returned null`);
+      } else {
+        extraction = extractor(tree.rootNode);
+        registries.fileRegistry.set(fileId, /* @__PURE__ */ new Map());
+        for (const sym of extraction.symbols) {
+          processSymbol(
+            sym,
+            fileId,
+            language,
+            registries,
+            allCallInfo,
+            nodes,
+            rels,
+            emittedNodeIds
+          );
+        }
+        const symCounts = countSymbols(extraction.symbols);
+        classesExtracted += symCounts.classes;
+        functionsExtracted += symCounts.functions;
+        const rootNode = extraction.rootNode;
+        if (rootNode) {
+          const importResult = analyzeImports(
+            rootNode,
+            language,
+            file.path,
+            knownPaths,
+            goModulePath
+          );
+          const fileImports = {};
+          const seenTargetFiles = /* @__PURE__ */ new Set();
+          for (const [alias, targetPath] of Object.entries(
+            importResult.internal
+          )) {
+            const targetFileId = pathToFileId.get(targetPath);
+            if (targetFileId) {
+              fileImports[alias] = targetFileId;
+              if (!seenTargetFiles.has(targetFileId)) {
+                seenTargetFiles.add(targetFileId);
+                rels.push({
+                  id: `${fileId}->IMPORTS->${targetFileId}`,
+                  type: "IMPORTS",
+                  source_id: fileId,
+                  target_id: targetFileId
+                });
+              }
+            }
+          }
+          registries.importRegistry.set(fileId, fileImports);
+          for (const [pkgName, pkgId] of Object.entries(
+            importResult.external
+          )) {
+            if (!packageNodes.has(pkgId)) {
+              const pkgNode = {
+                id: pkgId,
+                type: "Package",
+                name: pkgName,
+                properties: { registry: pkgId.split(":")[1] }
+              };
+              packageNodes.set(pkgId, pkgNode);
+              nodes.push(pkgNode);
+            }
+            rels.push({
+              id: `${fileId}->IMPORTS->${pkgId}`,
+              type: "IMPORTS",
+              source_id: fileId,
+              target_id: pkgId
+            });
+          }
+        }
+      }
+    } catch (err) {
+      errors.push(
+        `${file.path}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    totalNodes += nodes.length;
+    totalRels += rels.length;
+    filesProcessed++;
+    yield {
+      kind: "stage_progress",
+      phase: "processing",
+      message: `Processing ${file.path}`,
+      detail: { current: i + 1, total, fileName: file.path },
+      nodes: nodes.length > 0 ? nodes : void 0,
+      relationships: rels.length > 0 ? rels : void 0
+    };
+  }
+  yield {
+    kind: "stage_stop",
+    phase: "processing",
+    message: `Processed ${filesProcessed} files`,
+    errors: errors.length > 0 ? errors : void 0
+  };
+  return {
+    scanResult: input,
+    registries,
+    allCallInfo,
+    packageNodes,
+    stats: {
+      nodesCreated: totalNodes,
+      relationshipsCreated: totalRels,
+      filesProcessed,
+      classesExtracted,
+      functionsExtracted
+    }
+  };
+}
+function resolveCalls(callInfos, registries) {
+  const results = [];
+  for (const { callerNode, calls, fileId } of callInfos) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of calls) {
+      const dedupKey = `${ref.receiver ?? ""}:${ref.name}`;
+      if (seen.has(dedupKey)) continue;
+      if (ref.name === callerNode.name && ref.receiver === null) continue;
+      const resolved = resolveSingleCall(ref, callerNode, fileId, registries);
+      if (!resolved) continue;
+      seen.add(dedupKey);
+      results.push({
+        sourceId: callerNode.id,
+        targetId: resolved.targetId,
+        confidence: resolved.confidence
+      });
+    }
+  }
+  return results;
+}
+function resolveSingleCall(ref, callerNode, fileId, registries) {
+  const { nameRegistry, fileRegistry, classRegistry, importRegistry } = registries;
+  if (ref.kind === "attribute" && (ref.receiver === "self" || ref.receiver === "this")) {
+    const classNode = findEnclosingClass(callerNode, classRegistry);
+    if (classNode) {
+      for (const child of classNode.children) {
+        if (child.name === ref.name) {
+          return { targetId: child.id, confidence: 1 };
+        }
+      }
+    }
+    return null;
+  }
+  if (ref.kind === "attribute") {
+    if (callerNode.receiverVar && ref.receiver === callerNode.receiverVar && callerNode.receiverType) {
+      const candidates = nameRegistry.get(ref.name) ?? [];
+      for (const candidate of candidates) {
+        if (candidate.receiverType === callerNode.receiverType) {
+          return { targetId: candidate.id, confidence: 1 };
+        }
+      }
+    }
+  }
+  if (ref.kind === "attribute" && ref.receiver && callerNode.paramTypes) {
+    const typeName = callerNode.paramTypes[ref.receiver];
+    if (typeName && classRegistry.has(typeName)) {
+      const classCandidates = classRegistry.get(typeName);
+      for (const cls of classCandidates) {
+        for (const child of cls.children) {
+          if (child.name === ref.name) {
+            return { targetId: child.id, confidence: 0.7 };
+          }
+        }
+      }
+    }
+  }
+  if (ref.kind === "attribute" && ref.receiver && classRegistry.has(ref.receiver)) {
+    const classCandidates = classRegistry.get(ref.receiver);
+    const sorted = [...classCandidates].sort(
+      (a, b) => (a.fileId === fileId ? 0 : 1) - (b.fileId === fileId ? 0 : 1)
+    );
+    for (const cls of sorted) {
+      for (const child of cls.children) {
+        if (child.name === ref.name) {
+          const targetFileId = child.id.split("::")[0];
+          const conf = targetFileId === fileId ? 1 : 0.9;
+          return { targetId: child.id, confidence: conf };
+        }
+      }
+    }
+    const candidates = nameRegistry.get(ref.name) ?? [];
+    for (const candidate of candidates) {
+      if (candidate.receiverType === ref.receiver) {
+        const targetFileId = candidate.id.split("::")[0];
+        const conf = targetFileId === fileId ? 1 : 0.9;
+        return { targetId: candidate.id, confidence: conf };
+      }
+    }
+    return null;
+  }
+  if (ref.kind === "attribute" && ref.receiver) {
+    const fileImports = importRegistry.get(fileId);
+    if (fileImports) {
+      const targetFileId = fileImports[ref.receiver];
+      if (targetFileId) {
+        const targetNames = fileRegistry.get(targetFileId);
+        if (targetNames) {
+          const target = targetNames.get(ref.name);
+          if (target) {
+            return { targetId: target.id, confidence: 0.9 };
+          }
+        }
+      }
+    }
+  }
+  if (ref.kind === "bare") {
+    const fileImports = importRegistry.get(fileId);
+    if (fileImports) {
+      const targetFileId = fileImports[ref.name];
+      if (targetFileId) {
+        const targetNames = fileRegistry.get(targetFileId);
+        if (targetNames) {
+          const target = targetNames.get(ref.name);
+          if (target) {
+            if (target.kind === "class") {
+              for (const child of target.children) {
+                if (child.name === "__init__" || child.name === "constructor") {
+                  return { targetId: child.id, confidence: 0.9 };
+                }
+              }
+            }
+            return { targetId: target.id, confidence: 0.9 };
+          }
+        }
+      }
+    }
+  }
+  if (ref.kind === "bare" && classRegistry.has(ref.name)) {
+    const classCandidates = classRegistry.get(ref.name);
+    const sorted = [...classCandidates].sort(
+      (a, b) => (a.fileId === fileId ? 0 : 1) - (b.fileId === fileId ? 0 : 1)
+    );
+    for (const cls2 of sorted) {
+      for (const child of cls2.children) {
+        if (child.name === "__init__" || child.name === "constructor") {
+          const targetFileId2 = child.id.split("::")[0];
+          const conf2 = targetFileId2 === fileId ? 1 : 0.8;
+          return { targetId: child.id, confidence: conf2 };
+        }
+      }
+    }
+    const cls = sorted[0];
+    const targetFileId = cls.id.split("::")[0];
+    const conf = targetFileId === fileId ? 1 : 0.8;
+    return { targetId: cls.id, confidence: conf };
+  }
+  if (ref.kind === "bare") {
+    const fileNames = fileRegistry.get(fileId);
+    if (fileNames) {
+      const target = fileNames.get(ref.name);
+      if (target) {
+        return { targetId: target.id, confidence: 1 };
+      }
+    }
+  }
+  if (ref.kind === "bare") {
+    const candidates = nameRegistry.get(ref.name) ?? [];
+    const crossFile = candidates.filter((c) => c.id.split("::")[0] !== fileId);
+    if (crossFile.length === 1) {
+      return { targetId: crossFile[0].id, confidence: 0.8 };
+    }
+  }
+  return null;
+}
+function findEnclosingClass(node, classRegistry) {
+  const parts = node.id.split("::");
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const potentialClassName = parts[i];
+    const candidates = classRegistry.get(potentialClassName);
+    if (candidates) {
+      for (const cls of candidates) {
+        if (node.id.startsWith(cls.id + "::")) {
+          return cls;
+        }
+      }
+    }
+  }
+  return null;
+}
+function resolvedCallsToRelationships(resolvedCalls) {
+  return resolvedCalls.map((call) => ({
+    id: `${call.sourceId}->CALLS->${call.targetId}`,
+    type: "CALLS",
+    source_id: call.sourceId,
+    target_id: call.targetId,
+    properties: { confidence: call.confidence }
+  }));
+}
+function* execute$1(input) {
+  const { registries, allCallInfo, stats } = input;
+  yield {
+    kind: "stage_start",
+    phase: "resolving",
+    message: `Resolving ${allCallInfo.length} call sites`
+  };
+  const resolvedCalls = resolveCalls(allCallInfo, registries);
+  const callRels = resolvedCallsToRelationships(resolvedCalls);
+  if (callRels.length > 0) {
+    yield {
+      kind: "stage_progress",
+      phase: "resolving",
+      message: `Resolved ${callRels.length} calls`,
+      relationships: callRels
+    };
+  }
+  yield {
+    kind: "stage_stop",
+    phase: "resolving",
+    message: `Resolved ${callRels.length} calls`
+  };
+  return {
+    nodesCreated: stats.nodesCreated,
+    relationshipsCreated: stats.relationshipsCreated + callRels.length,
+    filesProcessed: stats.filesProcessed,
+    classesExtracted: stats.classesExtracted,
+    functionsExtracted: stats.functionsExtracted
+  };
+}
+function* execute(inner, store) {
+  let nodesSaved = 0;
+  let relsSaved = 0;
+  for (const event of inner) {
+    if (event.nodes) {
+      for (const node of event.nodes) {
+        store.saveNode(node);
+      }
+      nodesSaved += event.nodes.length;
+    }
+    if (event.relationships) {
+      for (const rel of event.relationships) {
+        store.saveRelationship(rel);
+      }
+      relsSaved += event.relationships.length;
+    }
+    yield event;
+  }
+  yield {
+    kind: "stage_stop",
+    phase: "submitting",
+    message: `Saved ${nodesSaved} nodes and ${relsSaved} relationships`
+  };
+}
+const VERB_MAP = {
+  get: "Retrieves",
+  fetch: "Retrieves",
+  load: "Retrieves",
+  find: "Retrieves",
+  query: "Retrieves",
+  read: "Reads",
+  lookup: "Looks up",
+  set: "Updates",
+  update: "Updates",
+  modify: "Updates",
+  patch: "Updates",
+  put: "Updates",
+  validate: "Validates",
+  verify: "Validates",
+  check: "Validates",
+  ensure: "Ensures",
+  create: "Creates",
+  make: "Creates",
+  build: "Creates",
+  generate: "Creates",
+  new: "Creates",
+  add: "Adds",
+  insert: "Adds",
+  append: "Adds",
+  register: "Registers",
+  delete: "Removes",
+  remove: "Removes",
+  destroy: "Removes",
+  drop: "Removes",
+  unset: "Removes",
+  clear: "Clears",
+  parse: "Parses",
+  extract: "Extracts",
+  decode: "Decodes",
+  handle: "Handles",
+  process: "Processes",
+  run: "Runs",
+  execute: "Executes",
+  do: "Performs",
+  perform: "Performs",
+  convert: "Converts",
+  transform: "Converts",
+  to: "Converts to",
+  format: "Formats",
+  encode: "Encodes",
+  serialize: "Serializes",
+  marshal: "Serializes",
+  deserialize: "Deserializes",
+  unmarshal: "Deserializes",
+  is: "Checks whether",
+  has: "Checks whether",
+  can: "Checks whether",
+  should: "Checks whether",
+  init: "Initializes",
+  setup: "Initializes",
+  configure: "Configures",
+  start: "Starts",
+  stop: "Stops",
+  open: "Opens",
+  close: "Closes",
+  connect: "Connects",
+  disconnect: "Disconnects",
+  render: "Renders",
+  display: "Renders",
+  show: "Renders",
+  draw: "Renders",
+  paint: "Renders",
+  hide: "Hides",
+  send: "Sends",
+  emit: "Emits",
+  dispatch: "Dispatches",
+  publish: "Publishes",
+  broadcast: "Broadcasts",
+  notify: "Notifies",
+  receive: "Receives",
+  listen: "Listens for",
+  subscribe: "Subscribes to",
+  on: "Handles",
+  sort: "Sorts",
+  filter: "Filters",
+  map: "Maps",
+  reduce: "Reduces",
+  merge: "Merges",
+  join: "Joins",
+  split: "Splits",
+  group: "Groups",
+  flatten: "Flattens",
+  test: "Tests",
+  assert: "Tests",
+  expect: "Tests",
+  log: "Logs",
+  print: "Logs",
+  warn: "Logs warning for",
+  error: "Logs error for",
+  debug: "Logs debug info for",
+  write: "Writes",
+  save: "Saves",
+  store: "Stores",
+  cache: "Caches",
+  flush: "Flushes",
+  sync: "Synchronizes",
+  reset: "Resets",
+  refresh: "Refreshes",
+  reload: "Reloads",
+  retry: "Retries",
+  wrap: "Wraps",
+  unwrap: "Unwraps",
+  apply: "Applies",
+  resolve: "Resolves",
+  reject: "Rejects",
+  throw: "Throws",
+  raise: "Raises",
+  try: "Attempts",
+  await: "Awaits",
+  wait: "Waits for",
+  schedule: "Schedules",
+  defer: "Defers",
+  cancel: "Cancels",
+  abort: "Aborts",
+  clone: "Clones",
+  copy: "Copies",
+  compare: "Compares",
+  equals: "Checks equality of",
+  match: "Matches",
+  contains: "Checks whether contains",
+  include: "Includes",
+  exclude: "Excludes",
+  enable: "Enables",
+  disable: "Disables",
+  toggle: "Toggles",
+  mount: "Mounts",
+  unmount: "Unmounts",
+  use: "Uses",
+  with: "Configures with",
+  from: "Creates from",
+  of: "Creates"
+};
+const CLASS_SUFFIX_MAP = {
+  service: "Service",
+  handler: "Handler",
+  controller: "Controller",
+  factory: "Factory",
+  repository: "Repository",
+  repo: "Repository",
+  manager: "Manager",
+  provider: "Provider",
+  adapter: "Adapter",
+  middleware: "Middleware",
+  guard: "Guard",
+  interceptor: "Interceptor",
+  resolver: "Resolver",
+  validator: "Validator",
+  builder: "Builder",
+  parser: "Parser",
+  formatter: "Formatter",
+  converter: "Converter",
+  serializer: "Serializer",
+  client: "Client",
+  server: "Server",
+  router: "Router",
+  store: "Store",
+  cache: "Cache",
+  queue: "Queue",
+  pool: "Pool",
+  registry: "Registry",
+  observer: "Observer",
+  emitter: "Emitter",
+  listener: "Listener",
+  subscriber: "Subscriber",
+  publisher: "Publisher",
+  component: "Component",
+  module: "Module",
+  plugin: "Plugin",
+  helper: "Helper",
+  util: "Utility",
+  utils: "Utility",
+  error: "Error",
+  exception: "Exception",
+  model: "Model",
+  entity: "Entity",
+  dto: "DTO",
+  config: "Configuration",
+  options: "Options",
+  context: "Context",
+  state: "State",
+  hook: "Hook"
+};
+const FILE_PATTERNS = [
+  [/_test\.go$/, "Tests for"],
+  [/_test\.py$/, "Tests for"],
+  [/\.test\.[jt]sx?$/, "Tests for"],
+  [/\.spec\.[jt]sx?$/, "Tests for"],
+  [/^test_/, "Tests for"],
+  [/^conftest\.py$/, "Pytest fixtures and configuration"],
+  [/^setup\.[jt]s$/, "Setup configuration"],
+  [/^index\.[jt]sx?$/, "Barrel exports for"],
+  [/^main\.[a-z]+$/, "Application entry point"],
+  [/^mod\.rs$/, "Module declarations"],
+  [/^__init__\.py$/, "Package initialization for"],
+  [/^constants?\.[a-z]+$/, "Constants and configuration values"],
+  [/^types?\.[a-z]+$/, "Type definitions"],
+  [/^utils?\.[a-z]+$/, "Utility functions"],
+  [/^helpers?\.[a-z]+$/, "Helper functions"],
+  [/^middleware\.[a-z]+$/, "Middleware definitions"],
+  [/^routes?\.[a-z]+$/, "Route definitions"],
+  [/^models?\.[a-z]+$/, "Data model definitions"],
+  [/^schema\.[a-z]+$/, "Schema definitions"],
+  [/^migrations?/, "Database migration"],
+  [/^dockerfile/i, "Docker container configuration"],
+  [/^makefile$/i, "Build automation rules"],
+  [/^readme/i, "Project documentation"],
+  [/^changelog/i, "Version change history"],
+  [/^license/i, "License information"],
+  [/\.config\.[a-z]+$/, "Configuration for"],
+  [/rc\.[a-z]+$/, "Configuration for"]
+];
+const DIR_PATTERNS = {
+  api: "API layer",
+  apis: "API layer",
+  handlers: "Request handlers",
+  handler: "Request handlers",
+  controllers: "Request controllers",
+  controller: "Request controllers",
+  routes: "Route definitions",
+  routing: "Route definitions",
+  models: "Data models",
+  model: "Data models",
+  entities: "Data entities",
+  schema: "Schema definitions",
+  schemas: "Schema definitions",
+  services: "Service layer",
+  service: "Service layer",
+  middleware: "Middleware",
+  middlewares: "Middleware",
+  utils: "Utility functions",
+  util: "Utility functions",
+  helpers: "Helper functions",
+  helper: "Helper functions",
+  lib: "Library modules",
+  libs: "Library modules",
+  pkg: "Package modules",
+  internal: "Internal packages",
+  cmd: "Command entry points",
+  config: "Configuration",
+  configs: "Configuration",
+  tests: "Test suite",
+  test: "Test suite",
+  __tests__: "Test suite",
+  spec: "Test specifications",
+  specs: "Test specifications",
+  fixtures: "Test fixtures",
+  mocks: "Test mocks",
+  components: "UI components",
+  component: "UI components",
+  pages: "Page components",
+  views: "View components",
+  layouts: "Layout components",
+  hooks: "React hooks",
+  store: "State management",
+  stores: "State management",
+  state: "State management",
+  reducers: "State reducers",
+  actions: "State actions",
+  selectors: "State selectors",
+  types: "Type definitions",
+  interfaces: "Interface definitions",
+  constants: "Constants",
+  static: "Static assets",
+  assets: "Static assets",
+  public: "Public assets",
+  styles: "Stylesheets",
+  css: "Stylesheets",
+  docs: "Documentation",
+  doc: "Documentation",
+  scripts: "Build and utility scripts",
+  migrations: "Database migrations",
+  seeds: "Database seed data",
+  templates: "Templates",
+  i18n: "Internationalization",
+  locales: "Locale translations",
+  proto: "Protocol buffer definitions",
+  generated: "Generated code",
+  gen: "Generated code",
+  dist: "Build output",
+  build: "Build output",
+  vendor: "Vendored dependencies",
+  node_modules: "NPM dependencies",
+  bin: "Executable binaries",
+  examples: "Usage examples",
+  example: "Usage examples",
+  plugins: "Plugin modules",
+  extensions: "Extension modules",
+  auth: "Authentication and authorization",
+  security: "Security modules",
+  crypto: "Cryptographic utilities",
+  db: "Database layer",
+  database: "Database layer",
+  cache: "Caching layer",
+  queue: "Message queue handlers",
+  workers: "Background workers",
+  jobs: "Background jobs",
+  tasks: "Task definitions",
+  events: "Event handlers",
+  subscribers: "Event subscribers",
+  publishers: "Event publishers",
+  adapters: "Adapter implementations",
+  providers: "Service providers",
+  repositories: "Data repositories",
+  repository: "Data repositories",
+  clients: "External API clients",
+  sdk: "SDK modules",
+  common: "Shared common modules",
+  shared: "Shared modules",
+  core: "Core modules",
+  base: "Base classes and interfaces",
+  errors: "Error definitions",
+  exceptions: "Exception definitions",
+  validators: "Input validators",
+  validation: "Validation logic",
+  serializers: "Data serializers",
+  parsers: "Data parsers",
+  formatters: "Data formatters",
+  converters: "Data converters",
+  transformers: "Data transformers",
+  mappers: "Data mappers",
+  resolvers: "GraphQL resolvers",
+  guards: "Route guards",
+  interceptors: "Request interceptors",
+  decorators: "Decorators",
+  annotations: "Annotations",
+  factories: "Factory functions",
+  builders: "Builder patterns",
+  observers: "Observer implementations",
+  strategies: "Strategy pattern implementations",
+  commands: "Command implementations",
+  queries: "Query implementations",
+  notifications: "Notification handlers",
+  mailers: "Email sending",
+  logging: "Logging configuration",
+  monitoring: "Monitoring and metrics",
+  metrics: "Application metrics",
+  tracing: "Distributed tracing",
+  indexer: "Indexing pipeline",
+  graph: "Graph data structures",
+  summarizer: "Summarization modules",
+  embedder: "Embedding modules",
+  extractors: "Data extractors"
+};
+const KEYWORD_PATTERNS = [
+  {
+    domain: "database",
+    patterns: [
+      /\bsql\b/i,
+      /\bquery\b/i,
+      /\bSELECT\b/,
+      /\bINSERT\b/,
+      /\bUPDATE\b.*\bSET\b/,
+      /\bdb\./i,
+      /\bcursor\b/i,
+      /\bconnection\b/i,
+      /\bprisma\b/i,
+      /\bknex\b/i,
+      /\bsequelize\b/i,
+      /\bmongoose\b/i,
+      /\bsqlx\b/i,
+      /\borm\b/i,
+      /\bmigration\b/i,
+      /\bschema\b/i,
+      /\btable\b/i,
+      /\btransaction\b/i,
+      /\bcolumn\b/i
+    ]
+  },
+  {
+    domain: "auth",
+    patterns: [
+      /\bauth\b/i,
+      /\bjwt\b/i,
+      /\btoken\b/i,
+      /\bpassword\b/i,
+      /\blogin\b/i,
+      /\bsession\b/i,
+      /\boauth\b/i,
+      /\bbcrypt\b/i,
+      /\bcredential\b/i,
+      /\bpermission\b/i,
+      /\brole\b/i,
+      /\bacl\b/i,
+      /\bsignin\b/i,
+      /\bsignup\b/i
+    ]
+  },
+  {
+    domain: "http",
+    patterns: [
+      /\bhttp\b/i,
+      /\brequest\b/i,
+      /\bresponse\b/i,
+      /\bfetch\s*\(/i,
+      /\baxios\b/i,
+      /\bhandler\b/i,
+      /\bmiddleware\b/i,
+      /\bcors\b/i,
+      /\bendpoint\b/i,
+      /\broute\b/i,
+      /\bREST\b/i,
+      /\bgraphql\b/i,
+      /\bheader\b/i
+    ]
+  },
+  {
+    domain: "filesystem",
+    patterns: [
+      /\bfs\./i,
+      /\breadFile\b/i,
+      /\bwriteFile\b/i,
+      /\bpath\./i,
+      /\bstream\b/i,
+      /\bbuffer\b/i,
+      /\bmkdir\b/i,
+      /\bunlink\b/i,
+      /\bglob\b/i
+    ]
+  },
+  {
+    domain: "crypto",
+    patterns: [
+      /\bcrypto\b/i,
+      /\bencrypt\b/i,
+      /\bdecrypt\b/i,
+      /\bhash\b/i,
+      /\bsign\b/i,
+      /\bverify\b/i,
+      /\bcipher\b/i,
+      /\bhmac\b/i
+    ]
+  },
+  {
+    domain: "cache",
+    patterns: [
+      /\bcache\b/i,
+      /\bredis\b/i,
+      /\bmemcached\b/i,
+      /\bttl\b/i,
+      /\binvalidate\b/i,
+      /\bLRU\b/i
+    ]
+  },
+  {
+    domain: "queue",
+    patterns: [
+      /\bqueue\b/i,
+      /\bworker\b/i,
+      /\bjob\b/i,
+      /\bpublish\b/i,
+      /\bsubscribe\b/i,
+      /\bkafka\b/i,
+      /\brabbitmq\b/i,
+      /\bamqp\b/i
+    ]
+  },
+  {
+    domain: "config",
+    patterns: [
+      /\bconfig\b/i,
+      /\benv\b/i,
+      /\bsettings\b/i,
+      /\byaml\b/i,
+      /\bdotenv\b/i,
+      /\.env\b/i
+    ]
+  },
+  {
+    domain: "logging",
+    patterns: [
+      /\blogger\b/i,
+      /\bwinston\b/i,
+      /\bpino\b/i,
+      /\blogrus\b/i,
+      /\bslog\b/i,
+      /\blog\./i
+    ]
+  },
+  {
+    domain: "testing",
+    patterns: [
+      /\btest\b/i,
+      /\bassert\b/i,
+      /\bexpect\b/i,
+      /\bmock\b/i,
+      /\bstub\b/i,
+      /\bspy\b/i,
+      /\bfixture\b/i,
+      /\bjest\b/i,
+      /\bpytest\b/i
+    ]
+  },
+  {
+    domain: "async",
+    patterns: [
+      /\basync\b/i,
+      /\bawait\b/i,
+      /\bPromise\b/,
+      /\bgoroutine\b/i,
+      /\bchannel\b/i,
+      /\bconcurrent\b/i,
+      /\bparallel\b/i,
+      /\bmutex\b/i
+    ]
+  },
+  {
+    domain: "error",
+    patterns: [
+      /\btry\b/,
+      /\bcatch\b/,
+      /\bthrow\b/,
+      /\bError\b/,
+      /\bpanic\b/i,
+      /\brecover\b/i,
+      /\berrno\b/i
+    ]
+  },
+  {
+    domain: "validation",
+    patterns: [
+      /\bvalidate\b/i,
+      /\bsanitize\b/i,
+      /\bzod\b/i,
+      /\byup\b/i,
+      /\bjoi\b/i,
+      /\bregexp\b/i,
+      /\bregex\b/i
+    ]
+  },
+  {
+    domain: "websocket",
+    patterns: [
+      /\bwebsocket\b/i,
+      /\bws\./i,
+      /\bsocket\b/i,
+      /\bWebSocket\b/,
+      /\bemit\s*\(/i
+    ]
+  },
+  {
+    domain: "email",
+    patterns: [/\bemail\b/i, /\bsmtp\b/i, /\bsendmail\b/i, /\bmailer\b/i]
+  }
+];
+function splitIdentifier(name) {
+  const cleaned = name.replace(/^[_$]+/, "").replace(/[_$]+$/, "");
+  if (!cleaned) return [name];
+  const parts = cleaned.split(/[_-]+/).filter(Boolean);
+  const words = [];
+  for (const part of parts) {
+    const subWords = part.replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split("\0").filter(Boolean);
+    words.push(...subWords);
+  }
+  return words.length > 0 ? words : [name];
+}
+function wordsToPhrase(words) {
+  return words.map((w) => {
+    if (w.length <= 4 && w === w.toUpperCase() && /^[A-Z]+$/.test(w))
+      return w;
+    return w.toLowerCase();
+  }).join(" ");
+}
+function extractKeywords(source) {
+  if (!source) return [];
+  const found = [];
+  for (const kp of KEYWORD_PATTERNS) {
+    if (found.length >= 4) break;
+    for (const pat of kp.patterns) {
+      if (pat.test(source)) {
+        found.push(kp.domain);
+        break;
+      }
+    }
+  }
+  return found;
+}
+function formatKeywords(keywords) {
+  return keywords.length > 0 ? ` [${keywords.join(", ")}]` : "";
+}
+const CONSTRUCTOR_NAMES = /* @__PURE__ */ new Set([
+  "__init__",
+  "constructor",
+  "init",
+  "initialize",
+  "New"
+]);
+function isNonDescriptive(name) {
+  if (name.length <= 2) return true;
+  const lower = name.toLowerCase();
+  return [
+    "foo",
+    "bar",
+    "baz",
+    "tmp",
+    "temp",
+    "x",
+    "y",
+    "z",
+    "fn",
+    "cb",
+    "f",
+    "g"
+  ].includes(lower);
+}
+function summarizeFunction(name, _signature, _language, _lineCount, receiverType, source) {
+  if (CONSTRUCTOR_NAMES.has(name)) {
+    const subject = receiverType || "instance";
+    return `Initializes ${subject}`;
+  }
+  const lowerName = name.toLowerCase();
+  if (lowerName.startsWith("test_") || lowerName.startsWith("test")) {
+    const words2 = splitIdentifier(name);
+    const testWords = words2[0].toLowerCase() === "test" ? words2.slice(1) : words2;
+    if (testWords.length > 0) {
+      return `Tests ${wordsToPhrase(testWords)}`;
+    }
+    return `Tests ${name}`;
+  }
+  if (isNonDescriptive(name)) {
+    return `Function ${name}`;
+  }
+  const words = splitIdentifier(name);
+  if (words.length === 0) return `Function ${name}`;
+  const firstWord = words[0].toLowerCase();
+  const restWords = words.slice(1);
+  const verb = VERB_MAP[firstWord];
+  if (verb) {
+    const object = restWords.length > 0 ? ` ${wordsToPhrase(restWords)}` : "";
+    let prefix = "";
+    if (receiverType) {
+      prefix = `${receiverType} method that `;
+      const lowerVerb = verb.toLowerCase();
+      const result3 = `${prefix}${lowerVerb}${object}`;
+      const keywords3 = source ? extractKeywords(source) : [];
+      return result3 + formatKeywords(keywords3);
+    }
+    const result2 = `${verb}${object}`;
+    const keywords2 = source ? extractKeywords(source) : [];
+    return result2 + formatKeywords(keywords2);
+  }
+  const phrase = wordsToPhrase(words);
+  let result;
+  if (receiverType) {
+    result = `${receiverType} method for ${phrase}`;
+  } else {
+    result = phrase.charAt(0).toUpperCase() + phrase.slice(1);
+  }
+  const keywords = source ? extractKeywords(source) : [];
+  return result + formatKeywords(keywords);
+}
+const CRUD_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "read",
+  "get",
+  "find",
+  "update",
+  "delete",
+  "remove",
+  "save",
+  "list"
+]);
+function summarizeClass(name, childNames, source) {
+  const words = splitIdentifier(name);
+  const readableName = wordsToPhrase(words);
+  const capitalizedName = readableName.charAt(0).toUpperCase() + readableName.slice(1);
+  const lastWord = words[words.length - 1].toLowerCase();
+  const suffixLabel = CLASS_SUFFIX_MAP[lastWord];
+  let hasCrud = false;
+  if (childNames && childNames.length > 0) {
+    const lowerChildren = childNames.map(
+      (c) => splitIdentifier(c)[0].toLowerCase()
+    );
+    const crudCount = lowerChildren.filter((c) => CRUD_METHODS.has(c)).length;
+    hasCrud = crudCount >= 3;
+  }
+  let summary = capitalizedName;
+  if (hasCrud) {
+    summary += " for CRUD operations";
+  } else if (suffixLabel) {
+    if (words.length > 1) ;
+  }
+  if (childNames && childNames.length > 0) {
+    const methodList = childNames.slice(0, 5).join(", ");
+    const extra = childNames.length > 5 ? ` and ${childNames.length - 5} more` : "";
+    summary += ` with methods: ${methodList}${extra}`;
+  }
+  const keywords = source ? extractKeywords(source) : [];
+  return summary + formatKeywords(keywords);
+}
+function summarizeFile(fileName, symbolNames, language, _source) {
+  const lowerFile = fileName.toLowerCase();
+  for (const [pattern, prefix] of FILE_PATTERNS) {
+    if (pattern.test(lowerFile)) {
+      if (prefix.endsWith("for")) {
+        const baseName = fileName.replace(/_test\.\w+$/, "").replace(/\.test\.\w+$/, "").replace(/\.spec\.\w+$/, "").replace(/^test_/, "").replace(/\.\w+$/, "");
+        const subject = wordsToPhrase(splitIdentifier(baseName));
+        return `${prefix} ${subject}`;
+      }
+      if (prefix.endsWith("for") || prefix === "Barrel exports for") {
+        if (symbolNames && symbolNames.length > 0) {
+          const listing = symbolNames.slice(0, 3).join(", ");
+          const extra = symbolNames.length > 3 ? ` and ${symbolNames.length - 3} more` : "";
+          return `${prefix} ${listing}${extra}`;
+        }
+      }
+      return prefix;
+    }
+  }
+  if (symbolNames && symbolNames.length > 0) {
+    const listing = symbolNames.slice(0, 3).join(", ");
+    const extra = symbolNames.length > 3 ? ` and ${symbolNames.length - 3} more` : "";
+    const langNote = language ? ` ${language}` : "";
+    return `Defines${langNote} ${listing}${extra}`;
+  }
+  return `Source file ${fileName}`;
+}
+function summarizeDirectory(dirName, childNames) {
+  const lowerDir = dirName.toLowerCase();
+  const knownPurpose = DIR_PATTERNS[lowerDir];
+  if (knownPurpose) {
+    if (childNames.length > 0) {
+      const listing = childNames.slice(0, 5).join(", ");
+      const extra = childNames.length > 5 ? ` and ${childNames.length - 5} more` : "";
+      return `${knownPurpose} containing ${listing}${extra}`;
+    }
+    return knownPurpose;
+  }
+  if (childNames.length > 0) {
+    const listing = childNames.slice(0, 5).join(", ");
+    const extra = childNames.length > 5 ? ` and ${childNames.length - 5} more` : "";
+    return `Directory containing ${listing}${extra}`;
+  }
+  return `Directory ${dirName}`;
+}
+function summarizeFromMetadata(meta) {
+  if (meta.docs) {
+    const firstSentence = meta.docs.split(/\.\s|\n/)[0].trim();
+    if (firstSentence) {
+      return firstSentence.endsWith(".") ? firstSentence.slice(0, -1) : firstSentence;
+    }
+  }
+  switch (meta.kind) {
+    case "function":
+      return summarizeFunction(
+        meta.name,
+        meta.signature,
+        meta.language,
+        meta.lineCount,
+        meta.receiverType,
+        meta.source
+      );
+    case "class":
+      return summarizeClass(meta.name, meta.childNames, meta.source);
+    case "file":
+      return summarizeFile(
+        meta.fileName || meta.name,
+        meta.childNames,
+        meta.language,
+        meta.source
+      );
+    case "directory":
+      return summarizeDirectory(meta.name, meta.childNames || []);
+    default:
+      return `${meta.kind} ${meta.name}`;
+  }
+}
+class TemplateSummarizer {
+  async init() {
+  }
+  async summarize(source, kind) {
+    const firstLine = source.split("\n")[0] || "";
+    const nameMatch = firstLine.match(
+      /(?:function|def|func|class|const|let|var|type|interface)\s+(\w+)/
+    );
+    const name = nameMatch?.[1] || "unknown";
+    return summarizeFromMetadata({ name, kind, source });
+  }
+  async summarizeBatch(items) {
+    return Promise.all(
+      items.map((item) => this.summarize(item.source, item.kind))
+    );
+  }
+  async dispose() {
+  }
+}
+const TYPE_TO_KIND = {
+  Function: "function",
+  Class: "class",
+  File: "file",
+  Directory: "directory"
+};
+function summarizeNode(node) {
+  const kind = TYPE_TO_KIND[node.type];
+  if (!kind) {
+    return `${node.type} ${node.name}`;
+  }
+  const props = node.properties ?? {};
+  return summarizeFromMetadata({
+    name: node.name,
+    kind,
+    signature: props.signature,
+    language: props.language,
+    lineCount: typeof props.start_line === "number" && typeof props.end_line === "number" ? props.end_line - props.start_line + 1 : void 0,
+    receiverType: props.receiver_type,
+    fileName: kind === "file" ? props.path ?? node.name : void 0,
+    childNames: props.childNames,
+    docs: props.docs
+  });
+}
+function* wrapWithSummaries(inner) {
+  let summarized = 0;
+  let total = 0;
+  yield {
+    kind: "stage_start",
+    phase: "summarizing",
+    message: "Summarizing nodes..."
+  };
+  for (const event of inner) {
+    if (event.nodes) {
+      for (const node of event.nodes) {
+        total++;
+        if (!node.properties?.summary) {
+          const summary = summarizeNode(node);
+          if (summary) {
+            node.properties = { ...node.properties, summary };
+            summarized++;
+          }
+        }
+      }
+      yield {
+        kind: "stage_progress",
+        phase: "summarizing",
+        message: `Summarized ${summarized} of ${total} nodes`,
+        detail: { current: summarized, total }
+      };
+    }
+    yield event;
+  }
+  yield {
+    kind: "stage_stop",
+    phase: "summarizing",
+    message: `Summarized ${summarized} nodes`
+  };
+}
+function* corePipeline(input, ctx) {
+  const scanResult = yield* execute$3(input, ctx);
+  if (ctx.cancelled) return;
+  const processingOutput = yield* execute$2(scanResult, ctx);
+  if (ctx.cancelled) return;
+  const finalResult = yield* execute$1(processingOutput);
+  yield {
+    kind: "done",
+    phase: "resolving",
+    message: "Pipeline complete",
+    result: finalResult
+  };
+}
+function* runPipeline(input, ctx, store) {
+  const inner = wrapWithSummaries(corePipeline(input, ctx));
+  if (store) {
+    yield* execute(inner, store);
+  } else {
+    yield* inner;
+  }
+}
+function collectPipeline(input, ctx, store) {
+  const events = [];
+  const nodes = [];
+  const relationships = [];
+  for (const event of runPipeline(input, ctx, store)) {
+    events.push(event);
+    if (event.nodes) nodes.push(...event.nodes);
+    if (event.relationships) relationships.push(...event.relationships);
+  }
+  return { events, nodes, relationships };
+}
+class MemoryStore {
+  nodes = /* @__PURE__ */ new Map();
+  relationships = /* @__PURE__ */ new Map();
+  saveNode(node) {
+    const existing = this.nodes.get(node.id);
+    if (existing) {
+      existing.properties = {
+        ...existing.properties,
+        ...node.properties ?? {}
+      };
+    } else {
+      this.nodes.set(node.id, node);
+    }
+  }
+  saveRelationship(rel) {
+    this.relationships.set(rel.id, rel);
+  }
+}
+const DEFAULT_SUMMARIZER_CONFIG = {
+  enabled: true,
+  strategy: "template",
+  model: "Xenova/flan-t5-small",
+  maxInputLength: 480,
+  minLines: 5
+};
+exports.DEFAULT_SUMMARIZER_CONFIG = DEFAULT_SUMMARIZER_CONFIG;
+exports.MemoryStore = MemoryStore;
+exports.TemplateSummarizer = TemplateSummarizer;
+exports.addToRegistry = addToRegistry;
+exports.analyzeGoImports = analyzeGoImports;
+exports.analyzeImports = analyzeImports;
+exports.analyzePythonImports = analyzePythonImports;
+exports.analyzeRubyImports = analyzeRubyImports;
+exports.analyzeRustImports = analyzeRustImports;
+exports.analyzeTypeScriptImports = analyzeTypeScriptImports;
+exports.collectPipeline = collectPipeline;
+exports.countSymbols = countSymbols;
+exports.detectLanguage = detectLanguage;
+exports.ensureDirChain = ensureDirChain;
+exports.extractGeneric = extractGeneric;
+exports.extractGo = extractGo;
+exports.extractKeywords = extractKeywords;
+exports.extractPython = extractPython;
+exports.extractTypeScript = extractTypeScript;
+exports.getExtension = getExtension;
+exports.getExtractor = getExtractor;
+exports.getParserForLanguage = getParserForLanguage;
+exports.initParsers = initParsers;
+exports.isManifestFile = isManifestFile;
+exports.normalizePyName = normalizePyName;
+exports.npmPackageName = npmPackageName;
+exports.packageId = packageId;
+exports.packageSourceUrl = packageSourceUrl;
+exports.parentDir = parentDir$1;
+exports.parseCargoToml = parseCargoToml;
+exports.parseFile = parseFile;
+exports.parseGoMod = parseGoMod;
+exports.parseManifest = parseManifest;
+exports.parsePackageJson = parsePackageJson;
+exports.parsePyprojectToml = parsePyprojectToml;
+exports.parseRequirementsTxt = parseRequirementsTxt;
+exports.processSymbol = processSymbol;
+exports.resetDirIndexCache = resetDirIndexCache;
+exports.resolveCalls = resolveCalls;
+exports.resolvedCallsToRelationships = resolvedCallsToRelationships;
+exports.runPipeline = runPipeline;
+exports.splitIdentifier = splitIdentifier;
+exports.summarizeClass = summarizeClass;
+exports.summarizeDirectory = summarizeDirectory;
+exports.summarizeFile = summarizeFile;
+exports.summarizeFromMetadata = summarizeFromMetadata;
+exports.summarizeFunction = summarizeFunction;
+//# sourceMappingURL=pipeline.cjs.map