@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-EEOFQDT6.js

@@ -0,0 +1,898 @@
+// src/codebase-index/tree-sitter-parser.ts
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/codebase-index/tree-sitter/queries.ts
+function parseGroupedUse(text) {
+  const open = text.indexOf("{");
+  const close = text.lastIndexOf("}");
+  if (open < 0 || close <= open) return null;
+  const prefix = text.slice(0, open).replace(/[\\/]+$/, "");
+  const out = [];
+  for (const rawMember of text.slice(open + 1, close).split(",")) {
+    let member = rawMember.trim();
+    if (!member) continue;
+    member = member.replace(
+      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+      ""
+    ).trim();
+    if (!member) continue;
+    const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(member);
+    if (aliasMatch) member = member.slice(0, aliasMatch.index).trim();
+    if (!member) continue;
+    const module = prefix ? `${prefix}\\${member}` : member;
+    const toName = member.split(/[\\/]/).filter(Boolean).pop();
+    if (toName) out.push({ toName, callType: "import", module });
+  }
+  return out.length ? out : null;
+}
+function importFromText(prefixes) {
+  return (node) => {
+    let text = node.text.replace(/\s+/g, " ").trim();
+    for (const prefix of prefixes) {
+      if (text.startsWith(prefix)) text = text.slice(prefix.length).trim();
+    }
+    text = text.replace(
+      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+      ""
+    ).trim();
+    if (text.includes("{")) return parseGroupedUse(text);
+    if (text.includes(",") && !text.includes("<") && !text.includes("=")) {
+      const out = [];
+      for (const clause of text.split(",")) {
+        const one = oneImportClause(clause.trim());
+        if (one) out.push(one);
+      }
+      return out.length ? out : null;
+    }
+    const single = oneImportClause(text);
+    return single ? [single] : null;
+  };
+}
+function oneImportClause(rawClause) {
+  let text = rawClause;
+  text = text.replace(
+    /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
+    ""
+  ).trim();
+  text = text.replace(/[;}]+$/g, "").trim();
+  const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(text);
+  if (aliasMatch) text = text.slice(0, aliasMatch.index).trim();
+  const eqMatch = /^([A-Za-z_]\w*)\s*=\s*(.+)$/.exec(text);
+  if (eqMatch) text = eqMatch[2].trim();
+  if (!text) return null;
+  if (text.endsWith("*")) text = text.slice(0, -1).replace(/[.]$/, "");
+  if (!text) return null;
+  const module = text;
+  const toName = module.split(/[.\\/]/).filter(Boolean).pop()?.replace(/<.*>$/s, "");
+  if (!toName) return null;
+  return { toName, callType: "import", module };
+}
+var heritageExtractor = (node) => {
+  const out = [];
+  const SKIP_SUBTREES = /* @__PURE__ */ new Set([
+    "type_arguments",
+    "type_argument_list",
+    // tree-sitter-cpp names its argument subtree template_argument_list —
+    // verified AST: (base_class_clause (template_type name:
+    // (type_identifier) arguments: (template_argument_list
+    // (type_descriptor type: (type_identifier))))). Without this entry
+    // `class D : Base<Foo>` recurses into the descriptor and emits Foo as a
+    // phantom inherit ref.
+    "template_argument_list",
+    "type_parameter_list",
+    "type_projection",
+    "value_arguments"
+  ]);
+  const collect = (current, depth) => {
+    if (depth > 4) return;
+    for (let i = 0; i < current.namedChildCount; i++) {
+      const child = current.namedChild(i);
+      if (!child) continue;
+      if (SKIP_SUBTREES.has(child.type)) continue;
+      if (child.type === "type_identifier" || child.type === "identifier" || child.type === "named_type" || child.type === "type" || // PHP heritage carries `name`; Ruby a `constant`.
+      child.type === "constant" || child.type === "name") {
+        const name = child.type === "named_type" ? leafSegment(child.text) : child.text;
+        if (name) out.push({ toName: name });
+        continue;
+      }
+      if (child.type === "generic_type" || child.type === "generic_name") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const inner = child.namedChild(j);
+          if (inner && !SKIP_SUBTREES.has(inner.type) && (inner.type === "type_identifier" || inner.type === "identifier" || inner.type === "name")) {
+            out.push({ toName: inner.text });
+            break;
+          }
+        }
+        continue;
+      }
+      if (child.type === "qualified_name" || child.type === "scoped_type_identifier" || child.type === "user_type" || child.type === "scope_resolution") {
+        const leaf = heritageLeaf(child, 0);
+        if (leaf) out.push({ toName: leaf });
+        continue;
+      }
+      collect(child, depth + 1);
+    }
+  };
+  collect(node, 0);
+  return out;
+};
+function heritageLeaf(node, depth) {
+  if (depth > 6) return null;
+  const named = node.childForFieldName("name");
+  if (named) {
+    if (named.type === "scoped_type_identifier" || named.type === "qualified_name" || named.type === "scope_resolution" || named.type === "user_type") {
+      return heritageLeaf(named, depth + 1);
+    }
+    return named.text;
+  }
+  const children = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c) children.push(c);
+  }
+  for (let i = children.length - 1; i >= 0; i--) {
+    const c = children[i];
+    if (c.type === "type_arguments" || c.type === "type_argument_list" || // cpp: (template_type arguments: (template_argument_list …)) — the
+    // descriptor's type_identifier inside it is never the declared base.
+    c.type === "template_argument_list" || c.type === "type_parameter_list" || c.type === "type_projection" || c.type === "value_arguments") {
+      continue;
+    }
+    if (c.type === "type_identifier" || c.type === "identifier" || c.type === "constant" || c.type === "name") {
+      return c.text;
+    }
+    if (c.type === "scoped_type_identifier" || c.type === "qualified_name" || c.type === "scope_resolution" || c.type === "user_type") {
+      return heritageLeaf(c, depth + 1);
+    }
+  }
+  return leafSegment(
+    node.text.replace(/\\/g, ".").replace(/::/g, ".").replace(/<[^<>]*>$/, "")
+  );
+}
+function leafSegment(text) {
+  return text.split(".").filter(Boolean).pop() ?? text;
+}
+var cCallExtractor = (node) => {
+  const fn = node.childForFieldName("function");
+  if (!fn) return null;
+  if (fn.type === "field_expression") {
+    const field = fn.childForFieldName("field");
+    if (field) return [{ toName: field.text, callType: "call" }];
+    const seg = fn.text.split("->").filter(Boolean).pop();
+    if (seg) return [{ toName: leafSegment(seg.split(".")[0] ?? seg), callType: "call" }];
+    return null;
+  }
+  if (fn.type === "qualified_identifier") {
+    const name = fn.childForFieldName("name");
+    if (name) return [{ toName: name.text, callType: "call" }];
+    const seg = fn.text.split("::").filter(Boolean).pop();
+    if (seg) return [{ toName: seg.split(/[<(]/)[0].trim(), callType: "call" }];
+    return null;
+  }
+  return [{ toName: fn.text.split(/[<(]/)[0].trim(), callType: "call" }];
+};
+var rubyCallExtractor = (node) => {
+  const emissions = [];
+  const method = node.childForFieldName("method");
+  if (method) {
+    const name = method.text;
+    if (name && !name.includes(" ")) emissions.push({ toName: name, callType: "call" });
+    if (name === "require" || name === "require_relative") {
+      const args = node.childForFieldName("arguments");
+      const first = args?.namedChild(0);
+      if (first) {
+        const raw = first.text.replace(/^['"]|['"]$/g, "");
+        const toName = raw.split("/").filter(Boolean).pop();
+        if (toName) emissions.push({ toName, callType: "import", module: raw });
+      }
+    }
+  }
+  return emissions;
+};
+var firstIdentifierCallExtractor = (node) => {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && (child.type === "simple_identifier" || child.type === "identifier")) {
+      return [{ toName: child.text, callType: "call" }];
+    }
+  }
+  const first = node.namedChild(0);
+  if (!first) return null;
+  const leaf = leafSegment(first.text.split(/[<(]/)[0] ?? first.text);
+  if (!leaf) return null;
+  return [{ toName: leaf, callType: "call" }];
+};
+var cIncludeExtractor = (node) => {
+  const raw = node.text.replace(/^#\s*include\s*/i, "").trim();
+  const module = raw.replace(/^["'<]|["'>]$/g, "");
+  if (!module) return null;
+  const toName = module.split("/").pop()?.replace(/\.h$/, "");
+  if (!toName) return null;
+  return [{ toName, callType: "import", module }];
+};
+var phpConstructorExtractor = (node) => {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && (child.type === "qualified_name" || child.type === "name")) {
+      const leaf = child.text.split(/[\\]/).filter(Boolean).pop();
+      if (leaf) return [{ toName: leaf, callType: "call" }];
+    }
+  }
+  return null;
+};
+var DEFAULT_QUERIES = {
+  declKinds: {}
+};
+var LANG_QUERIES = {
+  // ─── C family ──────────────────────────────────────────────────────────────
+  c: {
+    declKinds: {
+      function_definition: "function",
+      declaration: "function",
+      // K&R-style `int foo(...)` ambiguous w/ local var; the visitor prefers the function branch when the declarator field is present
+      struct_specifier: "struct",
+      union_specifier: "struct",
+      enum_specifier: "enum",
+      type_definition: "type",
+      // `typedef … X;`
+      preproc_def: "const"
+      // `#define NAME …`
+    },
+    nameField: {
+      function_definition: "declarator",
+      declaration: "declarator",
+      struct_specifier: "name",
+      enum_specifier: "name",
+      type_definition: "declarator",
+      preproc_def: "name"
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "translation_unit",
+      "function_definition",
+      "struct_specifier",
+      "union_specifier",
+      "enum_specifier"
+    ]),
+    refRules: {
+      // `obj->run()` and `Cls::stat()` carry structured function fields —
+      // cCallExtractor handles all three AST shapes.
+      call_expression: { callType: "call", nameExtractor: cCallExtractor },
+      preproc_include: { callType: "import", nameExtractor: cIncludeExtractor }
+    }
+  },
+  cpp: {
+    declKinds: {
+      function_definition: "function",
+      template_declaration: "function",
+      // `template<typename T> …`
+      class_specifier: "class",
+      struct_specifier: "struct",
+      union_specifier: "struct",
+      enum_specifier: "enum",
+      namespace_definition: "namespace",
+      type_definition: "type"
+    },
+    nameField: {
+      function_definition: "declarator",
+      template_declaration: "name",
+      class_specifier: "name",
+      struct_specifier: "name",
+      enum_specifier: "name",
+      namespace_definition: "name",
+      type_definition: "declarator"
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "translation_unit",
+      "function_definition",
+      "class_specifier",
+      "struct_specifier",
+      "union_specifier",
+      "enum_specifier",
+      "namespace_definition"
+    ]),
+    refRules: {
+      call_expression: { callType: "call", nameExtractor: cCallExtractor },
+      preproc_include: { callType: "import", nameExtractor: cIncludeExtractor },
+      // `class Foo : public Bar, private Baz` — the base-class clause.
+      base_class_clause: { callType: "inherit", nameExtractor: heritageExtractor }
+    }
+  },
+  java: {
+    declKinds: {
+      class_declaration: "class",
+      interface_declaration: "interface",
+      enum_declaration: "enum",
+      record_declaration: "class",
+      annotation_type_declaration: "interface",
+      method_declaration: "method",
+      constructor_declaration: "method",
+      field_declaration: "property"
+    },
+    nameField: {
+      class_declaration: "name",
+      interface_declaration: "name",
+      enum_declaration: "name",
+      record_declaration: "name",
+      annotation_type_declaration: "name",
+      method_declaration: "name",
+      constructor_declaration: "name"
+    },
+    // `field_declaration` has no single `name` field — it carries a list of
+    // variable declarators. We emit one Symbol per node using the first
+    // identifier-shaped named child (see `extractName` fallback in
+    // `visitor.ts`). `int a, b, c;` therefore indexes only `a` — splitting
+    // multi-declarator fields into separate Symbols is a separate refactor
+    // that needs the visitor to know it has multiple names per node, and no
+    // current test relies on it.
+    scopeNodes: /* @__PURE__ */ new Set([
+      "program",
+      "class_declaration",
+      "interface_declaration",
+      "enum_declaration",
+      "record_declaration"
+    ]),
+    refRules: {
+      method_invocation: { callType: "call", field: "name" },
+      object_creation_expression: { callType: "call", field: "type" },
+      // Verified AST: `superclass: (superclass (type_identifier))` and
+      // `interfaces: (super_interfaces (type_list ...))` — no underscores.
+      superclass: { callType: "inherit", nameExtractor: heritageExtractor },
+      super_interfaces: {
+        callType: "implement",
+        nameExtractor: heritageExtractor
+      },
+      import_declaration: {
+        callType: "import",
+        nameExtractor: importFromText(["import "])
+      }
+    }
+  },
+  csharp: {
+    // C# 10+ `namespace Foo.Bar;` produces this node type. The legacy block
+    // form `namespace Foo.Bar { ... }` produces `namespace_declaration`. Both
+    // carry a `qualified_name` child whose text already includes the dots.
+    // `using_directive` is intentionally not a declaration. Imports are
+    // extracted separately; indexing a using directive as a namespace makes
+    // the resolver bind it to its own source file before the real declaration.
+    declKinds: {
+      file_scoped_namespace_declaration: "namespace",
+      class_declaration: "class",
+      interface_declaration: "interface",
+      struct_declaration: "struct",
+      enum_declaration: "enum",
+      record_declaration: "class",
+      method_declaration: "method",
+      constructor_declaration: "method",
+      property_declaration: "property",
+      field_declaration: "property",
+      namespace_declaration: "namespace"
+    },
+    // Custom name extractor: take the full dotted name verbatim.
+    nameExtractor: (node) => {
+      const inner = node.namedChild(0);
+      if (inner && (inner.type === "qualified_name" || inner.type === "name")) {
+        return inner.text;
+      }
+      return null;
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "compilation_unit",
+      "namespace_declaration",
+      "class_declaration",
+      "interface_declaration",
+      "struct_declaration",
+      "enum_declaration",
+      "record_declaration"
+    ]),
+    refRules: {
+      // Verified AST: `invocation_expression function: (identifier)` — the
+      // callee field is `function` (C-style), not `name`.
+      invocation_expression: { callType: "call", field: "function" },
+      object_creation_expression: { callType: "call", field: "type" },
+      base_list: { callType: "inherit", nameExtractor: heritageExtractor },
+      using_directive: {
+        callType: "import",
+        nameExtractor: importFromText(["using "])
+      }
+    }
+  },
+  php: {
+    declKinds: {
+      function_definition: "function",
+      method_declaration: "method",
+      class_declaration: "class",
+      interface_declaration: "interface",
+      trait_declaration: "class",
+      enum_declaration: "enum",
+      namespace_definition: "namespace"
+    },
+    nameField: {
+      function_definition: "name",
+      method_declaration: "name",
+      class_declaration: "name",
+      interface_declaration: "name",
+      trait_declaration: "name",
+      enum_declaration: "name",
+      namespace_definition: "name"
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "program",
+      "namespace_definition",
+      "class_declaration",
+      "interface_declaration",
+      "trait_declaration",
+      "enum_declaration"
+    ]),
+    refRules: {
+      function_call_expression: { callType: "call", field: "function" },
+      // Verified AST: `new App\Model\User()` carries a BARE qualified_name
+      // child (no `name:` field), so the field default never fires.
+      object_creation_expression: { callType: "call", nameExtractor: phpConstructorExtractor },
+      base_clause: { callType: "inherit", nameExtractor: heritageExtractor },
+      class_interface_clause: {
+        callType: "implement",
+        nameExtractor: heritageExtractor
+      },
+      // Verified AST: `namespace_use_declaration (namespace_use_clause
+      // (qualified_name ...))` — not `use_declaration`.
+      namespace_use_declaration: {
+        callType: "import",
+        nameExtractor: importFromText(["use "])
+      }
+    }
+  },
+  // ─── Scripting / mobile ────────────────────────────────────────────────────
+  ruby: {
+    declKinds: {
+      method: "function",
+      singleton_method: "method",
+      class: "class",
+      module: "namespace",
+      constant: "const"
+    },
+    nameField: {
+      method: "name",
+      singleton_method: "name",
+      class: "name",
+      module: "name",
+      constant: "name"
+    },
+    scopeNodes: /* @__PURE__ */ new Set(["program", "class", "module", "singleton_method", "method"]),
+    refRules: {
+      // `call` covers both `foo(...)` and `obj.foo(...)` — the extractor
+      // records the method leaf, plus `require`/`require_relative` imports.
+      call: { callType: "call", nameExtractor: rubyCallExtractor },
+      superclass: { callType: "inherit", nameExtractor: heritageExtractor }
+    }
+  },
+  swift: {
+    declKinds: {
+      function_declaration: "function",
+      class_declaration: "class",
+      struct_declaration: "struct",
+      enum_declaration: "enum",
+      protocol_declaration: "interface",
+      actor_declaration: "class",
+      extension_declaration: "class",
+      initializer: "method",
+      property_declaration: "property"
+    },
+    nameField: {
+      function_declaration: "name",
+      class_declaration: "name",
+      struct_declaration: "name",
+      enum_declaration: "name",
+      protocol_declaration: "name",
+      actor_declaration: "name",
+      extension_declaration: "name",
+      initializer: "name",
+      property_declaration: "name"
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "source_file",
+      "class_declaration",
+      "struct_declaration",
+      "enum_declaration",
+      "protocol_declaration",
+      "actor_declaration",
+      "extension_declaration"
+    ]),
+    refRules: {
+      // Verified AST: `call_expression (simple_identifier) (call_suffix …)` —
+      // the callee is a bare first child, no field name.
+      call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
+      // Verified AST: `inheritance_specifier inherits_from: (user_type …)`.
+      inheritance_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
+      import_declaration: {
+        callType: "import",
+        nameExtractor: importFromText(["import ", "import type ", "@testable import "])
+      }
+    }
+  },
+  kotlin: {
+    declKinds: {
+      class_declaration: "class",
+      object_declaration: "class",
+      interface_declaration: "interface",
+      function_declaration: "function",
+      property_declaration: "property",
+      type_alias: "type"
+    },
+    nameField: {
+      class_declaration: "name",
+      object_declaration: "name",
+      interface_declaration: "name",
+      function_declaration: "name",
+      property_declaration: "name",
+      type_alias: "name"
+    },
+    scopeNodes: /* @__PURE__ */ new Set([
+      "source_file",
+      "class_declaration",
+      "object_declaration",
+      "interface_declaration",
+      "function_declaration"
+    ]),
+    refRules: {
+      call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
+      // Verified AST: `delegation_specifier (user_type (type_identifier))` —
+      // the `: Handler` / `: Base()` clause.
+      delegation_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
+      import_header: {
+        callType: "import",
+        nameExtractor: importFromText(["import "])
+      }
+    }
+  },
+  elixir: {
+    declKinds: {
+      // `def foo`, `defp foo`, `defmacro foo`, `macrop foo` all surface as
+      // `call` nodes in the tree-sitter grammar — there is no
+      // `function_definition`. The `nameExtractor` walks the call's
+      // children to pick the right sibling identifier.
+      call: "function",
+      module: "namespace"
+    },
+    nameExtractor: (node) => {
+      if (node.type === "module") {
+        const aliasNode = node.childForFieldName("alias");
+        return readFirstString(aliasNode) ?? null;
+      }
+      if (node.type !== "call") return null;
+      const first = node.namedChild(0);
+      if (!first) return null;
+      const target = first.text;
+      if (target !== "def" && target !== "defp" && target !== "defmacro" && target !== "defp_macro" && target !== "macrop" && target !== "defprotocol" && target !== "defguard" && target !== "defguardp") {
+        return null;
+      }
+      const nameNode = node.namedChild(1);
+      return nameNode?.text ?? null;
+    },
+    scopeNodes: /* @__PURE__ */ new Set(["source", "module"])
+  },
+  shell: {
+    declKinds: {
+      function_definition: "function"
+    },
+    nameField: { function_definition: "name" },
+    scopeNodes: /* @__PURE__ */ new Set(["program", "function_definition"])
+  }
+};
+function getQueries(lang) {
+  return LANG_QUERIES[lang] ?? DEFAULT_QUERIES;
+}
+function readFirstString(node) {
+  if (!node) return null;
+  if (node.type === "string_literal" || node.type === "alias") {
+    return node.text.replace(/^"|"$/g, "");
+  }
+  const child = node.namedChild(0);
+  return child ? readFirstString(child) : null;
+}
+
+// src/codebase-index/tree-sitter/util.ts
+function lineColAt(offsets, index) {
+  let low = 0;
+  let high = offsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((offsets[mid] ?? 0) < index) low = mid + 1;
+    else high = mid;
+  }
+  const lastNl = low > 0 ? offsets[low - 1] ?? -1 : -1;
+  return { line: low + 1, col: index - lastNl };
+}
+function newlineOffsets(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
+  }
+  return offsets;
+}
+var TREE_SITTER_MAX_FILE_CHARS = 512 * 1024;
+var TREE_SITTER_MAX_SYMBOLS = 500;
+
+// src/codebase-index/tree-sitter/visitor.ts
+function visitTree(tree, content, file, lang, queries) {
+  const boundedContent = content.length > TREE_SITTER_MAX_FILE_CHARS ? content.slice(0, TREE_SITTER_MAX_FILE_CHARS) : content;
+  const nlOffsets = newlineOffsets(boundedContent);
+  const symbols = [];
+  const refs = [];
+  const seenRefs = /* @__PURE__ */ new Set();
+  const scopeStack = [];
+  function emitRefsForNode(node, rule) {
+    const emissions = rule.nameExtractor?.(node) ?? defaultRefTarget(node, rule);
+    if (!emissions) return;
+    const { line } = lineColAt(nlOffsets, node.startIndex);
+    for (const emission of emissions) {
+      if (!emission.toName) continue;
+      const callType = emission.callType ?? rule.callType;
+      const key = `${emission.toName}:${callType}:${line}:${emission.module ?? ""}:${node.startIndex}`;
+      if (seenRefs.has(key)) continue;
+      seenRefs.add(key);
+      refs.push({
+        fromId: 0,
+        // assignRefsToSymbols attaches owners after insertion
+        toName: emission.toName.slice(0, 200),
+        callType,
+        line,
+        lang,
+        module: emission.module
+      });
+    }
+  }
+  function defaultRefTarget(node, rule) {
+    if (!rule.field) return null;
+    const field = node.childForFieldName(rule.field);
+    if (!field) return null;
+    const leaf = field.text.split(/[.:\\]/).filter(Boolean).pop()?.split(/[<(]/)[0];
+    if (!leaf) return null;
+    return [{ toName: leaf.trim() }];
+  }
+  function visit(node, depth) {
+    if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) return;
+    if (node.isMissing || node.isError) {
+    } else {
+      const kind = queries.declKinds[node.type];
+      if (kind) {
+        const emitted = emitSymbol(
+          node,
+          kind,
+          file,
+          lang,
+          scopeStack,
+          boundedContent,
+          nlOffsets,
+          queries
+        );
+        if (emitted) symbols.push(emitted);
+      }
+      const refRule = queries.refRules?.[node.type];
+      if (refRule) emitRefsForNode(node, refRule);
+    }
+    const pushesScope = queries.scopeNodes?.has(node.type) ?? false;
+    const pushIdx = pushesScope ? pushScope(scopeStack, node, queries) : -1;
+    if (queries.skipNamedChildren) {
+      if (pushIdx !== -1) scopeStack.pop();
+      return;
+    }
+    for (const child of node.namedChildren) {
+      visit(child, depth + 1);
+      if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) {
+        if (pushIdx !== -1) scopeStack.pop();
+        return;
+      }
+    }
+    if (pushIdx !== -1) scopeStack.pop();
+  }
+  visit(tree.rootNode, 0);
+  return { symbols, refs };
+}
+function pushScope(scopeStack, node, queries) {
+  const name = extractName(node, queries);
+  if (!name) return -1;
+  scopeStack.push(name);
+  return scopeStack.length - 1;
+}
+var IDENTIFIER_NODE_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "simple_identifier",
+  "type_identifier",
+  "field_identifier",
+  "property_identifier",
+  "name",
+  "word",
+  "variable_name",
+  "constant",
+  "sym"
+]);
+function extractName(node, queries) {
+  if (queries.nameExtractor) {
+    const extracted = queries.nameExtractor(node);
+    if (extracted) return extracted;
+  }
+  const fieldName = queries.nameField?.[node.type] ?? "name";
+  const field = node.childForFieldName(fieldName);
+  if (field) {
+    if (IDENTIFIER_NODE_TYPES.has(field.type)) {
+      return field.text;
+    }
+    const inner = field.childForFieldName("name") ?? field.namedChild(0);
+    if (inner && IDENTIFIER_NODE_TYPES.has(inner.type)) {
+      return inner.text;
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && IDENTIFIER_NODE_TYPES.has(child.type)) {
+      return child.text;
+    }
+  }
+  return null;
+}
+function emitSymbol(node, kind, file, lang, scopeStack, content, nlOffsets, queries) {
+  const name = extractName(node, queries);
+  if (!name) return null;
+  const pos = node.startIndex;
+  const { line, col } = lineColAt(nlOffsets, pos);
+  const end = Math.min(node.endIndex, content.length);
+  const signature = content.slice(pos, end).replace(/\s+/g, " ").trim().slice(0, 500);
+  const scope = scopeStack.join(".");
+  const text = [name, signature].filter(Boolean).join(" | ").trim().slice(0, 1e3);
+  return {
+    id: 0,
+    // caller assigns during bulk insertion
+    lang,
+    kind,
+    name: name.slice(0, 200),
+    file,
+    line,
+    col,
+    signature,
+    docComment: "",
+    // doc-comment extraction lands with ref emission on Day 4
+    scope,
+    text
+  };
+}
+
+// src/codebase-index/tree-sitter-parser.ts
+var WASM_DIR = fileURLToPath(new URL("./wasm/", import.meta.url));
+var RUNTIME_WASM = path.join(WASM_DIR, "tree-sitter-runtime.wasm");
+var LANG_TO_GRAMMAR = {
+  c: "c",
+  cpp: "cpp",
+  java: "java",
+  csharp: "c_sharp",
+  // tree-sitter directory uses underscore
+  php: "php",
+  ruby: "ruby",
+  swift: "swift",
+  kotlin: "kotlin",
+  shell: "bash",
+  // we treat `.sh` / `.bash` / `.zsh` via the bash grammar
+  // Go/Python/Rust are opt-in only (see goOptIn / pyOptIn / rsOptIn below)
+  elixir: "elixir"
+};
+var GO_OPT_IN = "WRONGSTACK_USE_TS_GO";
+var PY_OPT_IN = "WRONGSTACK_USE_TS_PY";
+var RS_OPT_IN = "WRONGSTACK_USE_TS_RS";
+function optInEnabled(env) {
+  return process.env[env] === "1" || process.env[env] === "true";
+}
+var runtimePromise = null;
+var languageCache = /* @__PURE__ */ new Map();
+function getRuntime() {
+  if (!runtimePromise) {
+    runtimePromise = (async () => {
+      const mod = await import("web-tree-sitter");
+      const init = () => mod.Parser.init({ locateFile: () => RUNTIME_WASM });
+      return { Parser: mod.Parser, Language: mod.Language, init };
+    })();
+  }
+  return runtimePromise;
+}
+async function loadLanguage(lang) {
+  const existing = languageCache.get(lang);
+  if (existing) return existing;
+  const promise = (async () => {
+    const grammarName = resolveGrammarName(lang);
+    if (!grammarName) {
+      throw new Error(`tree-sitter: no grammar registered for lang "${lang}"`);
+    }
+    const wasmPath = path.join(WASM_DIR, grammarName, `tree-sitter-${grammarName}.wasm`);
+    const { Language, init } = await getRuntime();
+    await init();
+    const languageObj = await Language.load(wasmPath);
+    return { lang, Language: languageObj };
+  })();
+  languageCache.set(lang, promise);
+  return promise;
+}
+function resolveGrammarName(lang) {
+  if (lang === "go" && optInEnabled(GO_OPT_IN)) return "go";
+  if (lang === "py" && optInEnabled(PY_OPT_IN)) return "python";
+  if (lang === "rs" && optInEnabled(RS_OPT_IN)) return "rust";
+  return LANG_TO_GRAMMAR[lang];
+}
+function isTreeSitterSupported(lang) {
+  return resolveGrammarName(lang) !== void 0;
+}
+function getGrammarWasmPath(lang) {
+  const name = resolveGrammarName(lang);
+  if (!name) return void 0;
+  return path.join(WASM_DIR, name, `tree-sitter-${name}.wasm`);
+}
+async function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  if (!isTreeSitterSupported(lang)) {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  try {
+    const { Parser } = await getRuntime();
+    const cached = await loadLanguage(lang);
+    const parser = new Parser();
+    parser.setLanguage(cached.Language);
+    const tree = parser.parse(content);
+    if (!tree) {
+      return { file, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { symbols, refs } = visitTree(tree, content, file, lang, getQueries(lang));
+    parser.delete();
+    tree.delete();
+    return { file, lang, symbols, refs, mtimeMs: Date.now() };
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+async function loadTreeSitterLanguage(lang) {
+  const cached = await loadLanguage(lang);
+  return cached.Language;
+}
+async function __smokeRootType(opts) {
+  if (!isTreeSitterSupported(opts.lang)) {
+    throw new Error(`tree-sitter: no grammar registered for lang "${opts.lang}"`);
+  }
+  const { Parser } = await getRuntime();
+  const cached = await loadLanguage(opts.lang);
+  const parser = new Parser();
+  parser.setLanguage(cached.Language);
+  let tree = null;
+  try {
+    tree = parser.parse(opts.content);
+    if (!tree) throw new Error("tree-sitter: parser.parse returned null");
+    return tree.rootNode.type;
+  } finally {
+    tree?.delete();
+    parser.delete();
+  }
+}
+async function parseTreeSitterAst(opts) {
+  const grammar = resolveGrammarName(opts.lang) ?? (opts.lang === "go" ? "go" : opts.lang === "py" ? "python" : opts.lang === "rs" ? "rust" : void 0);
+  if (!grammar) return null;
+  try {
+    const { Parser, Language, init } = await getRuntime();
+    await init();
+    const wasmPath = path.join(WASM_DIR, grammar, `tree-sitter-${grammar}.wasm`);
+    const languageObj = await Language.load(wasmPath);
+    const parser = new Parser();
+    parser.setLanguage(languageObj);
+    const tree = parser.parse(opts.content);
+    if (!tree) {
+      parser.delete();
+      return null;
+    }
+    return { tree, parser };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  getGrammarWasmPath,
+  parseSymbols,
+  loadTreeSitterLanguage,
+  __smokeRootType,
+  parseTreeSitterAst
+};
+//# sourceMappingURL=chunk-EEOFQDT6.js.map