@esankhan3/code-search-mcp 0.0.2 → 0.2.0

package/dist/core/tree-sitter-parser.js

@@ -1,539 +0,0 @@
-import { Parser as TSParser, Language as TSLanguage, Query as TSQuery } from "web-tree-sitter";
-import { createHash } from "node:crypto";
-import { createRequire } from "node:module";
-const require2 = createRequire(import.meta.url);
-const GRAMMAR_MAP = {
-  typescript: "tree-sitter-typescript.wasm",
-  javascript: "tree-sitter-javascript.wasm",
-  tsx: "tree-sitter-tsx.wasm",
-  go: "tree-sitter-go.wasm",
-  python: "tree-sitter-python.wasm",
-  rust: "tree-sitter-rust.wasm",
-  java: "tree-sitter-java.wasm",
-  php: "tree-sitter-php.wasm"
-};
-let parserReady = false;
-const languageParsers = /* @__PURE__ */ new Map();
-async function initTreeSitter() {
-  if (parserReady) return;
-  await TSParser.init();
-  parserReady = true;
-}
-async function getParserAndLang(language) {
-  if (languageParsers.has(language)) return languageParsers.get(language);
-  const wasmFile = GRAMMAR_MAP[language];
-  if (!wasmFile) return null;
-  try {
-    const wasmPath = require2.resolve(`tree-sitter-wasms/out/${wasmFile}`);
-    const lang = await TSLanguage.load(wasmPath);
-    const parser = new TSParser();
-    parser.setLanguage(lang);
-    const entry = { parser, lang };
-    languageParsers.set(language, entry);
-    return entry;
-  } catch {
-    return null;
-  }
-}
-const TS_QUERIES = {
-  entities: `
-    (function_declaration name: (identifier) @name) @entity
-    (class_declaration name: (type_identifier) @name) @entity
-    (interface_declaration name: (type_identifier) @name) @entity
-    (type_alias_declaration name: (type_identifier) @name) @entity
-    (enum_declaration name: (identifier) @name) @entity
-    (method_definition name: (property_identifier) @name) @entity
-    (export_statement declaration: (function_declaration name: (identifier) @name) @entity) @export
-    (export_statement declaration: (class_declaration name: (type_identifier) @name) @entity) @export
-    (export_statement declaration: (interface_declaration name: (type_identifier) @name) @entity) @export
-    (export_statement declaration: (type_alias_declaration name: (type_identifier) @name) @entity) @export
-    (export_statement declaration: (enum_declaration name: (identifier) @name) @entity) @export
-    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name value: (arrow_function) @entity))) @export
-  `,
-  imports: `
-    (import_statement source: (string) @source) @import
-  `,
-  calls: `
-    (call_expression function: (identifier) @callee) @call
-    (call_expression function: (member_expression property: (property_identifier) @callee)) @call
-  `
-};
-const GO_QUERIES = {
-  entities: `
-    (function_declaration name: (identifier) @name) @entity
-    (method_declaration name: (field_identifier) @name) @entity
-    (type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @entity
-    (type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @entity
-  `,
-  imports: `
-    (import_spec path: (interpreted_string_literal) @source) @import
-  `,
-  calls: `
-    (call_expression function: (identifier) @callee) @call
-    (call_expression function: (selector_expression field: (field_identifier) @callee)) @call
-  `
-};
-const PY_QUERIES = {
-  entities: `
-    (function_definition name: (identifier) @name) @entity
-    (class_definition name: (identifier) @name) @entity
-  `,
-  imports: `
-    (import_from_statement module_name: (dotted_name) @source) @import
-    (import_statement name: (dotted_name) @source) @import
-  `,
-  calls: `
-    (call function: (identifier) @callee) @call
-    (call function: (attribute attribute: (identifier) @callee)) @call
-  `
-};
-const RUST_QUERIES = {
-  entities: `
-    (function_item name: (identifier) @name) @entity
-    (struct_item name: (type_identifier) @name) @entity
-    (impl_item type: (type_identifier) @name) @entity
-    (trait_item name: (type_identifier) @name) @entity
-    (enum_item name: (type_identifier) @name) @entity
-  `,
-  imports: `
-    (use_declaration argument: (scoped_identifier) @source) @import
-  `,
-  calls: `
-    (call_expression function: (identifier) @callee) @call
-    (call_expression function: (field_expression field: (field_identifier) @callee)) @call
-  `
-};
-const JAVA_QUERIES = {
-  entities: `
-    (class_declaration name: (identifier) @name) @entity
-    (interface_declaration name: (identifier) @name) @entity
-    (method_declaration name: (identifier) @name) @entity
-    (enum_declaration name: (identifier) @name) @entity
-  `,
-  imports: `
-    (import_declaration (scoped_identifier) @source) @import
-  `,
-  calls: `
-    (method_invocation name: (identifier) @callee) @call
-  `
-};
-const PHP_QUERIES = {
-  entities: `
-    (function_definition name: (name) @name) @entity
-    (class_declaration name: (name) @name) @entity
-    (method_declaration name: (name) @name) @entity
-    (interface_declaration name: (name) @name) @entity
-    (trait_declaration name: (name) @name) @entity
-  `,
-  imports: `
-    (namespace_use_declaration (namespace_use_clause (qualified_name) @source)) @import
-  `,
-  calls: `
-    (function_call_expression function: (name) @callee) @call
-    (member_call_expression name: (name) @callee) @call
-  `
-};
-function queriesForLanguage(language) {
-  switch (language) {
-    case "typescript":
-    case "javascript":
-    case "tsx":
-      return TS_QUERIES;
-    case "go":
-      return GO_QUERIES;
-    case "python":
-      return PY_QUERIES;
-    case "rust":
-      return RUST_QUERIES;
-    case "java":
-      return JAVA_QUERIES;
-    case "php":
-      return PHP_QUERIES;
-    default:
-      return null;
-  }
-}
-const NODE_TYPE_TO_ENTITY = {
-  // TypeScript / JavaScript
-  function_declaration: "function",
-  arrow_function: "function",
-  class_declaration: "class",
-  method_definition: "method",
-  interface_declaration: "interface",
-  type_alias_declaration: "type",
-  enum_declaration: "enum",
-  // Python
-  function_definition: "function",
-  class_definition: "class",
-  // Go (type_spec handled separately via child type)
-  // Rust
-  function_item: "function",
-  struct_item: "struct",
-  impl_item: "module",
-  // impl blocks act as module-level grouping
-  trait_item: "trait",
-  enum_item: "enum",
-  // Java
-  method_declaration: "method",
-  // PHP (uses same names as TS for class/interface + 'trait_declaration')
-  function_definition_php: "function",
-  trait_declaration: "trait"
-};
-function detectEntityType(node, _language) {
-  const t = node.type;
-  const mapped = NODE_TYPE_TO_ENTITY[t];
-  if (mapped) return mapped;
-  if (t === "type_declaration" || t === "type_spec") {
-    const spec = t === "type_declaration" ? node.namedChildren.find((c) => c.type === "type_spec") : node;
-    if (spec) {
-      const typeChild = spec.namedChildren.find(
-        (c) => c.type === "struct_type" || c.type === "interface_type"
-      );
-      if (typeChild?.type === "struct_type") return "struct";
-      if (typeChild?.type === "interface_type") return "interface";
-    }
-    return "type";
-  }
-  if (t.includes("class")) return "class";
-  if (t.includes("interface")) return "interface";
-  if (t.includes("method")) return "method";
-  if (t.includes("function") || t.includes("func")) return "function";
-  if (t.includes("struct")) return "struct";
-  if (t.includes("enum")) return "enum";
-  if (t.includes("trait")) return "trait";
-  return "function";
-}
-function isExported(entityNode, language, content) {
-  if (language === "typescript" || language === "javascript" || language === "tsx") {
-    let cursor = entityNode.parent;
-    while (cursor) {
-      if (cursor.type === "export_statement") return true;
-      cursor = cursor.parent;
-    }
-    return false;
-  }
-  if (language === "rust") {
-    const text = content.slice(entityNode.startIndex, entityNode.startIndex + 10);
-    return text.trimStart().startsWith("pub");
-  }
-  if (language === "go") {
-    const nameChild = entityNode.namedChildren.find(
-      (c) => c.type === "identifier" || c.type === "type_identifier" || c.type === "field_identifier"
-    );
-    if (nameChild) {
-      const name = nameChild.text;
-      return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
-    }
-    return false;
-  }
-  if (language === "java") {
-    const modifiers = entityNode.namedChildren.find((c) => c.type === "modifiers");
-    if (modifiers) return modifiers.text.includes("public");
-    return false;
-  }
-  return true;
-}
-function findContainingEntity(node) {
-  let cursor = node.parent;
-  while (cursor) {
-    const t = cursor.type;
-    if (t === "class_declaration" || t === "class_definition" || t === "class_body" || t === "impl_item" || t === "struct_item" || t === "trait_item" || t === "interface_declaration" || t === "trait_declaration") {
-      const target = t === "class_body" && cursor.parent ? cursor.parent : cursor;
-      const nameChild = target.namedChildren.find(
-        (c) => c.type === "identifier" || c.type === "type_identifier" || c.type === "name"
-      );
-      if (nameChild) return nameChild.text;
-    }
-    cursor = cursor.parent;
-  }
-  return void 0;
-}
-function extractSignature(entityNode, entityType, _content) {
-  if (entityType !== "function" && entityType !== "method") return void 0;
-  const params = entityNode.namedChildren.find(
-    (c) => c.type === "formal_parameters" || c.type === "parameters" || c.type === "parameter_list" || c.type === "typed_parameters"
-  );
-  const returnType = entityNode.namedChildren.find(
-    (c) => c.type === "type_annotation" || c.type === "return_type"
-  );
-  if (!params) return void 0;
-  let sig = params.text;
-  if (returnType) sig += `: ${returnType.text}`;
-  return sig;
-}
-function runQuery(language, querySource, rootNode) {
-  try {
-    const query = new TSQuery(language, querySource);
-    return query.matches(rootNode);
-  } catch {
-    return [];
-  }
-}
-function runQueryWithFallback(language, querySource, rootNode) {
-  const fullResult = runQuery(language, querySource, rootNode);
-  if (fullResult.length > 0) return fullResult;
-  const patterns = querySource.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("("));
-  const results = [];
-  for (const pattern of patterns) {
-    try {
-      const q = new TSQuery(language, pattern);
-      results.push(...q.matches(rootNode));
-    } catch {
-    }
-  }
-  return results;
-}
-function parseImportMatches(matches, language, _content, _rootNode) {
-  const imports = [];
-  for (const match of matches) {
-    const sourceCapture = match.captures.find((c) => c.name === "source");
-    const importCapture = match.captures.find((c) => c.name === "import");
-    if (!sourceCapture) continue;
-    let source = sourceCapture.node.text.replace(/^['"`]|['"`]$/g, "");
-    const startLine = (importCapture ?? sourceCapture).node.startPosition.row;
-    const isRelative = source.startsWith("./") || source.startsWith("../");
-    const names = [];
-    if (language === "typescript" || language === "javascript" || language === "tsx") {
-      const importNode = importCapture?.node ?? sourceCapture.node.parent;
-      if (importNode) {
-        const walk = (n) => {
-          if (n.type === "import_specifier") {
-            const nameNode = n.namedChildren.find((c) => c.type === "identifier");
-            if (nameNode) names.push(nameNode.text);
-          }
-          if (n.type === "identifier" && n.parent?.type === "import_clause") {
-            names.push(n.text);
-          }
-          for (const child of n.namedChildren) walk(child);
-        };
-        walk(importNode);
-      }
-    }
-    if (language === "python") {
-      const importNode = importCapture?.node ?? sourceCapture.node.parent;
-      if (importNode && importNode.type === "import_from_statement") {
-        for (const child of importNode.namedChildren) {
-          if (child.type === "dotted_name" && child !== sourceCapture.node) {
-            names.push(child.text);
-          }
-          if (child.type === "aliased_import") {
-            const nameNode = child.namedChildren.find((c) => c.type === "dotted_name");
-            if (nameNode) names.push(nameNode.text);
-          }
-        }
-      }
-    }
-    imports.push({ source, names, startLine, isRelative });
-  }
-  return imports;
-}
-function parseCallMatches(matches, entities) {
-  const callSites = [];
-  for (const match of matches) {
-    const calleeCapture = match.captures.find((c) => c.name === "callee");
-    if (!calleeCapture) continue;
-    const callee = calleeCapture.node.text;
-    const startLine = calleeCapture.node.startPosition.row;
-    const containingEntity = entities.find(
-      (e) => startLine >= e.startLine && startLine <= e.endLine
-    )?.name;
-    callSites.push({ callee, startLine, containingEntity });
-  }
-  return callSites;
-}
-function extractTypeReferences(entities) {
-  const typeRefs = /* @__PURE__ */ new Set();
-  const typeRefPattern = /(?<!['"@/\\])\b([A-Z][A-Za-z0-9]*(?:<[^>]+>)?)\b/g;
-  for (const entity of entities) {
-    if (entity.signature) {
-      let m;
-      while ((m = typeRefPattern.exec(entity.signature)) !== null) {
-        const ref = m[1].replace(/<.*>$/, "");
-        if (!BUILTIN_TYPES.has(ref)) typeRefs.add(ref);
-      }
-    }
-  }
-  return [...typeRefs];
-}
-const BUILTIN_TYPES = /* @__PURE__ */ new Set([
-  "String",
-  "Number",
-  "Boolean",
-  "Object",
-  "Array",
-  "Function",
-  "Symbol",
-  "Promise",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "Date",
-  "RegExp",
-  "Error",
-  "Record",
-  "Partial",
-  "Required",
-  "Readonly",
-  "Pick",
-  "Omit",
-  "Exclude",
-  "Extract",
-  "NonNullable",
-  "ReturnType",
-  "Parameters",
-  "InstanceType",
-  "Awaited",
-  "Uint8Array",
-  "Int32Array",
-  "Float64Array",
-  "ArrayBuffer",
-  "Iterator",
-  "AsyncIterator",
-  "Generator",
-  "AsyncGenerator"
-]);
-async function parseFile(filePath, content, language) {
-  await initTreeSitter();
-  const parserEntry = await getParserAndLang(language);
-  if (!parserEntry) return null;
-  const queries = queriesForLanguage(language);
-  if (!queries) return null;
-  let tree;
-  try {
-    tree = parserEntry.parser.parse(content);
-  } catch {
-    return null;
-  }
-  if (!tree) return null;
-  const rootNode = tree.rootNode;
-  const lang = parserEntry.lang;
-  const entityMatches = runQueryWithFallback(lang, queries.entities, rootNode);
-  const entities = [];
-  const seenEntityKeys = /* @__PURE__ */ new Set();
-  for (const match of entityMatches) {
-    const nameCapture = match.captures.find((c) => c.name === "name");
-    const entityCapture = match.captures.find((c) => c.name === "entity");
-    if (!nameCapture || !entityCapture) continue;
-    const entityNode = entityCapture.node;
-    const name = nameCapture.node.text;
-    const type = detectEntityType(entityNode, language);
-    const startLine = entityNode.startPosition.row;
-    const endLine = entityNode.endPosition.row;
-    const key = `${name}:${startLine}`;
-    if (seenEntityKeys.has(key)) {
-      const existing = entities.find((e) => e.name === name && e.startLine === startLine);
-      const hasExportCapture2 = match.captures.some((c) => c.name === "export");
-      if (existing && hasExportCapture2) {
-        existing.isExported = true;
-      }
-      continue;
-    }
-    seenEntityKeys.add(key);
-    const hasExportCapture = match.captures.some((c) => c.name === "export");
-    const exported = hasExportCapture || isExported(entityNode, language, content);
-    const parentName = type === "method" ? findContainingEntity(entityNode) : void 0;
-    const signature = extractSignature(entityNode, type, content);
-    const body = content.slice(entityNode.startIndex, entityNode.endIndex);
-    entities.push({
-      name,
-      type,
-      startLine,
-      endLine,
-      startByte: entityNode.startIndex,
-      endByte: entityNode.endIndex,
-      parent: parentName,
-      signature,
-      isExported: exported,
-      body
-    });
-  }
-  const importMatches = runQueryWithFallback(lang, queries.imports, rootNode);
-  const imports = parseImportMatches(importMatches, language, content, rootNode);
-  const callMatches = runQueryWithFallback(lang, queries.calls, rootNode);
-  const callSites = parseCallMatches(callMatches, entities);
-  const typeReferences = extractTypeReferences(entities);
-  tree.delete();
-  return {
-    filePath,
-    language,
-    entities,
-    imports,
-    callSites,
-    typeReferences
-  };
-}
-async function parseFiles(files) {
-  await initTreeSitter();
-  const results = [];
-  for (const file of files) {
-    const result = await parseFile(file.path, file.content, file.language);
-    if (result) results.push(result);
-  }
-  return results;
-}
-async function computeStructuralHash(_content, entity, language) {
-  await initTreeSitter();
-  const parserEntry = await getParserAndLang(language);
-  if (!parserEntry) return null;
-  let tree;
-  try {
-    tree = parserEntry.parser.parse(entity.body);
-  } catch {
-    return null;
-  }
-  if (!tree) return null;
-  const identifierMap = /* @__PURE__ */ new Map();
-  let identifierCounter = 0;
-  const tokens = [];
-  const SKIP_TYPES = /* @__PURE__ */ new Set([
-    "comment",
-    "line_comment",
-    "block_comment",
-    "doc_comment"
-    // Whitespace nodes are typically not named, but include for safety
-  ]);
-  const IDENTIFIER_TYPES = /* @__PURE__ */ new Set([
-    "identifier",
-    "type_identifier",
-    "property_identifier",
-    "field_identifier",
-    "shorthand_field_identifier",
-    "name",
-    "dotted_name"
-  ]);
-  function walk(node) {
-    if (SKIP_TYPES.has(node.type)) return;
-    if (node.namedChildCount === 0) {
-      if (IDENTIFIER_TYPES.has(node.type)) {
-        const text = node.text;
-        if (!identifierMap.has(text)) {
-          identifierMap.set(text, `v${identifierCounter++}`);
-        }
-        tokens.push(`${node.type}:${identifierMap.get(text)}`);
-      } else {
-        tokens.push(`${node.type}:${node.text}`);
-      }
-    } else {
-      tokens.push(`(${node.type}`);
-      for (const child of node.namedChildren) {
-        walk(child);
-      }
-      tokens.push(")");
-    }
-  }
-  walk(tree.rootNode);
-  tree.delete();
-  const canonical = tokens.join(" ");
-  return createHash("sha256").update(canonical).digest("hex");
-}
-function supportedLanguages() {
-  return Object.keys(GRAMMAR_MAP);
-}
-export {
-  computeStructuralHash,
-  initTreeSitter,
-  parseFile,
-  parseFiles,
-  supportedLanguages
-};