yandecode 0.1.0 → 0.2.0

package/dist/chunks/chunk-2S6B3DDQ.js

@@ -0,0 +1,1769 @@
+import { createRequire as __yandecodeCreateRequire } from 'node:module';
+const require = __yandecodeCreateRequire(import.meta.url);
+import {
+  CONFIG_FILENAME,
+  __commonJS,
+  __toESM,
+  openModuleDb,
+  splitIdentifier,
+  toFtsQuery
+} from "./chunk-Y2MIXROU.js";
+
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports, module) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => Object.defineProperty(object, key, { value });
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    };
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = (pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path, cache, checkUnignored, slices);
+      }
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._testOne(path, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    }
+  }
+});
+
+// packages/retrieval/src/chunking/languages.ts
+import { basename, extname } from "node:path";
+var BY_EXT = {
+  ts: "typescript",
+  mts: "typescript",
+  cts: "typescript",
+  tsx: "tsx",
+  js: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  jsx: "javascript",
+  py: "python",
+  go: "go",
+  java: "java",
+  rs: "rust",
+  md: "markdown",
+  mdx: "markdown",
+  json: "json",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  sh: "shell",
+  bash: "shell",
+  css: "css",
+  scss: "css",
+  html: "html",
+  sql: "sql",
+  txt: "text"
+};
+var BY_NAME = { Dockerfile: "text", Makefile: "text" };
+function detectLanguage(path) {
+  const name2 = basename(path);
+  if (BY_NAME[name2]) return BY_NAME[name2];
+  const ext = extname(name2).slice(1).toLowerCase();
+  return BY_EXT[ext] ?? null;
+}
+var GRAMMAR_FILES = {
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm",
+  go: "tree-sitter-go.wasm",
+  java: "tree-sitter-java.wasm",
+  rust: "tree-sitter-rust.wasm"
+};
+
+// packages/retrieval/src/chunking/parser-loader.ts
+import { createRequire } from "node:module";
+import Parser from "web-tree-sitter";
+var require2 = createRequire(import.meta.url);
+var parserInit = null;
+var languages = /* @__PURE__ */ new Map();
+async function loadLanguage(language) {
+  parserInit ??= Parser.init();
+  await parserInit;
+  let lang = languages.get(language);
+  if (!lang) {
+    const file = GRAMMAR_FILES[language];
+    if (!file) throw new Error(`no grammar for ${language}`);
+    lang = Parser.Language.load(require2.resolve(`tree-sitter-wasms/out/${file}`));
+    languages.set(language, lang);
+  }
+  return lang;
+}
+async function createParser(language) {
+  const lang = await loadLanguage(language);
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  return parser;
+}
+
+// packages/retrieval/src/symbols/extract.ts
+function name(n) {
+  return n.childForFieldName("name")?.text ?? null;
+}
+function endRowOf(n) {
+  return n.endPosition.column === 0 && n.endPosition.row > n.startPosition.row ? n.endPosition.row - 1 : n.endPosition.row;
+}
+function unitOf(n, kind, symbol, members = []) {
+  return { kind, symbol, startRow: n.startPosition.row, endRow: endRowOf(n), members };
+}
+function firstStringArg(call) {
+  const args = call.childForFieldName("arguments");
+  const s = args?.namedChildren.find((c) => c.type === "string" || c.type === "template_string");
+  return s ? s.text.replace(/^['"`]|['"`]$/g, "") : null;
+}
+var TEST_FNS = /* @__PURE__ */ new Set(["describe", "it", "test", "context", "suite"]);
+function jsMembers(body, parent) {
+  if (!body) return [];
+  const out = [];
+  for (const m of body.namedChildren) {
+    if (m.type === "method_definition" || m.type === "abstract_method_signature" || m.type === "method_signature") {
+      const n = name(m);
+      out.push(unitOf(m, "method", parent && n ? `${parent}/${n}` : n));
+    }
+  }
+  return out;
+}
+var JS_DECLARATIONS = {
+  class_declaration: "class",
+  abstract_class_declaration: "class",
+  interface_declaration: "interface",
+  type_alias_declaration: "type",
+  enum_declaration: "enum",
+  function_declaration: "function",
+  generator_function_declaration: "function",
+  /** `declare function f(): T;` in .d.ts files. */
+  function_signature: "function"
+};
+var FUNCTION_VALUES = /* @__PURE__ */ new Set(["arrow_function", "function", "function_expression"]);
+function jsFunctionVariable(n) {
+  const decl = n.namedChildren.find((c) => c.type === "variable_declarator");
+  const value = decl?.childForFieldName("value");
+  if (!value || !FUNCTION_VALUES.has(value.type)) return null;
+  return { kind: "function", symbol: decl ? name(decl) : null };
+}
+function jsTestCall(n) {
+  const call = n.namedChildren[0];
+  if (call?.type !== "call_expression") return null;
+  const fn = call.childForFieldName("function")?.text ?? "";
+  return TEST_FNS.has(fn.split(".")[0] ?? "") ? { kind: "test", symbol: firstStringArg(call) } : null;
+}
+function jsUnwrap(n) {
+  const exported = n.type === "export_statement" ? n.childForFieldName("declaration") ?? n : n;
+  return exported.type === "ambient_declaration" ? exported.namedChildren[0] ?? exported : exported;
+}
+var JS_RULES = {
+  unwrap: jsUnwrap,
+  classify: (n) => {
+    const kind = JS_DECLARATIONS[n.type];
+    if (kind) return { kind, symbol: name(n) };
+    if (n.type === "lexical_declaration" || n.type === "variable_declaration") {
+      return jsFunctionVariable(n);
+    }
+    return n.type === "expression_statement" ? jsTestCall(n) : null;
+  },
+  members: (n, parent) => n.type.endsWith("class_declaration") ? jsMembers(n.childForFieldName("body"), parent) : []
+};
+var PY_RULES = {
+  unwrap: (n) => n.type === "decorated_definition" ? n.childForFieldName("definition") ?? n : n,
+  classify: (n) => {
+    if (n.type === "class_definition") return { kind: "class", symbol: name(n) };
+    if (n.type === "function_definition") return { kind: "function", symbol: name(n) };
+    return null;
+  },
+  members: (n, parent) => {
+    if (n.type !== "class_definition") return [];
+    const body = n.childForFieldName("body");
+    const out = [];
+    for (const raw of body?.namedChildren ?? []) {
+      const m = PY_RULES.unwrap(raw);
+      if (m.type === "function_definition") {
+        const nm = name(m);
+        out.push(unitOf(raw, "method", parent && nm ? `${parent}/${nm}` : nm));
+      }
+    }
+    return out;
+  }
+};
+function goMethod(n) {
+  const receiver = n.childForFieldName("receiver")?.namedChildren[0];
+  const receiverType = receiver?.childForFieldName("type")?.text.replace(/^\*/, "") ?? null;
+  const method = name(n);
+  return { kind: "method", symbol: receiverType && method ? `${receiverType}/${method}` : method };
+}
+var GO_TYPE_KINDS = {
+  struct_type: "struct",
+  interface_type: "interface"
+};
+function goType(n) {
+  const spec = n.namedChildren.find((c) => c.type === "type_spec");
+  const shape = spec?.childForFieldName("type")?.type ?? "";
+  return { kind: GO_TYPE_KINDS[shape] ?? "type", symbol: spec ? name(spec) : null };
+}
+var GO_RULES = {
+  unwrap: (n) => n,
+  classify: (n) => {
+    if (n.type === "function_declaration") return { kind: "function", symbol: name(n) };
+    if (n.type === "method_declaration") return goMethod(n);
+    return n.type === "type_declaration" ? goType(n) : null;
+  },
+  members: () => []
+};
+var JAVA_RULES = {
+  unwrap: (n) => n,
+  classify: (n) => {
+    if (n.type === "class_declaration") return { kind: "class", symbol: name(n) };
+    if (n.type === "interface_declaration") return { kind: "interface", symbol: name(n) };
+    if (n.type === "enum_declaration") return { kind: "enum", symbol: name(n) };
+    if (n.type === "record_declaration") return { kind: "class", symbol: name(n) };
+    return null;
+  },
+  members: (n, parent) => {
+    const body = n.childForFieldName("body");
+    const out = [];
+    for (const m of body?.namedChildren ?? []) {
+      if (m.type === "method_declaration" || m.type === "constructor_declaration") {
+        const nm = name(m);
+        out.push(unitOf(m, "method", parent && nm ? `${parent}/${nm}` : nm));
+      }
+    }
+    return out;
+  }
+};
+var RUST_DECLARATIONS = {
+  function_item: "function",
+  struct_item: "struct",
+  enum_item: "enum",
+  trait_item: "trait",
+  mod_item: "module"
+};
+var RUST_RULES = {
+  unwrap: (n) => n,
+  classify: (n) => {
+    if (n.type === "impl_item") {
+      return { kind: "impl", symbol: n.childForFieldName("type")?.text ?? null };
+    }
+    const kind = RUST_DECLARATIONS[n.type];
+    return kind ? { kind, symbol: name(n) } : null;
+  },
+  members: (n, parent) => {
+    if (n.type !== "impl_item" && n.type !== "trait_item") return [];
+    const body = n.childForFieldName("body");
+    const out = [];
+    for (const m of body?.namedChildren ?? []) {
+      if (m.type === "function_item" || m.type === "function_signature_item") {
+        const nm = name(m);
+        out.push(unitOf(m, "method", parent && nm ? `${parent}/${nm}` : nm));
+      }
+    }
+    return out;
+  }
+};
+var RULES = {
+  typescript: JS_RULES,
+  tsx: JS_RULES,
+  javascript: JS_RULES,
+  python: PY_RULES,
+  go: GO_RULES,
+  java: JAVA_RULES,
+  rust: RUST_RULES
+};
+function supportsSymbols(language) {
+  return language !== null && language in RULES;
+}
+async function extractUnits(content, language) {
+  const rules = RULES[language];
+  if (!rules) throw new Error(`unsupported language ${language}`);
+  const parser = await createParser(language);
+  const tree = parser.parse(content);
+  try {
+    const units = [];
+    for (const top of tree.rootNode.namedChildren) {
+      const inner = rules.unwrap(top);
+      const cls = rules.classify(inner);
+      if (!cls) continue;
+      units.push(unitOf(top, cls.kind, cls.symbol, rules.members(inner, cls.symbol)));
+    }
+    return units.sort((a, b) => a.startRow - b.startRow);
+  } finally {
+    tree.delete();
+    parser.delete();
+  }
+}
+function signatureOf(lines, row) {
+  const line = (lines[row] ?? "").trim().replace(/\s*\{\s*$/, "");
+  return line.length > 200 ? `${line.slice(0, 197)}...` : line;
+}
+async function extractSymbols(content, language) {
+  const lines = content.split("\n");
+  const out = [];
+  const visit = (unit, parent) => {
+    if (unit.symbol) {
+      out.push({
+        namePath: unit.symbol,
+        name: unit.symbol.split("/").pop(),
+        kind: unit.kind,
+        startLine: unit.startRow + 1,
+        endLine: unit.endRow + 1,
+        signature: signatureOf(lines, unit.startRow),
+        parent
+      });
+    }
+    for (const member of unit.members) visit(member, unit.symbol);
+  };
+  for (const unit of await extractUnits(content, language)) visit(unit, null);
+  return out;
+}
+
+// packages/retrieval/src/code-index/code-index.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { basename as basename2, dirname, join as join3 } from "node:path";
+
+// packages/retrieval/src/chunking/tokens.ts
+var ApproxTokenCounter = class {
+  countTokens(text) {
+    return Promise.resolve(Math.ceil(text.length / 4));
+  }
+};
+
+// packages/retrieval/src/chunking/types.ts
+var DEFAULT_LIMITS = { targetTokens: 350, maxTokens: 450, overlapTokens: 50 };
+
+// packages/retrieval/src/chunking/line-chunker.ts
+var FRAGMENT_CHARS = 1600;
+var LineChunker = class {
+  constructor(counter, limits = DEFAULT_LIMITS) {
+    this.counter = counter;
+    this.limits = limits;
+  }
+  counter;
+  limits;
+  chunk(_path, content, language) {
+    return this.chunkLines(content.split("\n"), 1, language ?? "text", null);
+  }
+  async chunkLines(lines, firstLine, kind, symbol) {
+    const tokens = await Promise.all(lines.map((l) => this.counter.countTokens(l)));
+    const out = [];
+    let current = [];
+    let currentTokens = 0;
+    const emit = (indices) => {
+      if (indices.length === 0) return;
+      const text = indices.map((i) => lines[i] ?? "").join("\n");
+      if (text.trim().length === 0) return;
+      out.push({
+        kind,
+        symbol,
+        startLine: firstLine + indices[0],
+        endLine: firstLine + indices[indices.length - 1],
+        content: text
+      });
+    };
+    for (let i = 0; i < lines.length; i++) {
+      const t = tokens[i] ?? 0;
+      if (t > this.limits.maxTokens) {
+        emit(current);
+        current = [];
+        currentTokens = 0;
+        const line = lines[i] ?? "";
+        for (let off = 0; off < line.length; off += FRAGMENT_CHARS) {
+          out.push({
+            kind: "fragment",
+            symbol,
+            startLine: firstLine + i,
+            endLine: firstLine + i,
+            content: line.slice(off, off + FRAGMENT_CHARS)
+          });
+        }
+        continue;
+      }
+      if (currentTokens + t > this.limits.targetTokens && current.length > 0) {
+        emit(current);
+        const overlap = [];
+        let overlapTokens = 0;
+        for (let j = current.length - 1; j >= 0; j--) {
+          const idx = current[j];
+          const lt = tokens[idx] ?? 0;
+          if (overlapTokens + lt > this.limits.overlapTokens) break;
+          overlap.unshift(idx);
+          overlapTokens += lt;
+        }
+        current = overlap;
+        currentTokens = overlapTokens;
+      }
+      current.push(i);
+      currentTokens += t;
+    }
+    emit(current);
+    return out;
+  }
+};
+
+// packages/retrieval/src/chunking/markdown-chunker.ts
+var HEADING = /^#{1,6}\s+(.*)$/;
+var MarkdownChunker = class {
+  constructor(counter, line, limits = DEFAULT_LIMITS) {
+    this.counter = counter;
+    this.line = line;
+    this.limits = limits;
+  }
+  counter;
+  line;
+  limits;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async chunk(_path, content, _language) {
+    const lines = content.split("\n");
+    const sections = [];
+    let current = { symbol: null, start: 0, end: -1 };
+    for (let i = 0; i < lines.length; i++) {
+      const m = HEADING.exec(lines[i] ?? "");
+      if (m) {
+        current.end = i - 1;
+        if (current.end >= current.start) sections.push(current);
+        current = { symbol: m[1].trim(), start: i, end: -1 };
+      }
+    }
+    current.end = lines.length - 1;
+    if (current.end >= current.start) sections.push(current);
+    const out = [];
+    for (const s of sections) {
+      const body = lines.slice(s.start, s.end + 1);
+      if (body.join("\n").trim().length === 0) continue;
+      const tokens = await this.counter.countTokens(body.join("\n"));
+      if (tokens <= this.limits.maxTokens) {
+        out.push({
+          kind: "section",
+          symbol: s.symbol,
+          startLine: s.start + 1,
+          endLine: s.end + 1,
+          content: body.join("\n")
+        });
+      } else {
+        out.push(...await this.line.chunkLines(body, s.start + 1, "section", s.symbol));
+      }
+    }
+    return out;
+  }
+};
+
+// packages/retrieval/src/chunking/tree-sitter-chunker.ts
+var TreeSitterChunker = class {
+  constructor(counter, line, limits = DEFAULT_LIMITS) {
+    this.counter = counter;
+    this.line = line;
+    this.limits = limits;
+  }
+  counter;
+  line;
+  limits;
+  supports(language) {
+    return supportsSymbols(language);
+  }
+  async chunk(_path, content, language) {
+    if (!this.supports(language)) throw new Error(`unsupported language ${String(language)}`);
+    const units = await extractUnits(content, language);
+    const lines = content.split("\n");
+    const out = [];
+    let cursor = 0;
+    for (const u of units) {
+      if (u.startRow > cursor) out.push(...await this.gap(lines, cursor, u.startRow - 1));
+      out.push(...await this.unitChunks(lines, u));
+      cursor = Math.max(cursor, u.endRow + 1);
+    }
+    if (cursor <= lines.length - 1) out.push(...await this.gap(lines, cursor, lines.length - 1));
+    return out.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+  }
+  async gap(lines, startRow, endRow) {
+    let start = startRow;
+    let end = endRow;
+    while (start <= end && (lines[start] ?? "").trim().length === 0) start++;
+    while (end >= start && (lines[end] ?? "").trim().length === 0) end--;
+    if (start > end) return [];
+    const slice = lines.slice(start, end + 1);
+    return this.line.chunkLines(slice, start + 1, "module", null);
+  }
+  async unitChunks(lines, u) {
+    const text = lines.slice(u.startRow, u.endRow + 1).join("\n");
+    const tokens = await this.counter.countTokens(text);
+    if (tokens <= this.limits.maxTokens) {
+      return [
+        {
+          kind: u.kind,
+          symbol: u.symbol,
+          startLine: u.startRow + 1,
+          endLine: u.endRow + 1,
+          content: text
+        }
+      ];
+    }
+    if (u.members.length === 0)
+      return this.line.chunkLines(
+        lines.slice(u.startRow, u.endRow + 1),
+        u.startRow + 1,
+        u.kind,
+        u.symbol
+      );
+    const out = [];
+    const covered = /* @__PURE__ */ new Set();
+    for (const m of u.members) {
+      for (let r = m.startRow; r <= m.endRow; r++) covered.add(r);
+      const mText = lines.slice(m.startRow, m.endRow + 1).join("\n");
+      const mTokens = await this.counter.countTokens(mText);
+      if (mTokens <= this.limits.maxTokens)
+        out.push({
+          kind: m.kind,
+          symbol: m.symbol,
+          startLine: m.startRow + 1,
+          endLine: m.endRow + 1,
+          content: mText
+        });
+      else
+        out.push(
+          ...await this.line.chunkLines(
+            lines.slice(m.startRow, m.endRow + 1),
+            m.startRow + 1,
+            m.kind,
+            m.symbol
+          )
+        );
+    }
+    const shellRows = [];
+    for (let r = u.startRow; r <= u.endRow; r++) if (!covered.has(r)) shellRows.push(r);
+    const shellLines = shellRows.map((r) => lines[r] ?? "");
+    if (shellLines.some((l) => l.trim().length > 0)) {
+      const first = shellRows[0];
+      const shell = await this.line.chunkLines(shellLines, first + 1, u.kind, u.symbol);
+      out.push(...shell.map((c) => ({ ...c, startLine: u.startRow + 1, endLine: u.endRow + 1 })));
+    }
+    return out;
+  }
+};
+
+// packages/retrieval/src/chunking/router.ts
+var ChunkerRouter = class {
+  constructor(treeSitter, markdown, line) {
+    this.treeSitter = treeSitter;
+    this.markdown = markdown;
+    this.line = line;
+  }
+  treeSitter;
+  markdown;
+  line;
+  async chunk(path, content, language) {
+    if (language === "markdown") return this.markdown.chunk(path, content, language);
+    if (this.treeSitter.supports(language)) {
+      try {
+        return await this.treeSitter.chunk(path, content, language);
+      } catch {
+        return this.line.chunk(path, content, language);
+      }
+    }
+    return this.line.chunk(path, content, language ?? "text");
+  }
+};
+function createDefaultChunker(counter, limits = DEFAULT_LIMITS) {
+  const line = new LineChunker(counter, limits);
+  return new ChunkerRouter(
+    new TreeSitterChunker(counter, line, limits),
+    new MarkdownChunker(counter, line, limits),
+    line
+  );
+}
+
+// packages/retrieval/src/graph/import-extractor.ts
+var JS_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript"]);
+function stripQuotes(text) {
+  return text.replace(/^['"`]|['"`]$/g, "");
+}
+function jsSpecifiers(root) {
+  const out = [];
+  for (const top of root.namedChildren) {
+    if (top.type !== "import_statement" && top.type !== "export_statement") continue;
+    const source = top.childForFieldName("source");
+    if (source) out.push(stripQuotes(source.text));
+  }
+  return out;
+}
+function pythonSpecifiers(root) {
+  const out = [];
+  for (const top of root.namedChildren) {
+    if (top.type === "import_statement") {
+      for (const child of top.namedChildren) {
+        if (child.type === "dotted_name") out.push(child.text);
+        else if (child.type === "aliased_import") {
+          const dotted = child.namedChildren.find((c) => c.type === "dotted_name");
+          if (dotted) out.push(dotted.text);
+        }
+      }
+    } else if (top.type === "import_from_statement") {
+      const moduleName = top.childForFieldName("module_name");
+      if (moduleName) out.push(moduleName.text);
+    }
+  }
+  return out;
+}
+async function extractImports(content, language) {
+  if (language === null || !(JS_LANGUAGES.has(language) || language === "python")) return [];
+  const parser = await createParser(language);
+  try {
+    const tree = parser.parse(content);
+    try {
+      return JS_LANGUAGES.has(language) ? jsSpecifiers(tree.rootNode) : pythonSpecifiers(tree.rootNode);
+    } finally {
+      tree.delete();
+    }
+  } finally {
+    parser.delete();
+  }
+}
+
+// packages/retrieval/src/graph/pagerank.ts
+function adjacency(graph, nodes) {
+  const outDegree = /* @__PURE__ */ new Map();
+  const incoming = new Map(nodes.map((node) => [node, []]));
+  for (const node of nodes) {
+    const targets = [...graph.edges.get(node) ?? []];
+    outDegree.set(node, targets.length);
+    for (const target of targets) incoming.get(target)?.push(node);
+  }
+  return { outDegree, incoming };
+}
+function pagerank(graph, options = {}) {
+  const d = options.dampingFactor ?? 0.85;
+  const iterations = options.iterations ?? 20;
+  const nodes = [...graph.nodes];
+  const n = nodes.length;
+  if (n === 0) return /* @__PURE__ */ new Map();
+  const { outDegree, incoming } = adjacency(graph, nodes);
+  let scores = new Map(nodes.map((node) => [node, 1 / n]));
+  for (let iter = 0; iter < iterations; iter += 1) {
+    const danglingSum = nodes.filter((node) => (outDegree.get(node) ?? 0) === 0).reduce((sum, node) => sum + (scores.get(node) ?? 0), 0);
+    const next = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      let incomingSum = 0;
+      for (const source of incoming.get(node) ?? []) {
+        const degree = outDegree.get(source) ?? 0;
+        if (degree > 0) incomingSum += (scores.get(source) ?? 0) / degree;
+      }
+      next.set(node, (1 - d) / n + d * (danglingSum / n + incomingSum));
+    }
+    scores = next;
+  }
+  return scores;
+}
+
+// packages/retrieval/src/graph/symbol-graph.ts
+import { posix } from "node:path";
+var JS_SUFFIXES = ["", ".ts", ".tsx", ".js", ".jsx"];
+var JS_INDEX_SUFFIXES = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+var PY_SUFFIXES = ["", ".py", "/__init__.py"];
+function pythonSpecifierToRelativePath(specifier) {
+  const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
+  const rest = specifier.slice(dots).replace(/\./g, "/");
+  const prefix = dots <= 1 ? "./" : "../".repeat(dots - 1);
+  return rest.length > 0 ? `${prefix}${rest}` : prefix.replace(/\/$/, "") || ".";
+}
+function withoutJsExtension(path) {
+  const match = /\.jsx?$/.exec(path);
+  return match ? path.slice(0, -match[0].length) : null;
+}
+function resolveOne(fromPath, relativeSpecifier, known) {
+  const base = posix.dirname(fromPath);
+  const joined = posix.normalize(posix.join(base, relativeSpecifier));
+  const suffixes = [...JS_SUFFIXES, ...JS_INDEX_SUFFIXES, ...PY_SUFFIXES];
+  for (const suffix of suffixes) {
+    const candidate = suffix ? `${joined}${suffix}` : joined;
+    if (known.has(candidate)) return candidate;
+  }
+  const withoutExt = withoutJsExtension(joined);
+  if (withoutExt) {
+    for (const candidate of [`${withoutExt}.ts`, `${withoutExt}.tsx`]) {
+      if (known.has(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function resolveSpecifier(fromPath, specifier, language, known) {
+  if (language === "python") {
+    if (!specifier.startsWith(".")) return null;
+    return resolveOne(fromPath, pythonSpecifierToRelativePath(specifier), known);
+  }
+  if (!specifier.startsWith(".")) return null;
+  return resolveOne(fromPath, specifier, known);
+}
+function buildFileGraph(files) {
+  const known = new Set(files.map((f) => f.path));
+  const edges = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const specifier of file.imports) {
+      const resolved = resolveSpecifier(file.path, specifier, file.language, known);
+      if (resolved && resolved !== file.path) targets.add(resolved);
+    }
+    edges.set(file.path, targets);
+  }
+  return { nodes: known, edges };
+}
+
+// packages/retrieval/src/lexical/identifiers.ts
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "const",
+  "let",
+  "var",
+  "function",
+  "return",
+  "import",
+  "export",
+  "from",
+  "class",
+  "this",
+  "new",
+  "if",
+  "else",
+  "for",
+  "while",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "async",
+  "await",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "void",
+  "string",
+  "number",
+  "boolean",
+  "def",
+  "self",
+  "pub",
+  "mut",
+  "impl",
+  "struct",
+  "enum",
+  "use",
+  "package",
+  "func",
+  "type",
+  "interface",
+  "extends",
+  "implements",
+  "default",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "typeof",
+  "instanceof"
+]);
+var MAX = 200;
+function identifiersOf(text) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (t) => {
+    if (t.length < 3 || KEYWORDS.has(t) || seen.has(t) || out.length >= MAX) return;
+    seen.add(t);
+    out.push(t);
+  };
+  for (const id of text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []) {
+    push(id.toLowerCase());
+    const parts = splitIdentifier(id);
+    if (parts.length > 1) for (const p of parts) push(p);
+  }
+  return out.join(" ");
+}
+
+// packages/retrieval/src/scanner/rules.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var import_ignore = __toESM(require_ignore(), 1);
+var DEFAULT_IGNORED_DIRS = [
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "target",
+  "vendor",
+  ".next",
+  ".cache",
+  ".yandecode"
+];
+var SECRET_PATTERNS = [
+  ".env",
+  ".env.*",
+  "*.pem",
+  "*.key",
+  "id_rsa",
+  "id_ed25519",
+  // Data/config files only: `secrets.ts` or `credentials.py` are source code and must stay indexed.
+  ...["credentials", "secrets"].flatMap(
+    (base) => ["json", "yml", "yaml", "toml", "ini", "env", "txt"].map((ext) => `${base}.${ext}`)
+  )
+];
+var MAX_FILE_BYTES = 512 * 1024;
+function isProbablyBinary(buf) {
+  return buf.subarray(0, 8192).includes(0);
+}
+function buildIgnore(root) {
+  const ig = (0, import_ignore.default)();
+  ig.add(DEFAULT_IGNORED_DIRS.map((dir) => `${dir}/`));
+  ig.add([...SECRET_PATTERNS]);
+  ig.add(`/${CONFIG_FILENAME}`);
+  const custom = join(root, ".yandecodeignore");
+  if (existsSync(custom)) ig.add(readFileSync(custom, "utf8"));
+  return ig;
+}
+
+// packages/retrieval/src/scanner/scanner.ts
+import { spawnSync } from "node:child_process";
+import { lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+function toPosix(p) {
+  return p.split(sep).join("/");
+}
+function isInsideRoot(root, target) {
+  const rel = relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !rel.startsWith(`..${sep}`);
+}
+function isGitRepo(root) {
+  const r = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+    cwd: root,
+    encoding: "utf8"
+  });
+  return r.status === 0 && r.stdout.trim() === "true";
+}
+function listViaGit(root) {
+  const r = spawnSync(
+    "git",
+    ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+    {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024
+    }
+  );
+  return r.stdout.split("\0").filter((p) => p.length > 0).map(toPosix);
+}
+function listViaWalk(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (DEFAULT_IGNORED_DIRS.includes(entry.name)) continue;
+        stack.push(join2(dir, entry.name));
+        continue;
+      }
+      out.push(toPosix(relative(root, join2(dir, entry.name))));
+    }
+  }
+  return out;
+}
+function listCandidatePaths(root) {
+  const raw = isGitRepo(root) ? listViaGit(root) : listViaWalk(root);
+  const ig = buildIgnore(root);
+  const kept = [];
+  for (const relPath of ig.filter(raw)) {
+    const absPath = join2(root, relPath);
+    const lst = lstatSync(absPath, { throwIfNoEntry: false });
+    if (!lst) continue;
+    if (lst.isSymbolicLink()) {
+      let real;
+      try {
+        real = realpathSync(absPath);
+      } catch {
+        continue;
+      }
+      if (!isInsideRoot(root, real)) continue;
+    }
+    const st = statSync(absPath, { throwIfNoEntry: false });
+    if (!st || !st.isFile()) continue;
+    if (st.size > MAX_FILE_BYTES) continue;
+    kept.push(relPath);
+  }
+  return kept;
+}
+
+// packages/retrieval/src/code-index/schema.ts
+var CODE_INDEX_MIGRATIONS = [
+  `
+  CREATE TABLE files (
+    path TEXT PRIMARY KEY,
+    language TEXT,
+    size INTEGER NOT NULL,
+    mtime_ms INTEGER NOT NULL,
+    hash TEXT NOT NULL,
+    indexed_at TEXT NOT NULL
+  );
+  CREATE TABLE symbols (
+    id INTEGER PRIMARY KEY,
+    path TEXT NOT NULL,
+    name TEXT NOT NULL,
+    name_path TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    signature TEXT NOT NULL,
+    parent TEXT
+  );
+  CREATE INDEX symbols_name ON symbols (name COLLATE NOCASE);
+  CREATE INDEX symbols_name_path ON symbols (name_path);
+  CREATE INDEX symbols_path ON symbols (path);
+  CREATE TABLE chunks (
+    id INTEGER PRIMARY KEY,
+    path TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    symbol TEXT,
+    content TEXT NOT NULL
+  );
+  CREATE INDEX chunks_path ON chunks (path);
+  CREATE VIRTUAL TABLE chunks_fts USING fts5 (body, idents, path, tokenize = 'porter unicode61');
+  CREATE TABLE imports (path TEXT NOT NULL, specifier TEXT NOT NULL);
+  CREATE INDEX imports_path ON imports (path);
+  CREATE TABLE edges (src TEXT NOT NULL, dst TEXT NOT NULL);
+  CREATE INDEX edges_dst ON edges (dst);
+  CREATE INDEX edges_src ON edges (src);
+  CREATE TABLE centrality (path TEXT PRIMARY KEY, score REAL NOT NULL);
+  `,
+  // v2: split symbol-name words (findOrCreateBySso → " find or create by sso ") for
+  // natural-language symbol matching; clearing files forces a full re-index to fill them.
+  `
+  ALTER TABLE symbols ADD COLUMN name_terms TEXT NOT NULL DEFAULT '';
+  DELETE FROM files;
+  DELETE FROM symbols;
+  DELETE FROM chunks;
+  DELETE FROM chunks_fts;
+  DELETE FROM imports;
+  `
+];
+
+// packages/retrieval/src/code-index/code-index.ts
+var RELATIVE_SCORE_FLOOR = 0.25;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "how",
+  "does",
+  "what",
+  "where",
+  "why",
+  "when",
+  "which",
+  "who",
+  "are",
+  "was",
+  "with",
+  "from",
+  "into",
+  "that",
+  "this",
+  "there",
+  "then",
+  "than",
+  "can",
+  "should",
+  "returned"
+]);
+function stem(word) {
+  const w = word.toLowerCase();
+  const stemmed = w.replace(/(ies|ied)$/, "y").replace(/(ing|ed|es|s|e)$/, "");
+  return stemmed.length >= 3 ? stemmed : w;
+}
+function nameTerms(namePath) {
+  const words = namePath.split(/[/.]/).flatMap((part) => splitIdentifier(part));
+  return ` ${[...new Set(words.filter((w) => w.length >= 3).map(stem))].join(" ")} `;
+}
+var PROSE_LANGUAGES = /* @__PURE__ */ new Set(["markdown"]);
+function toSymbol(row) {
+  return {
+    path: row.path,
+    name: row.name,
+    namePath: row.name_path,
+    kind: row.kind,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    signature: row.signature,
+    parent: row.parent
+  };
+}
+function escapeLike(text) {
+  return text.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var CodeIndex = class _CodeIndex {
+  constructor(db, root) {
+    this.db = db;
+    this.root = root;
+  }
+  db;
+  root;
+  chunker = createDefaultChunker(new ApproxTokenCounter());
+  static open(dbFile, root) {
+    mkdirSync(dirname(dbFile), { recursive: true });
+    return new _CodeIndex(openModuleDb(dbFile, CODE_INDEX_MIGRATIONS), root);
+  }
+  close() {
+    this.db.close();
+  }
+  stats() {
+    const count = (table) => this.db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n;
+    return { files: count("files"), symbols: count("symbols"), chunks: count("chunks") };
+  }
+  async sync() {
+    const started = Date.now();
+    const known = new Map(
+      this.db.prepare("SELECT path, size, mtime_ms, hash FROM files").all().map(
+        (r) => [r.path, r]
+      )
+    );
+    const report = {
+      added: 0,
+      changed: 0,
+      removed: 0,
+      unchanged: 0,
+      durationMs: 0,
+      parseFailures: []
+    };
+    const seen = /* @__PURE__ */ new Set();
+    const toIndex = [];
+    for (const path of listCandidatePaths(this.root)) {
+      const language = detectLanguage(path);
+      if (language !== null && PROSE_LANGUAGES.has(language)) continue;
+      const abs = join3(this.root, path);
+      const st = statSync2(abs, { throwIfNoEntry: false });
+      if (!st) continue;
+      const previous = known.get(path);
+      if (previous && previous.size === st.size && previous.mtime_ms === Math.trunc(st.mtimeMs)) {
+        seen.add(path);
+        report.unchanged++;
+        continue;
+      }
+      const buffer = readFileSync2(abs);
+      if (isProbablyBinary(buffer)) continue;
+      seen.add(path);
+      const hash = createHash("sha256").update(buffer).digest("hex");
+      if (previous && previous.hash === hash) {
+        this.db.prepare("UPDATE files SET size = ?, mtime_ms = ? WHERE path = ?").run(st.size, Math.trunc(st.mtimeMs), path);
+        report.unchanged++;
+        continue;
+      }
+      if (previous) report.changed++;
+      else report.added++;
+      toIndex.push({
+        path,
+        size: st.size,
+        mtimeMs: Math.trunc(st.mtimeMs),
+        hash,
+        content: buffer.toString("utf8")
+      });
+    }
+    const removed = [...known.keys()].filter((p) => !seen.has(p));
+    report.removed = removed.length;
+    const prepared = [];
+    for (const file of toIndex) {
+      const language = detectLanguage(file.path);
+      let symbols = [];
+      let imports = [];
+      try {
+        if (supportsSymbols(language)) symbols = await extractSymbols(file.content, language);
+        imports = await extractImports(file.content, language);
+      } catch (error) {
+        report.parseFailures.push({ path: file.path, error: error.message });
+      }
+      const chunks = await this.chunker.chunk(file.path, file.content, language);
+      prepared.push({ ...file, language, symbols, chunks, imports });
+    }
+    const deleteFile = (path) => {
+      this.db.prepare("DELETE FROM symbols WHERE path = ?").run(path);
+      this.db.prepare("DELETE FROM chunks_fts WHERE path = ?").run(path);
+      this.db.prepare("DELETE FROM chunks WHERE path = ?").run(path);
+      this.db.prepare("DELETE FROM imports WHERE path = ?").run(path);
+      this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
+    };
+    this.db.transaction(() => {
+      for (const path of removed) deleteFile(path);
+      const insertSymbol = this.db.prepare(
+        "INSERT INTO symbols (path, name, name_path, kind, start_line, end_line, signature, parent, name_terms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      );
+      const insertChunk = this.db.prepare(
+        "INSERT INTO chunks (path, start_line, end_line, symbol, content) VALUES (?, ?, ?, ?, ?)"
+      );
+      const insertFts = this.db.prepare(
+        "INSERT INTO chunks_fts (rowid, body, idents, path) VALUES (?, ?, ?, ?)"
+      );
+      const insertImport = this.db.prepare("INSERT INTO imports (path, specifier) VALUES (?, ?)");
+      for (const file of prepared) {
+        deleteFile(file.path);
+        this.db.prepare(
+          "INSERT INTO files (path, language, size, mtime_ms, hash, indexed_at) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(
+          file.path,
+          file.language,
+          file.size,
+          file.mtimeMs,
+          file.hash,
+          (/* @__PURE__ */ new Date()).toISOString()
+        );
+        for (const s of file.symbols) {
+          insertSymbol.run(
+            file.path,
+            s.name,
+            s.namePath,
+            s.kind,
+            s.startLine,
+            s.endLine,
+            s.signature,
+            s.parent,
+            nameTerms(s.namePath)
+          );
+        }
+        for (const c of file.chunks) {
+          const id = insertChunk.run(
+            file.path,
+            c.startLine,
+            c.endLine,
+            c.symbol,
+            c.content
+          ).lastInsertRowid;
+          const idents = `${identifiersOf(c.content)} ${c.symbol ? identifiersOf(c.symbol) : ""}`;
+          insertFts.run(
+            id,
+            c.content,
+            idents,
+            `${file.path} ${identifiersOf(basename2(file.path))}`
+          );
+        }
+        for (const spec of new Set(file.imports)) insertImport.run(file.path, spec);
+      }
+      if (prepared.length > 0 || removed.length > 0) this.rebuildGraph();
+    })();
+    report.durationMs = Date.now() - started;
+    return report;
+  }
+  rebuildGraph() {
+    const files = this.db.prepare("SELECT path, language FROM files").all();
+    const importsByPath = /* @__PURE__ */ new Map();
+    for (const row of this.db.prepare("SELECT path, specifier FROM imports").all()) {
+      const list = importsByPath.get(row.path) ?? [];
+      list.push(row.specifier);
+      importsByPath.set(row.path, list);
+    }
+    const graph = buildFileGraph(
+      files.map((f) => ({
+        path: f.path,
+        language: f.language,
+        imports: importsByPath.get(f.path) ?? []
+      }))
+    );
+    const ranks = pagerank(graph);
+    this.db.prepare("DELETE FROM edges").run();
+    this.db.prepare("DELETE FROM centrality").run();
+    const insertEdge = this.db.prepare("INSERT INTO edges (src, dst) VALUES (?, ?)");
+    for (const [src, targets] of graph.edges) for (const dst of targets) insertEdge.run(src, dst);
+    const insertRank = this.db.prepare("INSERT INTO centrality (path, score) VALUES (?, ?)");
+    for (const [path, score] of ranks) insertRank.run(path, score);
+  }
+  findSymbols(pattern, options = {}) {
+    const limit = options.limit ?? 20;
+    const clauses = [];
+    const params = [];
+    if (pattern.includes("/")) {
+      if (options.substring) {
+        clauses.push("name_path LIKE ? ESCAPE '\\'");
+        params.push(`%${escapeLike(pattern)}%`);
+      } else {
+        clauses.push("(name_path = ? OR name_path LIKE ? ESCAPE '\\')");
+        params.push(pattern, `%/${escapeLike(pattern)}`);
+      }
+    } else if (options.substring) {
+      clauses.push("name LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLike(pattern)}%`);
+    } else {
+      clauses.push("name = ? COLLATE NOCASE");
+      params.push(pattern);
+    }
+    if (options.path) {
+      clauses.push("(path = ? OR path LIKE ? ESCAPE '\\')");
+      params.push(options.path, `${escapeLike(options.path.replace(/\/$/, ""))}/%`);
+    }
+    const rows = this.db.prepare(
+      `SELECT s.* FROM symbols s LEFT JOIN centrality c ON c.path = s.path
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY (s.name = ?) DESC, COALESCE(c.score, 0) DESC, s.path, s.start_line LIMIT ?`
+    ).all(...params, pattern, limit);
+    return rows.map(toSymbol);
+  }
+  /**
+   * Symbols whose name shares at least `minMatches` words with a natural-language query
+   * ("how does SSO login create or find a user" → `UserRepository/findOrCreateBySso`).
+   */
+  findSymbolsByTerms(query, options = {}) {
+    const terms = [
+      ...new Set(
+        (query.toLowerCase().match(/[a-z0-9]{3,}/g) ?? []).filter((w) => !STOPWORDS.has(w)).map(stem)
+      )
+    ];
+    if (terms.length === 0) return [];
+    const rows = this.db.prepare(
+      `SELECT s.*, COALESCE(c.score, 0) AS centrality FROM symbols s LEFT JOIN centrality c ON c.path = s.path
+         WHERE ${terms.map(() => "instr(s.name_terms, ' ' || ? || ' ') > 0").join(" OR ")}`
+    ).all(...terms);
+    return rows.map((row) => ({
+      row,
+      matches: terms.filter((t) => row.name_terms.includes(` ${t} `)).length
+    })).filter((r) => r.matches >= (options.minMatches ?? 2)).sort(
+      (a, b) => b.matches - a.matches || b.row.centrality - a.row.centrality || a.row.name_path.length - b.row.name_path.length
+    ).slice(0, options.limit ?? 3).map((r) => toSymbol(r.row));
+  }
+  outline(path) {
+    return this.db.prepare("SELECT * FROM symbols WHERE path = ? ORDER BY start_line, end_line DESC").all(path).map(toSymbol);
+  }
+  definition(namePath, path) {
+    const symbol = this.findSymbols(namePath, path ? { path, limit: 1 } : { limit: 1 })[0];
+    if (!symbol) return null;
+    const lines = readFileSync2(join3(this.root, symbol.path), "utf8").split("\n");
+    return { ...symbol, body: lines.slice(symbol.startLine - 1, symbol.endLine).join("\n") };
+  }
+  /** Distinct file paths whose body matches a bare identifier (FTS), for reference scanning. */
+  pathsMatchingBody(identifier) {
+    if (!toFtsQuery(identifier)) return [];
+    return this.db.prepare("SELECT DISTINCT path FROM chunks_fts WHERE chunks_fts MATCH ?").all(`body:"${identifier.replace(/"/g, "")}"`).map((r) => r.path.split(" ")[0]);
+  }
+  /**
+   * Lines that mention the symbol's name as a whole identifier, outside its own definition.
+   *
+   * This is a lexical approximation (the precise path is `lsp_references`). To avoid grepping the
+   * bare last token, a qualified name path is anchored to a real definition first — like Serena,
+   * which resolves the symbol before finding references. An unresolvable qualified name returns
+   * nothing rather than every occurrence of the method name, and when the name is qualified the
+   * scan is narrowed to files related to the target (its definition files and files that mention
+   * the qualifying class), which cuts false positives for common method names.
+   */
+  references(namePath, limit = 50) {
+    const name2 = namePath.split("/").pop();
+    const qualifier = namePath.includes("/") ? namePath.split("/").slice(0, -1).pop() : null;
+    const definitions = this.findSymbols(namePath, { limit: 50 });
+    if (qualifier !== null && definitions.length === 0) return [];
+    const query = toFtsQuery(name2);
+    if (!query) return [];
+    let candidatePaths = this.pathsMatchingBody(name2);
+    if (qualifier !== null) {
+      const related = /* @__PURE__ */ new Set([
+        ...definitions.map((d) => d.path),
+        ...this.pathsMatchingBody(qualifier)
+      ]);
+      candidatePaths = candidatePaths.filter((p) => related.has(p));
+    }
+    const pattern = new RegExp(`\\b${escapeRegExp(name2)}\\b`);
+    const out = [];
+    for (const path of [...new Set(candidatePaths)].sort()) {
+      let lines;
+      try {
+        lines = readFileSync2(join3(this.root, path), "utf8").split("\n");
+      } catch {
+        continue;
+      }
+      lines.forEach((text, i) => {
+        const line = i + 1;
+        const insideDefinition = definitions.some(
+          (d) => d.path === path && line >= d.startLine && line <= d.endLine
+        );
+        if (!insideDefinition && pattern.test(text) && out.length < limit) {
+          out.push({ path, line, text: text.trim().slice(0, 200) });
+        }
+      });
+    }
+    return out;
+  }
+  searchText(query, limit = 8) {
+    const fts = toFtsQuery(query);
+    if (!fts) return [];
+    const rows = this.db.prepare(
+      `SELECT c.path, c.start_line, c.end_line, c.symbol,
+                snippet(chunks_fts, 0, '', '', ' \u2026 ', 16) AS snippet,
+                bm25(chunks_fts, 1.0, 1.5, 0.5) AS rank, COALESCE(k.score, 0) AS centrality
+         FROM chunks_fts JOIN chunks c ON c.id = chunks_fts.rowid
+         LEFT JOIN centrality k ON k.path = c.path
+         WHERE chunks_fts MATCH ? ORDER BY rank LIMIT ?`
+    ).all(fts, limit * 4);
+    const scored = rows.map((r) => ({ ...r, score: -r.rank * (1 + Math.min(r.centrality * 5, 0.5)) })).sort((a, b) => b.score - a.score);
+    const floor = (scored[0]?.score ?? 0) * RELATIVE_SCORE_FLOOR;
+    const seenFiles = /* @__PURE__ */ new Set();
+    const hits = [];
+    for (const row of scored) {
+      if (row.score < floor || seenFiles.has(row.path)) continue;
+      seenFiles.add(row.path);
+      hits.push({
+        path: row.path,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        symbol: row.symbol,
+        snippet: row.snippet.replace(/\s+/g, " ").trim().slice(0, 140),
+        score: row.score
+      });
+      if (hits.length >= limit) break;
+    }
+    return hits;
+  }
+  /** Paths whose characters contain the query as a subsequence, best (tightest, shortest) first. */
+  searchPaths(query, limit = 10) {
+    const needle = query.toLowerCase().replace(/\s+/g, "");
+    if (!needle) return [];
+    const paths = this.db.prepare("SELECT path FROM files").all().map(
+      (r) => r.path
+    );
+    const scored = [];
+    for (const path of paths) {
+      const hay = path.toLowerCase();
+      const base = basename2(hay);
+      if (hay.includes(needle)) {
+        scored.push({ path, score: (base.includes(needle) ? 0 : 1e3) + path.length });
+        continue;
+      }
+      let from = 0;
+      let first = -1;
+      let last = -1;
+      let ok = true;
+      for (const ch of needle) {
+        const at = hay.indexOf(ch, from);
+        if (at < 0) {
+          ok = false;
+          break;
+        }
+        if (first < 0) first = at;
+        last = at;
+        from = at + 1;
+      }
+      if (ok) scored.push({ path, score: 2e3 + (last - first) * 10 + path.length });
+    }
+    return scored.sort((a, b) => a.score - b.score || a.path.localeCompare(b.path)).slice(0, limit).map((s) => s.path);
+  }
+  importersOf(path) {
+    return this.db.prepare("SELECT src FROM edges WHERE dst = ? ORDER BY src").all(path).map((r) => r.src);
+  }
+  importsOf(path) {
+    return this.db.prepare("SELECT dst FROM edges WHERE src = ? ORDER BY dst").all(path).map((r) => r.dst);
+  }
+  /**
+   * Aider-style repository map: files by import centrality with their top-level declarations,
+   * cut at whole-file boundaries to fit `maxChars`. `focus` restricts to paths under a prefix.
+   */
+  repoMap(options) {
+    const files = this.db.prepare(
+      `SELECT f.path FROM files f LEFT JOIN centrality c ON c.path = f.path
+         WHERE f.path LIKE ? ESCAPE '\\'
+         ORDER BY COALESCE(c.score, 0) DESC, f.path`
+    ).all(`${escapeLike(options.focus ?? "")}%`);
+    const topLevel = this.db.prepare(
+      "SELECT signature FROM symbols WHERE path = ? AND parent IS NULL ORDER BY start_line LIMIT 12"
+    );
+    const blocks = [];
+    let used = 0;
+    let omitted = 0;
+    for (const { path } of files) {
+      const signatures = topLevel.all(path).map(
+        (r) => `  ${r.signature}`
+      );
+      const block = [path, ...signatures].join("\n");
+      if (used + block.length + 1 > options.maxChars - 60) {
+        omitted++;
+        continue;
+      }
+      blocks.push(block);
+      used += block.length + 1;
+    }
+    if (omitted > 0) blocks.push(`\u2026 ${omitted} more file(s); narrow with focus=<dir>`);
+    return blocks.join("\n");
+  }
+};
+
+export {
+  detectLanguage,
+  supportsSymbols,
+  extractSymbols,
+  listCandidatePaths,
+  CodeIndex
+};
+//# sourceMappingURL=chunk-2S6B3DDQ.js.map