@vibgrate/cli 2026.702.2 → 2026.703.3

package/dist/chunk-X5YT263H.js

@@ -0,0 +1,912 @@
+import { redactSecrets } from './chunk-RXP66R2E.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { Language, Parser, Query } from 'web-tree-sitter';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+
+// src/engine/languages.ts
+var LANGUAGES = [
+  {
+    id: "ts",
+    label: "TypeScript",
+    extensions: [".ts", ".mts", ".cts"],
+    grammarFile: "tree-sitter-typescript"
+  },
+  {
+    id: "tsx",
+    label: "TSX",
+    extensions: [".tsx"],
+    grammarFile: "tree-sitter-tsx"
+  },
+  {
+    id: "js",
+    label: "JavaScript",
+    extensions: [".js", ".mjs", ".cjs", ".jsx"],
+    grammarFile: "tree-sitter-javascript"
+  },
+  {
+    id: "py",
+    label: "Python",
+    extensions: [".py", ".pyi"],
+    grammarFile: "tree-sitter-python"
+  },
+  {
+    id: "go",
+    label: "Go",
+    extensions: [".go"],
+    grammarFile: "tree-sitter-go"
+  },
+  {
+    id: "java",
+    label: "Java",
+    extensions: [".java"],
+    grammarFile: "tree-sitter-java"
+  },
+  {
+    id: "rust",
+    label: "Rust",
+    extensions: [".rs"],
+    grammarFile: "tree-sitter-rust"
+  },
+  {
+    id: "cs",
+    label: "C#",
+    extensions: [".cs"],
+    grammarFile: "tree-sitter-c_sharp"
+  },
+  {
+    id: "rb",
+    label: "Ruby",
+    extensions: [".rb"],
+    grammarFile: "tree-sitter-ruby"
+  },
+  { id: "php", label: "PHP", extensions: [".php"], grammarFile: "tree-sitter-php" },
+  { id: "kotlin", label: "Kotlin", extensions: [".kt", ".kts"], grammarFile: "tree-sitter-kotlin" },
+  { id: "swift", label: "Swift", extensions: [".swift"], grammarFile: "tree-sitter-swift" },
+  { id: "scala", label: "Scala", extensions: [".scala", ".sc"], grammarFile: "tree-sitter-scala" },
+  { id: "dart", label: "Dart", extensions: [".dart"], grammarFile: "tree-sitter-dart" },
+  { id: "lua", label: "Lua", extensions: [".lua"], grammarFile: "tree-sitter-lua" },
+  { id: "ex", label: "Elixir", extensions: [".ex", ".exs"], grammarFile: "tree-sitter-elixir" },
+  // Known limitation: the bundled bash grammar's external scanner throws under
+  // web-tree-sitter 0.25.10 on `case`/heredoc constructs. Such files degrade
+  // gracefully (per-file empty parse + a surfaced warning, never a build crash);
+  // functions in case/heredoc-free scripts extract normally.
+  { id: "sh", label: "Shell", extensions: [".sh", ".bash"], grammarFile: "tree-sitter-bash" },
+  { id: "zig", label: "Zig", extensions: [".zig"], grammarFile: "tree-sitter-zig" },
+  { id: "c", label: "C", extensions: [".c"], grammarFile: "tree-sitter-c" },
+  // C++ owns `.h`: the cpp grammar is a superset of C, so C headers parse clean
+  // under it, while C++ headers (classes/templates) break the C grammar.
+  {
+    id: "cpp",
+    label: "C++",
+    extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx", ".h"],
+    grammarFile: "tree-sitter-cpp"
+  }
+];
+var EXT_TO_LANG = /* @__PURE__ */ new Map();
+for (const lang of LANGUAGES) {
+  for (const ext of lang.extensions) EXT_TO_LANG.set(ext, lang);
+}
+var ID_TO_LANG = new Map(LANGUAGES.map((l) => [l.id, l]));
+function langForExtension(ext) {
+  return EXT_TO_LANG.get(ext.toLowerCase());
+}
+function langById(id) {
+  return ID_TO_LANG.get(id);
+}
+function allLanguageIds() {
+  return LANGUAGES.map((l) => l.id);
+}
+var require2 = createRequire(import.meta.url);
+var parserInit = null;
+var languageCache = /* @__PURE__ */ new Map();
+var grammarsOverride;
+function setGrammarsOverride(dir) {
+  grammarsOverride = dir ? path.resolve(dir) : void 0;
+}
+function thisDir() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+var cachedTreeSitterWasmsDir = null;
+function treeSitterWasmsOutDir() {
+  if (cachedTreeSitterWasmsDir) return cachedTreeSitterWasmsDir;
+  const pkgJson = require2.resolve("tree-sitter-wasms/package.json");
+  cachedTreeSitterWasmsDir = path.join(path.dirname(pkgJson), "out");
+  return cachedTreeSitterWasmsDir;
+}
+function grammarSetVersion() {
+  try {
+    const pkgJson = require2.resolve("tree-sitter-wasms/package.json");
+    const { version } = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+    return `tree-sitter-wasms@${version}+swift-vendored@0.7.1`;
+  } catch {
+    return "tree-sitter-wasms@unknown+swift-vendored@0.7.1";
+  }
+}
+function grammarDirs() {
+  const dirs = [];
+  if (grammarsOverride) dirs.push(grammarsOverride);
+  dirs.push(path.join(thisDir(), "..", "grammars"));
+  dirs.push(path.join(thisDir(), "grammars"));
+  dirs.push(path.join(thisDir(), "..", "vendor"));
+  dirs.push(path.join(thisDir(), "..", "..", "vendor"));
+  try {
+    dirs.push(treeSitterWasmsOutDir());
+  } catch {
+  }
+  return dirs;
+}
+var isVendorOverlay = (dir) => path.basename(dir) === "vendor";
+function grammarsSourceDir() {
+  for (const dir of grammarDirs()) {
+    if (isVendorOverlay(dir)) continue;
+    if (fs.existsSync(dir) && fs.readdirSync(dir).some((f) => f.endsWith(".wasm"))) return dir;
+  }
+  return null;
+}
+function resolveGrammarFile(grammarFile) {
+  const fileName = `${grammarFile}.wasm`;
+  for (const dir of grammarDirs()) {
+    const candidate = path.join(dir, fileName);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `grammar "${fileName}" not found. Looked in: ${grammarDirs().join(", ")}. Pass --grammars <dir> pointing at a directory of grammar .wasm files.`
+  );
+}
+function resolvedGrammarFiles() {
+  return LANGUAGES.map((l) => ({
+    fileName: `${l.grammarFile}.wasm`,
+    absPath: resolveGrammarFile(l.grammarFile)
+  }));
+}
+async function ensureParserInit() {
+  if (!parserInit) parserInit = Parser.init();
+  await parserInit;
+}
+async function loadLanguage(langId) {
+  const cached = languageCache.get(langId);
+  if (cached) return cached;
+  const def = langById(langId);
+  if (!def) throw new Error(`unknown language id "${langId}"`);
+  await ensureParserInit();
+  const wasmPath = resolveGrammarFile(def.grammarFile);
+  const language = await Language.load(fs.readFileSync(wasmPath));
+  languageCache.set(langId, language);
+  return language;
+}
+async function parserFor(def) {
+  const language = await loadLanguage(def.id);
+  const parser = new Parser();
+  parser.setLanguage(language);
+  return parser;
+}
+
+// src/engine/queries.ts
+var ASSERT_CALLS = [
+  '(call_expression function: (identifier) @_g (#match? @_g "^(assert|invariant|require|precondition|invariantViolation)$")) @guard'
+];
+var TS_JS_CALLS = [
+  "(call_expression function: (identifier) @callee)",
+  "(call_expression function: (member_expression property: (property_identifier) @callee))",
+  "(new_expression constructor: (identifier) @callee)"
+];
+var TS_JS_IMPORTS = [
+  "(import_statement source: (string) @source)",
+  '(call_expression function: (identifier) @_req (#eq? @_req "require") arguments: (arguments (string) @source))'
+];
+var TYPESCRIPT = {
+  defs: [
+    { kind: "function", query: "(function_declaration name: (identifier) @name) @def" },
+    {
+      kind: "function",
+      query: "(generator_function_declaration name: (identifier) @name) @def"
+    },
+    {
+      kind: "function",
+      query: "(variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression)]) @def"
+    },
+    { kind: "method", query: "(method_definition name: (property_identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (type_identifier) @name) @def" },
+    { kind: "class", query: "(abstract_class_declaration name: (type_identifier) @name) @def" },
+    { kind: "interface", query: "(interface_declaration name: (type_identifier) @name) @def" }
+  ],
+  calls: TS_JS_CALLS,
+  imports: TS_JS_IMPORTS,
+  heritage: [
+    "(class_heritage (extends_clause value: (identifier) @extends))",
+    "(class_heritage (extends_clause value: (member_expression property: (property_identifier) @extends)))",
+    "(class_heritage (implements_clause (type_identifier) @implements))",
+    "(extends_type_clause type: (type_identifier) @extends)"
+  ],
+  guards: ASSERT_CALLS
+};
+var JAVASCRIPT = {
+  defs: [
+    { kind: "function", query: "(function_declaration name: (identifier) @name) @def" },
+    {
+      kind: "function",
+      query: "(generator_function_declaration name: (identifier) @name) @def"
+    },
+    {
+      kind: "function",
+      query: "(variable_declarator name: (identifier) @name value: [(arrow_function) (function_expression)]) @def"
+    },
+    { kind: "method", query: "(method_definition name: (property_identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (identifier) @name) @def" }
+  ],
+  calls: TS_JS_CALLS,
+  imports: TS_JS_IMPORTS,
+  heritage: [
+    "(class_heritage (identifier) @extends)",
+    "(class_heritage (member_expression property: (property_identifier) @extends))"
+  ],
+  guards: ASSERT_CALLS
+};
+var PYTHON = {
+  defs: [
+    { kind: "function", query: "(function_definition name: (identifier) @name) @def" },
+    { kind: "class", query: "(class_definition name: (identifier) @name) @def" }
+  ],
+  calls: [
+    "(call function: (identifier) @callee)",
+    "(call function: (attribute attribute: (identifier) @callee))"
+  ],
+  imports: [
+    "(import_statement name: (dotted_name) @source)",
+    "(import_from_statement module_name: (dotted_name) @source)",
+    // Relative imports (`from .models import X`, `from ..core.utils import Y`) —
+    // the module is a `relative_import` node, not a `dotted_name`. These are the
+    // bulk of intra-package edges and were previously dropped entirely.
+    "(import_from_statement module_name: (relative_import) @source)"
+  ],
+  heritage: ["(class_definition superclasses: (argument_list (identifier) @extends))"],
+  guards: ["(assert_statement) @guard"]
+};
+var GO = {
+  defs: [
+    { kind: "function", query: "(function_declaration name: (identifier) @name) @def" },
+    { kind: "method", query: "(method_declaration name: (field_identifier) @name) @def" },
+    { kind: "class", query: "(type_declaration (type_spec name: (type_identifier) @name)) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (selector_expression field: (field_identifier) @callee))"
+  ],
+  imports: ["(import_spec path: (interpreted_string_literal) @source)"],
+  heritage: []
+};
+var JAVA = {
+  defs: [
+    { kind: "method", query: "(method_declaration name: (identifier) @name) @def" },
+    { kind: "method", query: "(constructor_declaration name: (identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (identifier) @name) @def" },
+    { kind: "interface", query: "(interface_declaration name: (identifier) @name) @def" }
+  ],
+  calls: ["(method_invocation name: (identifier) @callee)", "(object_creation_expression type: (type_identifier) @callee)"],
+  imports: ["(import_declaration (scoped_identifier) @source)"],
+  heritage: [
+    "(superclass (type_identifier) @extends)",
+    "(super_interfaces (type_list (type_identifier) @implements))"
+  ]
+};
+var RUST = {
+  defs: [
+    { kind: "function", query: "(function_item name: (identifier) @name) @def" },
+    { kind: "class", query: "(struct_item name: (type_identifier) @name) @def" },
+    { kind: "class", query: "(enum_item name: (type_identifier) @name) @def" },
+    { kind: "interface", query: "(trait_item name: (type_identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (field_expression field: (field_identifier) @callee))",
+    "(call_expression function: (scoped_identifier name: (identifier) @callee))"
+  ],
+  imports: ["(use_declaration (scoped_identifier) @source)"],
+  heritage: []
+};
+var C_SHARP = {
+  defs: [
+    { kind: "method", query: "(method_declaration name: (identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (identifier) @name) @def" },
+    { kind: "interface", query: "(interface_declaration name: (identifier) @name) @def" },
+    { kind: "class", query: "(struct_declaration name: (identifier) @name) @def" }
+  ],
+  calls: ["(invocation_expression function: (member_access_expression name: (identifier) @callee))", "(invocation_expression function: (identifier) @callee)"],
+  imports: ["(using_directive (qualified_name) @source)", "(using_directive (identifier) @source)"],
+  heritage: ["(base_list (identifier) @extends)"]
+};
+var RUBY = {
+  defs: [
+    { kind: "method", query: "(method name: (identifier) @name) @def" },
+    { kind: "class", query: "(class name: (constant) @name) @def" },
+    { kind: "module", query: "(module name: (constant) @name) @def" }
+  ],
+  calls: ["(call method: (identifier) @callee)", "(command method: (identifier) @callee)"],
+  imports: [
+    '(call method: (identifier) @_m (#match? @_m "require") arguments: (argument_list (string (string_content) @source)))'
+  ],
+  heritage: ["(class (superclass (constant) @extends))"]
+};
+var PHP = {
+  defs: [
+    { kind: "function", query: "(function_definition name: (name) @name) @def" },
+    {
+      kind: "function",
+      query: "(assignment_expression left: (variable_name (name) @name) right: [(anonymous_function_creation_expression) (arrow_function)]) @def"
+    },
+    { kind: "method", query: "(method_declaration name: (name) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (name) @name) @def" },
+    { kind: "class", query: "(trait_declaration name: (name) @name) @def" },
+    { kind: "interface", query: "(interface_declaration name: (name) @name) @def" }
+  ],
+  calls: [
+    "(function_call_expression function: (name) @callee)",
+    "(member_call_expression name: (name) @callee)",
+    "(nullsafe_member_call_expression name: (name) @callee)",
+    "(scoped_call_expression name: (name) @callee)",
+    "(object_creation_expression (name) @callee)"
+  ],
+  imports: [
+    "(namespace_use_clause (qualified_name) @source)",
+    "(namespace_use_clause (name) @source)",
+    "[(require_expression (string) @source) (require_once_expression (string) @source) (include_expression (string) @source) (include_once_expression (string) @source)]"
+  ],
+  heritage: ["(base_clause (name) @extends)", "(class_interface_clause (name) @implements)"],
+  guards: ['(function_call_expression function: (name) @_g (#eq? @_g "assert")) @guard']
+};
+var KOTLIN = {
+  defs: [
+    { kind: "function", query: "(function_declaration (simple_identifier) @name) @def" },
+    { kind: "class", query: '(class_declaration "class" (type_identifier) @name) @def' },
+    { kind: "interface", query: '(class_declaration "interface" (type_identifier) @name) @def' },
+    { kind: "class", query: "(object_declaration (type_identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression (simple_identifier) @callee)",
+    "(call_expression (navigation_expression (navigation_suffix (simple_identifier) @callee)))"
+  ],
+  imports: ["(import_header (identifier) @source)"],
+  heritage: [
+    "(delegation_specifier (constructor_invocation (user_type (type_identifier) @extends)))",
+    "(delegation_specifier (user_type (type_identifier) @implements))"
+  ],
+  guards: ['(call_expression (simple_identifier) @_g (#match? @_g "^(require|check|assert)$")) @guard']
+};
+var SWIFT = {
+  defs: [
+    { kind: "function", query: "(function_declaration name: (simple_identifier) @name) @def" },
+    { kind: "method", query: "(protocol_function_declaration name: (simple_identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (type_identifier) @name) @def" },
+    { kind: "class", query: "(class_declaration name: (user_type (type_identifier) @name)) @def" },
+    { kind: "interface", query: "(protocol_declaration name: (type_identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression (simple_identifier) @callee)",
+    "(call_expression (navigation_expression suffix: (navigation_suffix suffix: (simple_identifier) @callee)))"
+  ],
+  imports: ["(import_declaration (identifier) @source)"],
+  heritage: ["(inheritance_specifier inherits_from: (user_type (type_identifier) @extends))"],
+  guards: [
+    '(call_expression (simple_identifier) @_g (#match? @_g "^(assert|precondition|assertionFailure|preconditionFailure)$")) @guard'
+  ]
+};
+var SCALA = {
+  defs: [
+    { kind: "function", query: "(function_definition name: (identifier) @name) @def" },
+    { kind: "method", query: "(function_declaration name: (identifier) @name) @def" },
+    { kind: "class", query: "(class_definition name: (identifier) @name) @def" },
+    { kind: "interface", query: "(trait_definition name: (identifier) @name) @def" },
+    { kind: "module", query: "(object_definition name: (identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (field_expression field: (identifier) @callee))"
+  ],
+  imports: [
+    "(import_declaration path: (stable_identifier) @source)",
+    "(import_declaration path: (identifier) @source)"
+  ],
+  heritage: [
+    "(extends_clause type: (type_identifier) @extends)",
+    "(extends_clause type: (generic_type type: (type_identifier) @extends))",
+    "(extends_clause type: (compound_type base: (type_identifier) @extends))",
+    "(extends_clause type: (compound_type extra: (type_identifier) @implements))"
+  ],
+  guards: ['(call_expression function: (identifier) @_g (#match? @_g "^(require|assert|assume)$")) @guard']
+};
+var DART = {
+  defs: [
+    { kind: "function", query: "(function_signature name: (identifier) @name) @def" },
+    { kind: "method", query: "(constructor_signature name: (identifier) @name) @def" },
+    { kind: "class", query: "(class_definition name: (identifier) @name) @def" },
+    { kind: "class", query: "(mixin_declaration (identifier) @name) @def" }
+  ],
+  calls: [
+    "(_ (identifier) @callee . (selector (argument_part)))",
+    "(_ (selector (unconditional_assignable_selector (identifier) @callee)) . (selector (argument_part)))",
+    "(_ (selector (conditional_assignable_selector (identifier) @callee)) . (selector (argument_part)))",
+    "(cascade_section (cascade_selector (identifier) @callee) . (argument_part))"
+  ],
+  imports: ["(import_specification (configurable_uri (uri (string_literal) @source)))"],
+  heritage: [
+    "(superclass (type_identifier) @extends)",
+    "(interfaces (type_identifier) @implements)",
+    "(mixins (type_identifier) @implements)"
+  ],
+  guards: ["(assert_statement) @guard"]
+};
+var LUA = {
+  defs: [
+    { kind: "function", query: "(function_definition_statement name: (identifier) @name) @def" },
+    { kind: "function", query: "(function_definition_statement name: (variable field: (identifier) @name)) @def" },
+    { kind: "method", query: "(function_definition_statement name: (variable method: (identifier) @name)) @def" },
+    { kind: "function", query: "(local_function_definition_statement name: (identifier) @name) @def" },
+    {
+      kind: "function",
+      query: "(variable_assignment (variable_list (variable field: (identifier) @name)) (expression_list value: (function_definition))) @def"
+    },
+    {
+      kind: "function",
+      query: "(local_variable_declaration (variable_list (variable name: (identifier) @name)) (expression_list value: (function_definition))) @def"
+    }
+  ],
+  calls: [
+    "(call function: (variable name: (identifier) @callee))",
+    "(call function: (variable field: (identifier) @callee))",
+    "(call function: (variable method: (identifier) @callee))"
+  ],
+  imports: [
+    '(call function: (variable name: (identifier) @_r (#eq? @_r "require")) arguments: (argument_list (expression_list (string) @source)))'
+  ],
+  heritage: [],
+  guards: ['(call function: (variable name: (identifier) @_g (#eq? @_g "assert"))) @guard']
+};
+var ELIXIR = {
+  defs: [
+    { kind: "module", query: '(call target: (identifier) @_kw (#eq? @_kw "defmodule") (arguments (alias) @name)) @def' },
+    {
+      kind: "function",
+      query: '(call target: (identifier) @_kw (#match? @_kw "^(def|defp|defmacro|defmacrop|defguard|defguardp)$") (arguments (call target: (identifier) @name))) @def'
+    },
+    {
+      kind: "function",
+      query: '(call target: (identifier) @_kw (#match? @_kw "^(def|defp|defmacro|defmacrop)$") (arguments (identifier) @name)) @def'
+    },
+    {
+      kind: "function",
+      query: '(call target: (identifier) @_kw (#match? @_kw "^(def|defp|defmacro|defmacrop|defguard|defguardp)$") (arguments (binary_operator left: (call target: (identifier) @name)))) @def'
+    }
+  ],
+  calls: [
+    "(call target: (dot right: (identifier) @callee))",
+    '(call target: (identifier) @callee (#not-match? @callee "^(def|defp|defmacro|defmacrop|defmodule|defstruct|defprotocol|defimpl|defguard|defguardp|defdelegate|defexception|defoverridable|alias|import|require|use|quote|unquote|moduledoc|doc|spec|type|typep|typedoc|opaque|behaviour|impl|derive|enforce_keys|callback|macrocallback|optional_callbacks|compile|deprecated|dialyzer|external_resource|on_definition|on_load|after_compile|before_compile)$"))'
+  ],
+  imports: [
+    '(call target: (identifier) @_kw (#match? @_kw "^(alias|import|require|use)$") (arguments (alias) @source))',
+    '(call target: (identifier) @_kw (#match? @_kw "^(alias|import|require|use)$") (arguments (dot left: (alias) @source)))'
+  ],
+  heritage: []
+};
+var BASH = {
+  defs: [{ kind: "function", query: "(function_definition name: (word) @name) @def" }],
+  calls: ["(command name: (command_name (word) @callee))"],
+  imports: [
+    '(command name: (command_name (word) @_c (#match? @_c "^(source|\\.)$")) argument: [(word) (string) (raw_string) (concatenation)] @source)'
+  ],
+  heritage: []
+};
+var ZIG = {
+  defs: [
+    { kind: "function", query: "(function_declaration name: (identifier) @name) @def" },
+    { kind: "class", query: "(variable_declaration (identifier) @name (struct_declaration)) @def" },
+    { kind: "class", query: "(variable_declaration (identifier) @name (enum_declaration)) @def" },
+    { kind: "class", query: "(variable_declaration (identifier) @name (union_declaration)) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (field_expression member: (identifier) @callee))"
+  ],
+  imports: ['(builtin_function (builtin_identifier) @_i (#eq? @_i "@import") (arguments (string) @source))'],
+  heritage: [],
+  guards: ['(call_expression function: (field_expression member: (identifier) @_g (#eq? @_g "assert"))) @guard']
+};
+var C_LANG = {
+  defs: [
+    {
+      kind: "function",
+      query: "(function_definition declarator: [(function_declarator declarator: (identifier) @name) (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))]) @def"
+    },
+    { kind: "class", query: "(struct_specifier name: (type_identifier) @name body: (field_declaration_list)) @def" },
+    { kind: "class", query: "(enum_specifier name: (type_identifier) @name body: (enumerator_list)) @def" },
+    { kind: "class", query: "(type_definition declarator: (type_identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (field_expression field: (field_identifier) @callee))"
+  ],
+  imports: ["(preproc_include path: (string_literal) @source)", "(preproc_include path: (system_lib_string) @source)"],
+  heritage: [],
+  guards: ['(call_expression function: (identifier) @_g (#match? @_g "^(assert|static_assert)$")) @guard']
+};
+var CPP = {
+  defs: [
+    {
+      kind: "function",
+      query: "(function_definition declarator: [(function_declarator declarator: (identifier) @name) (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)) (reference_declarator (function_declarator declarator: (identifier) @name))]) @def"
+    },
+    { kind: "method", query: "(function_definition declarator: (function_declarator declarator: (field_identifier) @name)) @def" },
+    {
+      kind: "method",
+      query: "(function_definition declarator: [(function_declarator declarator: (qualified_identifier name: (identifier) @name)) (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))]) @def"
+    },
+    {
+      kind: "method",
+      query: "(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (qualified_identifier name: (identifier) @name)))) @def"
+    },
+    { kind: "class", query: "(class_specifier name: (type_identifier) @name body: (field_declaration_list)) @def" },
+    { kind: "class", query: "(struct_specifier name: (type_identifier) @name body: (field_declaration_list)) @def" },
+    { kind: "module", query: "(namespace_definition name: (namespace_identifier) @name) @def" }
+  ],
+  calls: [
+    "(call_expression function: (identifier) @callee)",
+    "(call_expression function: (field_expression field: (field_identifier) @callee))",
+    "(call_expression function: (qualified_identifier name: (identifier) @callee))",
+    "(call_expression function: (qualified_identifier name: (qualified_identifier name: (identifier) @callee)))",
+    "(new_expression type: (type_identifier) @callee)"
+  ],
+  imports: ["(preproc_include path: (string_literal) @source)", "(preproc_include path: (system_lib_string) @source)"],
+  heritage: [
+    "(base_class_clause (type_identifier) @extends)",
+    "(base_class_clause (qualified_identifier name: (type_identifier) @extends))"
+  ],
+  guards: ['(call_expression function: (identifier) @_g (#match? @_g "^(assert|static_assert)$")) @guard']
+};
+var BY_LANG = {
+  ts: TYPESCRIPT,
+  tsx: TYPESCRIPT,
+  js: JAVASCRIPT,
+  py: PYTHON,
+  go: GO,
+  java: JAVA,
+  rust: RUST,
+  cs: C_SHARP,
+  rb: RUBY,
+  php: PHP,
+  kotlin: KOTLIN,
+  swift: SWIFT,
+  scala: SCALA,
+  dart: DART,
+  lua: LUA,
+  ex: ELIXIR,
+  sh: BASH,
+  zig: ZIG,
+  c: C_LANG,
+  cpp: CPP
+};
+function queriesFor(langId) {
+  return BY_LANG[langId];
+}
+var encoder = new TextEncoder();
+function hashString(input) {
+  return bytesToHex(blake3(encoder.encode(input)));
+}
+function hashBytes(input) {
+  return bytesToHex(blake3(input));
+}
+function shortId(input) {
+  return bytesToHex(blake3(encoder.encode(input), { dkLen: 16 }));
+}
+function canonicalize(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeys(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/engine/parse.ts
+var compiledCache = /* @__PURE__ */ new Map();
+function compile(lang, langId, source) {
+  const key = `${langId}::${source}`;
+  if (compiledCache.has(key)) return compiledCache.get(key) ?? null;
+  let q = null;
+  try {
+    q = new Query(lang, source);
+  } catch {
+    q = null;
+  }
+  compiledCache.set(key, q);
+  return q;
+}
+function namedCapture(captures, name) {
+  return captures.find((c) => c.name === name)?.node;
+}
+var MEMBER_PARENT_TYPES = /* @__PURE__ */ new Set([
+  "member_expression",
+  // ts/js: obj.foo()
+  "attribute",
+  // python: obj.foo()
+  "selector_expression",
+  // go: pkg.Foo()
+  "field_expression",
+  // rust/scala/c/cpp/zig: recv.foo()
+  "scoped_identifier",
+  // rust: Type::foo()
+  "member_access_expression",
+  // c#: obj.Foo()
+  "qualified_identifier",
+  // c++: ns::f(), Type::m()
+  "dot",
+  // elixir: Mod.fun()
+  "navigation_suffix",
+  // kotlin/swift: recv.foo()
+  "member_call_expression",
+  // php: $x->m()
+  "nullsafe_member_call_expression",
+  // php: $x?->m()
+  "scoped_call_expression",
+  // php: X::m()
+  "unconditional_assignable_selector",
+  // dart: x.foo()
+  "conditional_assignable_selector",
+  // dart: x?.foo()
+  "cascade_selector"
+  // dart: x..foo()
+]);
+function isQualifiedCallee(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (MEMBER_PARENT_TYPES.has(parent.type)) return true;
+  if (parent.type === "method_invocation") return parent.childForFieldName("object") != null;
+  if (parent.type === "call") return parent.childForFieldName("receiver") != null;
+  if (parent.type === "variable") return parent.childForFieldName("table") != null;
+  return false;
+}
+function signatureOf(source, def, langId) {
+  const full = source.slice(def.startIndex, def.endIndex);
+  let head;
+  if (langId === "py") head = pythonHeader(full);
+  else if (langId === "rb" || langId === "ex") head = full.split("\n")[0];
+  else {
+    const braceIdx = full.indexOf("{");
+    head = braceIdx >= 0 ? full.slice(0, braceIdx) : full.split("\n")[0];
+  }
+  head = head.replace(/\s+/g, " ").trim().replace(/[:{]\s*$/, "").trim();
+  return head.length > 200 ? `${head.slice(0, 197)}...` : head;
+}
+function scrubbedDoc(source, def, langId) {
+  const doc = docOf(source, def, langId);
+  return doc === void 0 ? void 0 : redactSecrets(doc);
+}
+function docOf(source, def, langId) {
+  const lines = source.split("\n");
+  if (langId === "py") return pythonDocstring(lines, def.startPosition.row);
+  return leadingComment(lines, def.startPosition.row);
+}
+function leadingComment(lines, row) {
+  const collected = [];
+  for (let r = row - 1; r >= 0; r--) {
+    const line = lines[r].trim();
+    if (line === "") break;
+    if (/^(\/\/|\/\*\*?|\*\/?|#|;|--)/.test(line)) collected.unshift(line);
+    else break;
+  }
+  if (!collected.length) return void 0;
+  const text = collected.join("\n").replace(/\/\*\*?|\*\//g, " ").replace(/^\s*[*]\s?/gm, " ").replace(/^\s*(\/\/+|#+|;+|--)\s?/gm, " ").replace(/@\w+/g, " ");
+  return clip(text);
+}
+function pythonDocstring(lines, row) {
+  let r = row;
+  while (r < lines.length && !/:\s*(#.*)?$/.test(lines[r])) r++;
+  let j = r + 1;
+  while (j < lines.length && lines[j].trim() === "") j++;
+  const first = lines[j]?.trim() ?? "";
+  const m = /^[rubfRUBF]{0,2}("""|''')/.exec(first);
+  if (!m) return void 0;
+  const q = m[1];
+  let rest = first.slice(first.indexOf(q) + 3);
+  if (rest.includes(q)) return clip(rest.slice(0, rest.indexOf(q)));
+  const parts = [rest];
+  for (let k = j + 1; k < lines.length; k++) {
+    const idx = lines[k].indexOf(q);
+    if (idx >= 0) {
+      parts.push(lines[k].slice(0, idx));
+      break;
+    }
+    parts.push(lines[k]);
+  }
+  return clip(parts.join(" "));
+}
+function clip(s) {
+  const t = s.replace(/\s+/g, " ").trim();
+  if (!t) return void 0;
+  return t.length > 200 ? `${t.slice(0, 197)}...` : t;
+}
+function pythonHeader(full) {
+  let depth = 0;
+  for (let i = 0; i < full.length; i++) {
+    const c = full[i];
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === ":" && depth === 0) return full.slice(0, i);
+  }
+  return full.split("\n")[0];
+}
+async function parseSource(rel, langId, source) {
+  const def = langById(langId);
+  const langQueries = queriesFor(langId);
+  const hash = hashString(source);
+  const result = {
+    rel,
+    lang: langId,
+    hash,
+    bytes: Buffer.byteLength(source, "utf8"),
+    defs: [],
+    calls: [],
+    imports: [],
+    heritage: [],
+    guards: []
+  };
+  if (!def || !langQueries) return result;
+  const language = await loadLanguage(langId);
+  const parser = await parserFor(def);
+  const tree = parser.parse(source);
+  if (!tree) return result;
+  const root = tree.rootNode;
+  const rawDefs = [];
+  for (const rule of langQueries.defs) {
+    collectDefs(language, langId, source, root, rule, rawDefs);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = rawDefs.filter((d) => {
+    const key = `${d._start}:${d._end}:${d.name}:${d.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const byStart = [...deduped].sort((a, b) => a._start - b._start || b._end - a._end);
+  for (const d of byStart) {
+    const parent = enclosing(byStart, d._start, d._end);
+    d.qualifiedName = parent ? `${parent.qualifiedName}.${d.name}` : d.name;
+  }
+  result.defs = byStart.map((d) => {
+    const { _start, _end, ...rest } = d;
+    return rest;
+  }).sort(
+    (a, b) => a.startLine - b.startLine || a.qualifiedName.localeCompare(b.qualifiedName) || a.name.localeCompare(b.name)
+  );
+  const defNameBytes = /* @__PURE__ */ new Set();
+  for (const qsrc of langQueries.defs) {
+    const q = compile(language, langId, qsrc.query);
+    if (!q) continue;
+    for (const m of q.matches(root)) {
+      const nameNode = namedCapture(m.captures, "name");
+      if (nameNode) defNameBytes.add(nameNode.startIndex);
+    }
+  }
+  const calls = [];
+  for (const qsrc of langQueries.calls) {
+    const q = compile(language, langId, qsrc);
+    if (!q) continue;
+    for (const cap of q.captures(root)) {
+      if (cap.name !== "callee") continue;
+      if (defNameBytes.has(cap.node.startIndex)) continue;
+      calls.push({
+        callee: cap.node.text,
+        byte: cap.node.startIndex,
+        line: cap.node.startPosition.row + 1,
+        qualified: isQualifiedCallee(cap.node)
+      });
+    }
+  }
+  result.calls = calls.sort((a, b) => a.byte - b.byte || a.callee.localeCompare(b.callee));
+  const imports = [];
+  for (const qsrc of langQueries.imports) {
+    const q = compile(language, langId, qsrc);
+    if (!q) continue;
+    for (const cap of q.captures(root)) {
+      if (cap.name !== "source") continue;
+      imports.push({ source: stripQuotes(cap.node.text) });
+    }
+  }
+  result.imports = dedupeImports(imports);
+  const heritage = [];
+  for (const qsrc of langQueries.heritage) {
+    const q = compile(language, langId, qsrc);
+    if (!q) continue;
+    for (const cap of q.captures(root)) {
+      if (cap.name !== "extends" && cap.name !== "implements") continue;
+      heritage.push({ superName: cap.node.text, byte: cap.node.startIndex, kind: cap.name });
+    }
+  }
+  result.heritage = heritage.sort(
+    (a, b) => a.byte - b.byte || a.kind.localeCompare(b.kind) || a.superName.localeCompare(b.superName)
+  );
+  const guards = [];
+  for (const qsrc of langQueries.guards ?? []) {
+    const q = compile(language, langId, qsrc);
+    if (!q) continue;
+    for (const cap of q.captures(root)) {
+      if (cap.name !== "guard") continue;
+      const expr = cap.node.text.replace(/\s+/g, " ").trim();
+      guards.push({ expr: expr.length > 160 ? `${expr.slice(0, 157)}...` : expr, line: cap.node.startPosition.row + 1 });
+    }
+  }
+  result.guards = guards.sort((a, b) => a.line - b.line || a.expr.localeCompare(b.expr));
+  tree.delete();
+  return result;
+}
+function dartBodyOf(defNode) {
+  if (!defNode.type.endsWith("_signature")) return null;
+  if (defNode.nextNamedSibling?.type === "function_body") return defNode.nextNamedSibling;
+  const wrapper = defNode.parent;
+  if (wrapper?.type === "method_signature" && wrapper.nextNamedSibling?.type === "function_body") {
+    return wrapper.nextNamedSibling;
+  }
+  return null;
+}
+function collectDefs(language, langId, source, root, rule, out) {
+  const q = compile(language, langId, rule.query);
+  if (!q) return;
+  for (const match of q.matches(root)) {
+    const defNode = namedCapture(match.captures, "def");
+    const nameNode = namedCapture(match.captures, "name");
+    if (!defNode || !nameNode) continue;
+    const spanEnd = dartBodyOf(defNode) ?? defNode;
+    out.push({
+      kind: rule.kind,
+      name: nameNode.text,
+      qualifiedName: nameNode.text,
+      // refined after nesting is computed
+      startLine: defNode.startPosition.row + 1,
+      endLine: spanEnd.endPosition.row + 1,
+      startByte: defNode.startIndex,
+      endByte: spanEnd.endIndex,
+      signature: rule.kind === "function" || rule.kind === "method" ? redactSecrets(signatureOf(source, defNode, langId)) : void 0,
+      // GUARDRAILS §1: signatures/docs are lifted verbatim from source and are
+      // persisted (graph.json, `vg share` commits it) — scrub at ingest.
+      doc: scrubbedDoc(source, defNode, langId),
+      visibility: void 0,
+      _start: defNode.startIndex,
+      _end: spanEnd.endIndex
+    });
+  }
+}
+function enclosing(defs, start, end) {
+  let best;
+  for (const d of defs) {
+    if (d._start === start && d._end === end) continue;
+    if (d._start <= start && d._end >= end) {
+      if (!best || d._end - d._start < best._end - best._start) best = d;
+    }
+  }
+  return best;
+}
+function stripQuotes(text) {
+  return text.replace(/^['"`]|['"`]$/g, "");
+}
+function dedupeImports(imports) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const i of imports.sort((a, b) => a.source.localeCompare(b.source))) {
+    if (seen.has(i.source)) continue;
+    seen.add(i.source);
+    out.push(i);
+  }
+  return out;
+}
+
+export { LANGUAGES, allLanguageIds, canonicalize, grammarSetVersion, grammarsSourceDir, hashBytes, hashString, langById, langForExtension, parseSource, resolvedGrammarFiles, setGrammarsOverride, shortId };
+//# sourceMappingURL=chunk-X5YT263H.js.map
+//# sourceMappingURL=chunk-X5YT263H.js.map