opencode-codebase-index 0.4.1 → 0.5.0

package/dist/cli.cjs

@@ -0,0 +1,4862 @@
+#!/usr/bin/env node
+// opencode-codebase-index - Semantic codebase search for OpenCode
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "node_modules/eventemitter3/index.js"(exports2, module2) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module2) {
+      module2.exports = EventEmitter2;
+    }
+  }
+});
+
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports2, module2) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    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 = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    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 });
+      return 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}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    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).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.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._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path7, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path7);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path7, originalPath, doThrow) => {
+      if (!isString(path7)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path7) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path7)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore2 = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path7 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path7,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path7, cache, checkUnignored, slices);
+      }
+      checkIgnore(path7) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path7)) {
+          return this.test(path7);
+        }
+        const slices = path7.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path7, false, MODE_CHECK_IGNORE);
+      }
+      _t(path7, cache, checkUnignored, slices) {
+        if (path7 in cache) {
+          return cache[path7];
+        }
+        if (!slices) {
+          slices = path7.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path7] = this._rules.test(path7, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path7] = parent.ignored ? parent : this._rules.test(path7, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path7) {
+        return this._test(path7, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path7) => !this.ignores(path7);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path7) {
+        return this._test(path7, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore2(options);
+    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module2.exports = factory;
+    factory.default = factory;
+    module2.exports.isPathValid = isPathValid;
+    define(module2.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// src/cli.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_fs5 = require("fs");
+var path6 = __toESM(require("path"), 1);
+var os3 = __toESM(require("os"), 1);
+
+// src/config/constants.ts
+var DEFAULT_INCLUDE = [
+  "**/*.{ts,tsx,js,jsx,mjs,cjs}",
+  "**/*.{py,pyi}",
+  "**/*.{go,rs,java,kt,scala}",
+  "**/*.{c,cpp,cc,h,hpp}",
+  "**/*.{rb,php,swift}",
+  "**/*.{vue,svelte,astro}",
+  "**/*.{sql,graphql,proto}",
+  "**/*.{yaml,yml,toml}",
+  "**/*.{md,mdx}",
+  "**/*.{sh,bash,zsh}"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/*.min.js",
+  "**/*.bundle.js",
+  "**/vendor/**",
+  "**/__pycache__/**",
+  "**/target/**",
+  "**/coverage/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/.opencode/**"
+];
+var EMBEDDING_MODELS = {
+  "google": {
+    // `text-embedding-004` is DEPRECATED - https://ai.google.dev/gemini-api/docs/deprecations
+    "text-embedding-005": {
+      provider: "google",
+      model: "text-embedding-005",
+      dimensions: 768,
+      maxTokens: 2048,
+      costPer1MTokens: 0.025,
+      taskAble: false
+      // Note: on reality, this model allows for task-specific embeddings. See: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/embeddings/task-types
+    },
+    "gemini-embedding-001": {
+      provider: "google",
+      model: "gemini-embedding-001",
+      // Native output is 3072D, but we use Matryoshka truncation via outputDimensionality
+      // to reduce to 1536D for better storage/search efficiency with minimal quality loss.
+      // Google recommends 768, 1536, or 3072. See: https://ai.google.dev/gemini-api/docs/embeddings
+      dimensions: 1536,
+      maxTokens: 2048,
+      costPer1MTokens: 0.15,
+      taskAble: true
+    }
+  },
+  "openai": {
+    "text-embedding-3-small": {
+      provider: "openai",
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      maxTokens: 8191,
+      costPer1MTokens: 0.02
+    },
+    "text-embedding-3-large": {
+      provider: "openai",
+      model: "text-embedding-3-large",
+      dimensions: 3072,
+      maxTokens: 8191,
+      costPer1MTokens: 0.13
+    }
+  },
+  "ollama": {
+    "nomic-embed-text": {
+      provider: "ollama",
+      model: "nomic-embed-text",
+      dimensions: 768,
+      maxTokens: 8192,
+      costPer1MTokens: 0
+    },
+    "mxbai-embed-large": {
+      provider: "ollama",
+      model: "mxbai-embed-large",
+      dimensions: 1024,
+      maxTokens: 512,
+      costPer1MTokens: 0
+    }
+  },
+  "github-copilot": {
+    "text-embedding-3-small": {
+      provider: "github-copilot",
+      model: "text-embedding-3-small",
+      dimensions: 1536,
+      maxTokens: 8191,
+      costPer1MTokens: 0
+    }
+  }
+};
+var DEFAULT_PROVIDER_MODELS = {
+  "github-copilot": "text-embedding-3-small",
+  "openai": "text-embedding-3-small",
+  "google": "text-embedding-005",
+  "ollama": "nomic-embed-text"
+};
+
+// src/config/schema.ts
+function getDefaultIndexingConfig() {
+  return {
+    autoIndex: false,
+    watchFiles: true,
+    maxFileSize: 1048576,
+    maxChunksPerFile: 100,
+    semanticOnly: false,
+    retries: 3,
+    retryDelayMs: 1e3,
+    autoGc: true,
+    gcIntervalDays: 7,
+    gcOrphanThreshold: 100,
+    requireProjectMarker: true
+  };
+}
+function getDefaultSearchConfig() {
+  return {
+    maxResults: 20,
+    minScore: 0.1,
+    includeContext: true,
+    hybridWeight: 0.5,
+    contextLines: 0
+  };
+}
+function getDefaultDebugConfig() {
+  return {
+    enabled: false,
+    logLevel: "info",
+    logSearch: true,
+    logEmbedding: true,
+    logCache: true,
+    logGc: true,
+    logBranch: true,
+    metrics: true
+  };
+}
+var VALID_SCOPES = ["project", "global"];
+var VALID_LOG_LEVELS = ["error", "warn", "info", "debug"];
+function isValidProvider(value) {
+  return typeof value === "string" && Object.keys(EMBEDDING_MODELS).includes(value);
+}
+function isValidModel(value, provider) {
+  return typeof value === "string" && Object.keys(EMBEDDING_MODELS[provider]).includes(value);
+}
+function isValidScope(value) {
+  return typeof value === "string" && VALID_SCOPES.includes(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isValidLogLevel(value) {
+  return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
+}
+function parseConfig(raw) {
+  const input = raw && typeof raw === "object" ? raw : {};
+  const defaultIndexing = getDefaultIndexingConfig();
+  const defaultSearch = getDefaultSearchConfig();
+  const defaultDebug = getDefaultDebugConfig();
+  const rawIndexing = input.indexing && typeof input.indexing === "object" ? input.indexing : {};
+  const indexing = {
+    autoIndex: typeof rawIndexing.autoIndex === "boolean" ? rawIndexing.autoIndex : defaultIndexing.autoIndex,
+    watchFiles: typeof rawIndexing.watchFiles === "boolean" ? rawIndexing.watchFiles : defaultIndexing.watchFiles,
+    maxFileSize: typeof rawIndexing.maxFileSize === "number" ? rawIndexing.maxFileSize : defaultIndexing.maxFileSize,
+    maxChunksPerFile: typeof rawIndexing.maxChunksPerFile === "number" ? Math.max(1, rawIndexing.maxChunksPerFile) : defaultIndexing.maxChunksPerFile,
+    semanticOnly: typeof rawIndexing.semanticOnly === "boolean" ? rawIndexing.semanticOnly : defaultIndexing.semanticOnly,
+    retries: typeof rawIndexing.retries === "number" ? rawIndexing.retries : defaultIndexing.retries,
+    retryDelayMs: typeof rawIndexing.retryDelayMs === "number" ? rawIndexing.retryDelayMs : defaultIndexing.retryDelayMs,
+    autoGc: typeof rawIndexing.autoGc === "boolean" ? rawIndexing.autoGc : defaultIndexing.autoGc,
+    gcIntervalDays: typeof rawIndexing.gcIntervalDays === "number" ? Math.max(1, rawIndexing.gcIntervalDays) : defaultIndexing.gcIntervalDays,
+    gcOrphanThreshold: typeof rawIndexing.gcOrphanThreshold === "number" ? Math.max(0, rawIndexing.gcOrphanThreshold) : defaultIndexing.gcOrphanThreshold,
+    requireProjectMarker: typeof rawIndexing.requireProjectMarker === "boolean" ? rawIndexing.requireProjectMarker : defaultIndexing.requireProjectMarker
+  };
+  const rawSearch = input.search && typeof input.search === "object" ? input.search : {};
+  const search = {
+    maxResults: typeof rawSearch.maxResults === "number" ? rawSearch.maxResults : defaultSearch.maxResults,
+    minScore: typeof rawSearch.minScore === "number" ? rawSearch.minScore : defaultSearch.minScore,
+    includeContext: typeof rawSearch.includeContext === "boolean" ? rawSearch.includeContext : defaultSearch.includeContext,
+    hybridWeight: typeof rawSearch.hybridWeight === "number" ? Math.min(1, Math.max(0, rawSearch.hybridWeight)) : defaultSearch.hybridWeight,
+    contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines
+  };
+  const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
+  const debug = {
+    enabled: typeof rawDebug.enabled === "boolean" ? rawDebug.enabled : defaultDebug.enabled,
+    logLevel: isValidLogLevel(rawDebug.logLevel) ? rawDebug.logLevel : defaultDebug.logLevel,
+    logSearch: typeof rawDebug.logSearch === "boolean" ? rawDebug.logSearch : defaultDebug.logSearch,
+    logEmbedding: typeof rawDebug.logEmbedding === "boolean" ? rawDebug.logEmbedding : defaultDebug.logEmbedding,
+    logCache: typeof rawDebug.logCache === "boolean" ? rawDebug.logCache : defaultDebug.logCache,
+    logGc: typeof rawDebug.logGc === "boolean" ? rawDebug.logGc : defaultDebug.logGc,
+    logBranch: typeof rawDebug.logBranch === "boolean" ? rawDebug.logBranch : defaultDebug.logBranch,
+    metrics: typeof rawDebug.metrics === "boolean" ? rawDebug.metrics : defaultDebug.metrics
+  };
+  let embeddingProvider;
+  let embeddingModel = void 0;
+  if (isValidProvider(input.embeddingProvider)) {
+    embeddingProvider = input.embeddingProvider;
+    if (input.embeddingModel) {
+      embeddingModel = isValidModel(input.embeddingModel, embeddingProvider) ? input.embeddingModel : DEFAULT_PROVIDER_MODELS[embeddingProvider];
+    }
+  } else {
+    embeddingProvider = "auto";
+  }
+  return {
+    embeddingProvider,
+    embeddingModel,
+    scope: isValidScope(input.scope) ? input.scope : "project",
+    include: isStringArray(input.include) ? input.include : DEFAULT_INCLUDE,
+    exclude: isStringArray(input.exclude) ? input.exclude : DEFAULT_EXCLUDE,
+    indexing,
+    search,
+    debug
+  };
+}
+function getDefaultModelForProvider(provider) {
+  const models = EMBEDDING_MODELS[provider];
+  const providerDefault = DEFAULT_PROVIDER_MODELS[provider];
+  return models[providerDefault];
+}
+var availableProviders = Object.keys(EMBEDDING_MODELS);
+
+// src/mcp-server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod = require("zod");
+
+// src/indexer/index.ts
+var import_fs4 = require("fs");
+var path5 = __toESM(require("path"), 1);
+var import_perf_hooks = require("perf_hooks");
+
+// node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// node_modules/p-timeout/index.js
+var TimeoutError = class _TimeoutError extends Error {
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, _TimeoutError);
+  }
+};
+var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout },
+    signal
+  } = options;
+  let timer;
+  let abortHandler;
+  const wrappedPromise = new Promise((resolve4, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
+    }
+    if (signal) {
+      abortHandler = () => {
+        reject(getAbortedReason(signal));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    promise.then(resolve4, reject);
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve4(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve4();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
+    }
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// node_modules/p-queue/dist/priority-queue.js
+var PriorityQueue = class {
+  #queue = [];
+  enqueue(run, options) {
+    const { priority = 0, id } = options ?? {};
+    const element = {
+      priority,
+      id,
+      run
+    };
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
+      this.#queue.push(element);
+      return;
+    }
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((element) => element.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { priority, id });
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return item?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+};
+
+// node_modules/p-queue/dist/index.js
+var PQueue = class extends import_index.default {
+  #carryoverIntervalCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
+  #interval;
+  #intervalEnd = 0;
+  #lastExecutionTime = 0;
+  #intervalId;
+  #timeoutId;
+  #strict;
+  // Circular buffer implementation for better performance
+  #strictTicks = [];
+  #strictTicksStartIndex = 0;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  // Use to assign a unique identifier to a promise function, if not explicitly specified
+  #idAssigner = 1n;
+  // Track currently running tasks for debugging
+  #runningTasks = /* @__PURE__ */ new Map();
+  /**
+      Get or set the default timeout for all tasks. Can be changed at runtime.
+  
+      Operations will throw a `TimeoutError` if they don't complete within the specified time.
+  
+      The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+  
+      @example
+      ```
+      const queue = new PQueue({timeout: 5000});
+  
+      // Change timeout for all future tasks
+      queue.timeout = 10000;
+      ```
+      */
+  timeout;
+  constructor(options) {
+    super();
+    options = {
+      carryoverIntervalCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      strict: false,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    if (options.strict && options.interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#strict = options.strict;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    if (options.timeout !== void 0 && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
+    this.timeout = options.timeout;
+    this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
+  }
+  #cleanupStrictTicks(now) {
+    while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+      const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+      if (oldestTick !== void 0 && now - oldestTick >= this.#interval) {
+        this.#strictTicksStartIndex++;
+      } else {
+        break;
+      }
+    }
+    const shouldCompact = this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2 || this.#strictTicksStartIndex === this.#strictTicks.length;
+    if (shouldCompact) {
+      this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+      this.#strictTicksStartIndex = 0;
+    }
+  }
+  // Helper methods for interval consumption
+  #consumeIntervalSlot(now) {
+    if (this.#strict) {
+      this.#strictTicks.push(now);
+    } else {
+      this.#intervalCount++;
+    }
+  }
+  #rollbackIntervalSlot() {
+    if (this.#strict) {
+      if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+        this.#strictTicks.pop();
+      }
+    } else if (this.#intervalCount > 0) {
+      this.#intervalCount--;
+    }
+  }
+  #getActiveTicksCount() {
+    return this.#strictTicks.length - this.#strictTicksStartIndex;
+  }
+  get #doesIntervalAllowAnother() {
+    if (this.#isIntervalIgnored) {
+      return true;
+    }
+    if (this.#strict) {
+      return this.#getActiveTicksCount() < this.#intervalCap;
+    }
+    return this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#timeoutId = void 0;
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+  }
+  #isIntervalPausedAt(now) {
+    if (this.#strict) {
+      this.#cleanupStrictTicks(now);
+      const activeTicksCount = this.#getActiveTicksCount();
+      if (activeTicksCount >= this.#intervalCap) {
+        const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+        const delay = this.#interval - (now - oldestTick);
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+      return false;
+    }
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
+        }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+    }
+    return false;
+  }
+  #createIntervalTimeout(delay) {
+    if (this.#timeoutId !== void 0) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = void 0;
+    }
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
+        if (this.#strict && this.#strictTicksStartIndex > 0) {
+          const now = Date.now();
+          this.#cleanupStrictTicks(now);
+        }
+        this.emit("idle");
+      }
+      return false;
+    }
+    let taskStarted = false;
+    if (!this.#isPaused) {
+      const now = Date.now();
+      const canInitializeInterval = !this.#isIntervalPausedAt(now);
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!this.#isIntervalIgnored) {
+          this.#consumeIntervalSlot(now);
+          this.#scheduleRateLimitUpdate();
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        taskStarted = true;
+      }
+    }
+    return taskStarted;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    if (this.#strict) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (!this.#strict) {
+      if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+        this.#clearIntervalTimer();
+      }
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+    }
+    this.#processQueue();
+    this.#scheduleRateLimitUpdate();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      ...options,
+      // Assign unique ID if not provided
+      id: options.id ?? (this.#idAssigner++).toString()
+    };
+    return new Promise((resolve4, reject) => {
+      const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          // Match priority-queue default
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
+        let eventListener;
+        try {
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            this.#rollbackIntervalConsumption();
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
+          this.#lastExecutionTime = Date.now();
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
+          }
+          if (options.signal) {
+            const { signal } = options;
+            operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+              eventListener = () => {
+                reject2(signal.reason);
+              };
+              signal.addEventListener("abort", eventListener, { once: true });
+            })]);
+          }
+          const result = await operation;
+          resolve4(result);
+          this.emit("completed", result);
+        } catch (error) {
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          if (eventListener) {
+            options.signal?.removeEventListener("abort", eventListener);
+          }
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    this.#isPaused = true;
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    this.#queue = new this.#queueClass();
+    this.#clearIntervalTimer();
+    this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.#clearTimeoutTimer();
+      this.emit("idle");
+    }
+    this.emit("next");
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  /**
+      The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+  
+      @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+      */
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  /**
+      @returns A promise that rejects when any task in the queue errors.
+  
+      Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+  
+      Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+  
+      @example
+      ```
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      queue.add(() => fetchData(1)).catch(() => {});
+      queue.add(() => fetchData(2)).catch(() => {});
+      queue.add(() => fetchData(3)).catch(() => {});
+  
+      // Stop processing on first error
+      try {
+          await Promise.race([
+              queue.onError(),
+              queue.onIdle()
+          ]);
+      } catch (error) {
+          queue.pause(); // Stop processing remaining tasks
+          console.error('Queue failed:', error);
+      }
+      ```
+      */
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = (error) => {
+        this.off("error", handleError);
+        reject(error);
+      };
+      this.on("error", handleError);
+    });
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve4) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve4();
+      };
+      this.on(event, listener);
+    });
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return this.#queue.size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return this.#isPaused;
+  }
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
+  }
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
+    }
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
+  }
+  #rollbackIntervalConsumption() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.#rollbackIntervalSlot();
+    this.#scheduleRateLimitUpdate();
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    if (this.#isIntervalIgnored || this.#queue.size === 0) {
+      if (previous) {
+        this.#rateLimitedInInterval = false;
+        this.emit("rateLimitCleared");
+      }
+      return;
+    }
+    let count;
+    if (this.#strict) {
+      const now = Date.now();
+      this.#cleanupStrictTicks(now);
+      count = this.#getActiveTicksCount();
+    } else {
+      count = this.#intervalCount;
+    }
+    const shouldBeRateLimited = count >= this.#intervalCap;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
+  }
+  /**
+      Whether the queue is saturated. Returns `true` when:
+      - All concurrency slots are occupied and tasks are waiting, OR
+      - The queue is rate-limited and tasks are waiting
+  
+      Useful for detecting backpressure and potential hanging tasks.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Backpressure handling
+      if (queue.isSaturated) {
+          console.log('Queue is saturated, waiting for capacity...');
+          await queue.onSizeLessThan(queue.concurrency);
+      }
+  
+      // Monitoring for stuck tasks
+      setInterval(() => {
+          if (queue.isSaturated) {
+              console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+          }
+      }, 60000);
+      ```
+      */
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  /**
+      The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+  
+      Returns an array of task info objects.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Add tasks with IDs for better debugging
+      queue.add(() => fetchUser(123), {id: 'user-123'});
+      queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+  
+      // Check what's running
+      console.log(queue.runningTasks);
+      // => [{
+      //   id: 'user-123',
+      //   priority: 0,
+      //   startTime: 1759253001716,
+      //   timeout: undefined
+      // }, {
+      //   id: 'posts-456',
+      //   priority: 1,
+      //   startTime: 1759253001916,
+      //   timeout: undefined
+      // }]
+      ```
+      */
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
+};
+
+// node_modules/is-network-error/index.js
+var objectToString = Object.prototype.toString;
+var isError = (value) => objectToString.call(value) === "[object Error]";
+var errorMessages = /* @__PURE__ */ new Set([
+  "network error",
+  // Chrome
+  "Failed to fetch",
+  // Chrome
+  "NetworkError when attempting to fetch resource.",
+  // Firefox
+  "The Internet connection appears to be offline.",
+  // Safari 16
+  "Network request failed",
+  // `cross-fetch`
+  "fetch failed",
+  // Undici (Node.js)
+  "terminated",
+  // Undici (Node.js)
+  " A network error occurred.",
+  // Bun (WebKit)
+  "Network connection lost"
+  // Cloudflare Workers (fetch)
+]);
+function isNetworkError(error) {
+  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid) {
+    return false;
+  }
+  const { message, stack } = error;
+  if (message === "Load failed") {
+    return stack === void 0 || "__sentry_captured__" in error;
+  }
+  if (message.startsWith("error sending request for url")) {
+    return true;
+  }
+  return errorMessages.has(message);
+}
+
+// node_modules/p-retry/index.js
+function validateRetries(retries) {
+  if (typeof retries === "number") {
+    if (retries < 0) {
+      throw new TypeError("Expected `retries` to be a non-negative number.");
+    }
+    if (Number.isNaN(retries)) {
+      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+    }
+  } else if (retries !== void 0) {
+    throw new TypeError("Expected `retries` to be a number or Infinity.");
+  }
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  }
+  if (!allowInfinity && !Number.isFinite(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  }
+  if (value < min) {
+    throw new TypeError(`Expected \`${name}\` to be \u2265 ${min}.`);
+  }
+}
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+function calculateDelay(retriesConsumed, options) {
+  const attempt = Math.max(1, retriesConsumed + 1);
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+  timeout = Math.min(timeout, options.maxTimeout);
+  return timeout;
+}
+function calculateRemainingTime(start, max) {
+  if (!Number.isFinite(max)) {
+    return max;
+  }
+  return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
+  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError) {
+    throw normalizedError.originalError;
+  }
+  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+  const context = Object.freeze({
+    error: normalizedError,
+    attemptNumber,
+    retriesLeft,
+    retriesConsumed
+  });
+  await options.onFailedAttempt(context);
+  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+    throw normalizedError;
+  }
+  const consumeRetry = await options.shouldConsumeRetry(context);
+  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+  if (remainingTime <= 0 || retriesLeft <= 0) {
+    throw normalizedError;
+  }
+  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
+    if (consumeRetry) {
+      throw normalizedError;
+    }
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  if (!await options.shouldRetry(context)) {
+    throw normalizedError;
+  }
+  if (!consumeRetry) {
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  const delayTime = calculateDelay(retriesConsumed, options);
+  const finalDelay = Math.min(delayTime, remainingTime);
+  options.signal?.throwIfAborted();
+  if (finalDelay > 0) {
+    await new Promise((resolve4, reject) => {
+      const onAbort = () => {
+        clearTimeout(timeoutToken);
+        options.signal?.removeEventListener("abort", onAbort);
+        reject(options.signal.reason);
+      };
+      const timeoutToken = setTimeout(() => {
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve4();
+      }, finalDelay);
+      if (options.unref) {
+        timeoutToken.unref?.();
+      }
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  options.signal?.throwIfAborted();
+  return true;
+}
+async function pRetry(input, options = {}) {
+  options = { ...options };
+  validateRetries(options.retries);
+  if (Object.hasOwn(options, "forever")) {
+    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  }
+  options.retries ??= 10;
+  options.factor ??= 2;
+  options.minTimeout ??= 1e3;
+  options.maxTimeout ??= Number.POSITIVE_INFINITY;
+  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+  options.randomize ??= false;
+  options.onFailedAttempt ??= () => {
+  };
+  options.shouldRetry ??= () => true;
+  options.shouldConsumeRetry ??= () => true;
+  validateNumberOption("factor", options.factor, { min: 0, allowInfinity: false });
+  validateNumberOption("minTimeout", options.minTimeout, { min: 0, allowInfinity: false });
+  validateNumberOption("maxTimeout", options.maxTimeout, { min: 0, allowInfinity: true });
+  validateNumberOption("maxRetryTime", options.maxRetryTime, { min: 0, allowInfinity: true });
+  if (!(options.factor > 0)) {
+    options.factor = 1;
+  }
+  options.signal?.throwIfAborted();
+  let attemptNumber = 0;
+  let retriesConsumed = 0;
+  const startTime = performance.now();
+  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+    attemptNumber++;
+    try {
+      options.signal?.throwIfAborted();
+      const result = await input(attemptNumber);
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      if (await onAttemptFailure({
+        error,
+        attemptNumber,
+        retriesConsumed,
+        startTime,
+        options
+      })) {
+        retriesConsumed++;
+      }
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
+}
+
+// src/embeddings/detector.ts
+var import_fs = require("fs");
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function getOpenCodeAuthPath() {
+  return path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
+}
+function loadOpenCodeAuth() {
+  const authPath = getOpenCodeAuthPath();
+  try {
+    if ((0, import_fs.existsSync)(authPath)) {
+      return JSON.parse((0, import_fs.readFileSync)(authPath, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+async function detectEmbeddingProvider(preferredProvider, model) {
+  const credentials = await getProviderCredentials(preferredProvider);
+  if (credentials) {
+    if (!model) {
+      return {
+        provider: preferredProvider,
+        credentials,
+        modelInfo: getDefaultModelForProvider(preferredProvider)
+      };
+    }
+    if (!isValidModel(model, preferredProvider)) {
+      throw new Error(
+        `Model '${model}' is not supported by provider '${preferredProvider}'`
+      );
+    }
+    const providerModels = EMBEDDING_MODELS[preferredProvider];
+    return {
+      provider: preferredProvider,
+      credentials,
+      modelInfo: providerModels[model]
+    };
+  }
+  throw new Error(
+    `Preferred provider '${preferredProvider}' is not configured or authenticated`
+  );
+}
+async function tryDetectProvider() {
+  for (const provider of availableProviders) {
+    const credentials = await getProviderCredentials(provider);
+    if (credentials) {
+      return {
+        provider,
+        credentials,
+        modelInfo: getDefaultModelForProvider(provider)
+      };
+    }
+  }
+  throw new Error(
+    `No embedding-capable provider found. Please authenticate with OpenCode using one of: ${availableProviders.join(", ")}.`
+  );
+}
+async function getProviderCredentials(provider) {
+  switch (provider) {
+    case "github-copilot":
+      return getGitHubCopilotCredentials();
+    case "openai":
+      return getOpenAICredentials();
+    case "google":
+      return getGoogleCredentials();
+    case "ollama":
+      return getOllamaCredentials();
+    default:
+      return null;
+  }
+}
+function getGitHubCopilotCredentials() {
+  const authData = loadOpenCodeAuth();
+  const copilotAuth = authData["github-copilot"] || authData["github-copilot-enterprise"];
+  if (!copilotAuth || copilotAuth.type !== "oauth") {
+    return null;
+  }
+  const baseUrl = copilotAuth.enterpriseUrl ? `https://copilot-api.${copilotAuth.enterpriseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}` : "https://models.github.ai";
+  return {
+    provider: "github-copilot",
+    baseUrl,
+    refreshToken: copilotAuth.refresh,
+    accessToken: copilotAuth.access,
+    tokenExpires: copilotAuth.expires
+  };
+}
+function getOpenAICredentials() {
+  const authData = loadOpenCodeAuth();
+  const openaiAuth = authData["openai"];
+  if (openaiAuth?.type === "api") {
+    return {
+      provider: "openai",
+      apiKey: openaiAuth.key,
+      baseUrl: "https://api.openai.com/v1"
+    };
+  }
+  return null;
+}
+function getGoogleCredentials() {
+  const authData = loadOpenCodeAuth();
+  const googleAuth = authData["google"] || authData["google-generative-ai"];
+  if (googleAuth?.type === "api") {
+    return {
+      provider: "google",
+      apiKey: googleAuth.key,
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta"
+    };
+  }
+  return null;
+}
+async function getOllamaCredentials() {
+  const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2e3);
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      const hasEmbeddingModel = data.models?.some(
+        (m) => m.name.includes("nomic-embed") || m.name.includes("mxbai-embed") || m.name.includes("all-minilm")
+      );
+      if (hasEmbeddingModel) {
+        return {
+          provider: "ollama",
+          baseUrl
+        };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function getProviderDisplayName(provider) {
+  switch (provider) {
+    case "github-copilot":
+      return "GitHub Copilot";
+    case "openai":
+      return "OpenAI";
+    case "google":
+      return "Google (Gemini)";
+    case "ollama":
+      return "Ollama (Local)";
+    default:
+      return provider;
+  }
+}
+
+// src/embeddings/provider.ts
+function createEmbeddingProvider(configuredProviderInfo) {
+  switch (configuredProviderInfo.provider) {
+    case "github-copilot":
+      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "openai":
+      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "google":
+      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "ollama":
+      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    default: {
+      const _exhaustive = configuredProviderInfo;
+      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
+    }
+  }
+}
+var GitHubCopilotEmbeddingProvider = class {
+  constructor(credentials, modelInfo) {
+    this.credentials = credentials;
+    this.modelInfo = modelInfo;
+  }
+  getToken() {
+    if (!this.credentials.refreshToken) {
+      throw new Error("No OAuth token available for GitHub");
+    }
+    return this.credentials.refreshToken;
+  }
+  async embedQuery(query) {
+    const result = await this.embedBatch([query]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedDocument(document) {
+    const result = await this.embedBatch([document]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedBatch(texts) {
+    const token = this.getToken();
+    const response = await fetch(`${this.credentials.baseUrl}/inference/embeddings`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      },
+      body: JSON.stringify({
+        model: `openai/${this.modelInfo.model}`,
+        input: texts
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`GitHub Copilot embedding API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      embeddings: data.data.map((d) => d.embedding),
+      totalTokensUsed: data.usage.total_tokens
+    };
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
+var OpenAIEmbeddingProvider = class {
+  constructor(credentials, modelInfo) {
+    this.credentials = credentials;
+    this.modelInfo = modelInfo;
+  }
+  async embedQuery(query) {
+    const result = await this.embedBatch([query]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedDocument(document) {
+    const result = await this.embedBatch([document]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedBatch(texts) {
+    const response = await fetch(`${this.credentials.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.credentials.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.modelInfo.model,
+        input: texts
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI embedding API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      embeddings: data.data.map((d) => d.embedding),
+      totalTokensUsed: data.usage.total_tokens
+    };
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
+var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
+  constructor(credentials, modelInfo) {
+    this.credentials = credentials;
+    this.modelInfo = modelInfo;
+  }
+  static BATCH_SIZE = 20;
+  async embedQuery(query) {
+    const taskType = this.modelInfo.taskAble ? "CODE_RETRIEVAL_QUERY" : void 0;
+    const result = await this.embedWithTaskType([query], taskType);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedDocument(document) {
+    const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
+    const result = await this.embedWithTaskType([document], taskType);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedBatch(texts) {
+    const taskType = this.modelInfo.taskAble ? "RETRIEVAL_DOCUMENT" : void 0;
+    return this.embedWithTaskType(texts, taskType);
+  }
+  /**
+   * Embeds texts using the Google embedContent API.
+   * Sends multiple texts as parts in batched requests (up to BATCH_SIZE per call).
+   * When taskType is provided (gemini-embedding-001), includes it in the request
+   * for task-specific embedding optimization.
+   */
+  async embedWithTaskType(texts, taskType) {
+    const batches = [];
+    for (let i = 0; i < texts.length; i += _GoogleEmbeddingProvider.BATCH_SIZE) {
+      batches.push(texts.slice(i, i + _GoogleEmbeddingProvider.BATCH_SIZE));
+    }
+    const batchResults = await Promise.all(
+      batches.map(async (batch) => {
+        const requests = batch.map((text) => ({
+          model: `models/${this.modelInfo.model}`,
+          content: {
+            parts: [{ text }]
+          },
+          taskType,
+          outputDimensionality: this.modelInfo.dimensions
+        }));
+        const response = await fetch(
+          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents?key=${this.credentials.apiKey}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ requests })
+          }
+        );
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Google embedding API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+          embeddings: data.embeddings.map((e) => e.values),
+          tokensUsed: batch.reduce((sum, text) => sum + Math.ceil(text.length / 4), 0)
+        };
+      })
+    );
+    return {
+      embeddings: batchResults.flatMap((r) => r.embeddings),
+      totalTokensUsed: batchResults.reduce((sum, r) => sum + r.tokensUsed, 0)
+    };
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
+var OllamaEmbeddingProvider = class {
+  constructor(credentials, modelInfo) {
+    this.credentials = credentials;
+    this.modelInfo = modelInfo;
+  }
+  async embedQuery(query) {
+    const result = await this.embedBatch([query]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedDocument(document) {
+    const result = await this.embedBatch([document]);
+    return {
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
+    };
+  }
+  async embedBatch(texts) {
+    const results = await Promise.all(
+      texts.map(async (text) => {
+        const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: this.modelInfo.model,
+            prompt: text
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+          embedding: data.embedding,
+          tokensUsed: Math.ceil(text.length / 4)
+        };
+      })
+    );
+    return {
+      embeddings: results.map((r) => r.embedding),
+      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
+    };
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
+
+// src/utils/files.ts
+var import_ignore = __toESM(require_ignore(), 1);
+var import_fs2 = require("fs");
+var path2 = __toESM(require("path"), 1);
+function createIgnoreFilter(projectRoot) {
+  const ig = (0, import_ignore.default)();
+  const defaultIgnores = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "coverage",
+    "__pycache__",
+    "target",
+    "vendor",
+    ".opencode"
+  ];
+  ig.add(defaultIgnores);
+  const gitignorePath = path2.join(projectRoot, ".gitignore");
+  if ((0, import_fs2.existsSync)(gitignorePath)) {
+    const gitignoreContent = (0, import_fs2.readFileSync)(gitignorePath, "utf-8");
+    ig.add(gitignoreContent);
+  }
+  return ig;
+}
+function matchGlob(filePath, pattern) {
+  let regexPattern = pattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<DOUBLESTAR>>>/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, p1) => `(${p1.split(",").join("|")})`);
+  if (regexPattern.startsWith(".*/")) {
+    regexPattern = `(.*\\/)?${regexPattern.slice(3)}`;
+  }
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filePath);
+}
+async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns, ignoreFilter, maxFileSize, skipped) {
+  const entries = await import_fs2.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    const relativePath = path2.relative(projectRoot, fullPath);
+    if (ignoreFilter.ignores(relativePath)) {
+      if (entry.isFile()) {
+        skipped.push({ path: relativePath, reason: "gitignore" });
+      }
+      continue;
+    }
+    if (entry.isDirectory()) {
+      yield* walkDirectory(
+        fullPath,
+        projectRoot,
+        includePatterns,
+        excludePatterns,
+        ignoreFilter,
+        maxFileSize,
+        skipped
+      );
+    } else if (entry.isFile()) {
+      const stat = await import_fs2.promises.stat(fullPath);
+      if (stat.size > maxFileSize) {
+        skipped.push({ path: relativePath, reason: "too_large" });
+        continue;
+      }
+      for (const pattern of excludePatterns) {
+        if (matchGlob(relativePath, pattern)) {
+          skipped.push({ path: relativePath, reason: "excluded" });
+          continue;
+        }
+      }
+      let matched = false;
+      for (const pattern of includePatterns) {
+        if (matchGlob(relativePath, pattern)) {
+          matched = true;
+          break;
+        }
+      }
+      if (matched) {
+        yield { path: fullPath, size: stat.size };
+      }
+    }
+  }
+}
+async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFileSize) {
+  const ignoreFilter = createIgnoreFilter(projectRoot);
+  const files = [];
+  const skipped = [];
+  for await (const file of walkDirectory(
+    projectRoot,
+    projectRoot,
+    includePatterns,
+    excludePatterns,
+    ignoreFilter,
+    maxFileSize,
+    skipped
+  )) {
+    files.push(file);
+  }
+  return { files, skipped };
+}
+
+// src/utils/cost.ts
+function estimateChunksFromFiles(files) {
+  let totalChunks = 0;
+  for (const file of files) {
+    const avgChunkSize = 400;
+    const chunksPerFile = Math.max(1, Math.ceil(file.size / avgChunkSize));
+    totalChunks += chunksPerFile;
+  }
+  return totalChunks;
+}
+function estimateCost(estimatedTokens, modelInfo) {
+  return estimatedTokens / 1e6 * modelInfo.costPer1MTokens;
+}
+function createCostEstimate(files, provider) {
+  const filesCount = files.length;
+  const totalSizeBytes = files.reduce((sum, f) => sum + f.size, 0);
+  const estimatedChunks = estimateChunksFromFiles(files);
+  const avgTokensPerChunk = 150;
+  const estimatedTokens = estimatedChunks * avgTokensPerChunk;
+  const estimatedCost = estimateCost(estimatedTokens, provider.modelInfo);
+  return {
+    filesCount,
+    totalSizeBytes,
+    estimatedChunks,
+    estimatedTokens,
+    estimatedCost,
+    provider: getProviderDisplayName(provider.provider),
+    model: provider.modelInfo.model,
+    isFree: provider.modelInfo.costPer1MTokens === 0
+  };
+}
+function formatCostEstimate(estimate) {
+  const sizeFormatted = formatBytes(estimate.totalSizeBytes);
+  const costFormatted = estimate.isFree ? "Free" : `~$${estimate.estimatedCost.toFixed(4)}`;
+  return `
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  \u{1F4CA} Indexing Estimate                                           \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502                                                                 \u2502
+\u2502  Files to index:     ${padRight(estimate.filesCount.toLocaleString() + " files", 40)}\u2502
+\u2502  Total size:         ${padRight(sizeFormatted, 40)}\u2502
+\u2502  Estimated chunks:   ${padRight("~" + estimate.estimatedChunks.toLocaleString() + " chunks", 40)}\u2502
+\u2502  Estimated tokens:   ${padRight("~" + estimate.estimatedTokens.toLocaleString() + " tokens", 40)}\u2502
+\u2502                                                                 \u2502
+\u2502  Provider: ${padRight(estimate.provider, 52)}\u2502
+\u2502  Model:    ${padRight(estimate.model, 52)}\u2502
+\u2502  Cost:     ${padRight(costFormatted, 52)}\u2502
+\u2502                                                                 \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function padRight(str, length) {
+  return str.padEnd(length);
+}
+
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+function createEmptyMetrics() {
+  return {
+    filesScanned: 0,
+    filesParsed: 0,
+    parseMs: 0,
+    chunksProcessed: 0,
+    chunksEmbedded: 0,
+    chunksFromCache: 0,
+    chunksRemoved: 0,
+    embeddingApiCalls: 0,
+    embeddingTokensUsed: 0,
+    embeddingErrors: 0,
+    searchCount: 0,
+    searchTotalMs: 0,
+    searchAvgMs: 0,
+    searchLastMs: 0,
+    embeddingCallMs: 0,
+    vectorSearchMs: 0,
+    keywordSearchMs: 0,
+    fusionMs: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    queryCacheHits: 0,
+    queryCacheSimilarHits: 0,
+    queryCacheMisses: 0,
+    gcRuns: 0,
+    gcOrphansRemoved: 0,
+    gcChunksRemoved: 0,
+    gcEmbeddingsRemoved: 0
+  };
+}
+var Logger = class {
+  config;
+  metrics;
+  logs = [];
+  maxLogs = 1e3;
+  constructor(config) {
+    this.config = config;
+    this.metrics = createEmptyMetrics();
+  }
+  shouldLog(level) {
+    if (!this.config.enabled) return false;
+    return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[this.config.logLevel];
+  }
+  log(level, category, message, data) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      category,
+      message,
+      data
+    };
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs.shift();
+    }
+  }
+  search(level, message, data) {
+    if (this.config.logSearch) {
+      this.log(level, "search", message, data);
+    }
+  }
+  embedding(level, message, data) {
+    if (this.config.logEmbedding) {
+      this.log(level, "embedding", message, data);
+    }
+  }
+  cache(level, message, data) {
+    if (this.config.logCache) {
+      this.log(level, "cache", message, data);
+    }
+  }
+  gc(level, message, data) {
+    if (this.config.logGc) {
+      this.log(level, "gc", message, data);
+    }
+  }
+  branch(level, message, data) {
+    if (this.config.logBranch) {
+      this.log(level, "branch", message, data);
+    }
+  }
+  info(message, data) {
+    this.log("info", "general", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", "general", message, data);
+  }
+  error(message, data) {
+    this.log("error", "general", message, data);
+  }
+  debug(message, data) {
+    this.log("debug", "general", message, data);
+  }
+  recordIndexingStart() {
+    if (!this.config.metrics) return;
+    this.metrics.indexingStartTime = Date.now();
+  }
+  recordIndexingEnd() {
+    if (!this.config.metrics) return;
+    this.metrics.indexingEndTime = Date.now();
+  }
+  recordFilesScanned(count) {
+    if (!this.config.metrics) return;
+    this.metrics.filesScanned = count;
+  }
+  recordFilesParsed(count) {
+    if (!this.config.metrics) return;
+    this.metrics.filesParsed = count;
+  }
+  recordParseDuration(durationMs) {
+    if (!this.config.metrics) return;
+    this.metrics.parseMs = durationMs;
+  }
+  recordChunksProcessed(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksProcessed += count;
+  }
+  recordChunksEmbedded(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksEmbedded += count;
+  }
+  recordChunksFromCache(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksFromCache += count;
+  }
+  recordChunksRemoved(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksRemoved += count;
+  }
+  recordEmbeddingApiCall(tokens) {
+    if (!this.config.metrics) return;
+    this.metrics.embeddingApiCalls++;
+    this.metrics.embeddingTokensUsed += tokens;
+  }
+  recordEmbeddingError() {
+    if (!this.config.metrics) return;
+    this.metrics.embeddingErrors++;
+  }
+  recordSearch(durationMs, breakdown) {
+    if (!this.config.metrics) return;
+    this.metrics.searchCount++;
+    this.metrics.searchTotalMs += durationMs;
+    this.metrics.searchLastMs = durationMs;
+    this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
+    if (breakdown) {
+      this.metrics.embeddingCallMs = breakdown.embeddingMs;
+      this.metrics.vectorSearchMs = breakdown.vectorMs;
+      this.metrics.keywordSearchMs = breakdown.keywordMs;
+      this.metrics.fusionMs = breakdown.fusionMs;
+    }
+  }
+  recordCacheHit() {
+    if (!this.config.metrics) return;
+    this.metrics.cacheHits++;
+  }
+  recordCacheMiss() {
+    if (!this.config.metrics) return;
+    this.metrics.cacheMisses++;
+  }
+  recordQueryCacheHit() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheHits++;
+  }
+  recordQueryCacheSimilarHit() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheSimilarHits++;
+  }
+  recordQueryCacheMiss() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheMisses++;
+  }
+  recordGc(orphans, chunks, embeddings) {
+    if (!this.config.metrics) return;
+    this.metrics.gcRuns++;
+    this.metrics.gcOrphansRemoved += orphans;
+    this.metrics.gcChunksRemoved += chunks;
+    this.metrics.gcEmbeddingsRemoved += embeddings;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  getLogs(limit) {
+    const logs = [...this.logs];
+    if (limit) {
+      return logs.slice(-limit);
+    }
+    return logs;
+  }
+  getLogsByCategory(category, limit) {
+    const filtered = this.logs.filter((l) => l.category === category);
+    if (limit) {
+      return filtered.slice(-limit);
+    }
+    return filtered;
+  }
+  getLogsByLevel(level, limit) {
+    const filtered = this.logs.filter((l) => l.level === level);
+    if (limit) {
+      return filtered.slice(-limit);
+    }
+    return filtered;
+  }
+  resetMetrics() {
+    this.metrics = createEmptyMetrics();
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+  formatMetrics() {
+    const m = this.metrics;
+    const lines = [];
+    lines.push("=== Metrics ===");
+    if (m.indexingStartTime && m.indexingEndTime) {
+      const duration = m.indexingEndTime - m.indexingStartTime;
+      lines.push(`Indexing duration: ${(duration / 1e3).toFixed(2)}s`);
+    }
+    lines.push("");
+    lines.push("Indexing:");
+    lines.push(`  Files scanned: ${m.filesScanned}`);
+    lines.push(`  Files parsed: ${m.filesParsed}`);
+    lines.push(`  Chunks processed: ${m.chunksProcessed}`);
+    lines.push(`  Chunks embedded: ${m.chunksEmbedded}`);
+    lines.push(`  Chunks from cache: ${m.chunksFromCache}`);
+    lines.push(`  Chunks removed: ${m.chunksRemoved}`);
+    lines.push("");
+    lines.push("Embedding API:");
+    lines.push(`  API calls: ${m.embeddingApiCalls}`);
+    lines.push(`  Tokens used: ${m.embeddingTokensUsed.toLocaleString()}`);
+    lines.push(`  Errors: ${m.embeddingErrors}`);
+    if (m.searchCount > 0) {
+      lines.push("");
+      lines.push("Search:");
+      lines.push(`  Total searches: ${m.searchCount}`);
+      lines.push(`  Average time: ${m.searchAvgMs.toFixed(2)}ms`);
+      lines.push(`  Last search: ${m.searchLastMs.toFixed(2)}ms`);
+      if (m.embeddingCallMs > 0) {
+        lines.push(`    - Embedding: ${m.embeddingCallMs.toFixed(2)}ms`);
+        lines.push(`    - Vector search: ${m.vectorSearchMs.toFixed(2)}ms`);
+        lines.push(`    - Keyword search: ${m.keywordSearchMs.toFixed(2)}ms`);
+        lines.push(`    - Fusion: ${m.fusionMs.toFixed(2)}ms`);
+      }
+    }
+    const totalCacheOps = m.cacheHits + m.cacheMisses;
+    if (totalCacheOps > 0) {
+      lines.push("");
+      lines.push("Cache:");
+      lines.push(`  Hits: ${m.cacheHits}`);
+      lines.push(`  Misses: ${m.cacheMisses}`);
+      lines.push(`  Hit rate: ${(m.cacheHits / totalCacheOps * 100).toFixed(1)}%`);
+    }
+    if (m.gcRuns > 0) {
+      lines.push("");
+      lines.push("Garbage Collection:");
+      lines.push(`  GC runs: ${m.gcRuns}`);
+      lines.push(`  Orphans removed: ${m.gcOrphansRemoved}`);
+      lines.push(`  Chunks removed: ${m.gcChunksRemoved}`);
+      lines.push(`  Embeddings removed: ${m.gcEmbeddingsRemoved}`);
+    }
+    return lines.join("\n");
+  }
+  formatRecentLogs(limit = 20) {
+    const logs = this.getLogs(limit);
+    if (logs.length === 0) {
+      return "No logs recorded.";
+    }
+    return logs.map((l) => {
+      const dataStr = l.data ? ` ${JSON.stringify(l.data)}` : "";
+      return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
+    }).join("\n");
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  isMetricsEnabled() {
+    return this.config.enabled && this.config.metrics;
+  }
+};
+var globalLogger = null;
+function initializeLogger(config) {
+  globalLogger = new Logger(config);
+  return globalLogger;
+}
+
+// src/native/index.ts
+var path3 = __toESM(require("path"), 1);
+var os2 = __toESM(require("os"), 1);
+var import_url = require("url");
+var import_meta = {};
+function getNativeBinding() {
+  const platform2 = os2.platform();
+  const arch2 = os2.arch();
+  let bindingName;
+  if (platform2 === "darwin" && arch2 === "arm64") {
+    bindingName = "codebase-index-native.darwin-arm64.node";
+  } else if (platform2 === "darwin" && arch2 === "x64") {
+    bindingName = "codebase-index-native.darwin-x64.node";
+  } else if (platform2 === "linux" && arch2 === "x64") {
+    bindingName = "codebase-index-native.linux-x64-gnu.node";
+  } else if (platform2 === "linux" && arch2 === "arm64") {
+    bindingName = "codebase-index-native.linux-arm64-gnu.node";
+  } else if (platform2 === "win32" && arch2 === "x64") {
+    bindingName = "codebase-index-native.win32-x64-msvc.node";
+  } else {
+    throw new Error(`Unsupported platform: ${platform2}-${arch2}`);
+  }
+  let currentDir;
+  if (typeof import_meta !== "undefined" && import_meta.url) {
+    currentDir = path3.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  } else if (typeof __dirname !== "undefined") {
+    currentDir = __dirname;
+  } else {
+    currentDir = process.cwd();
+  }
+  const isDevMode = currentDir.includes("/src/native");
+  const packageRoot = isDevMode ? path3.resolve(currentDir, "../..") : path3.resolve(currentDir, "..");
+  const nativePath = path3.join(packageRoot, "native", bindingName);
+  return require(nativePath);
+}
+var native = getNativeBinding();
+function parseFiles(files) {
+  const result = native.parseFiles(files);
+  return result.map((f) => ({
+    path: f.path,
+    chunks: f.chunks.map(mapChunk),
+    hash: f.hash
+  }));
+}
+function mapChunk(c) {
+  return {
+    content: c.content,
+    startLine: c.startLine ?? c.start_line,
+    endLine: c.endLine ?? c.end_line,
+    chunkType: c.chunkType ?? c.chunk_type,
+    name: c.name ?? void 0,
+    language: c.language
+  };
+}
+function hashContent(content) {
+  return native.hashContent(content);
+}
+function hashFile(filePath) {
+  return native.hashFile(filePath);
+}
+var VectorStore = class {
+  inner;
+  dimensions;
+  constructor(indexPath, dimensions) {
+    this.inner = new native.VectorStore(indexPath, dimensions);
+    this.dimensions = dimensions;
+  }
+  add(id, vector, metadata) {
+    if (vector.length !== this.dimensions) {
+      throw new Error(
+        `Vector dimension mismatch: expected ${this.dimensions}, got ${vector.length}`
+      );
+    }
+    this.inner.add(id, vector, JSON.stringify(metadata));
+  }
+  addBatch(items) {
+    const ids = items.map((i) => i.id);
+    const vectors = items.map((i) => {
+      if (i.vector.length !== this.dimensions) {
+        throw new Error(
+          `Vector dimension mismatch for ${i.id}: expected ${this.dimensions}, got ${i.vector.length}`
+        );
+      }
+      return i.vector;
+    });
+    const metadata = items.map((i) => JSON.stringify(i.metadata));
+    this.inner.addBatch(ids, vectors, metadata);
+  }
+  search(queryVector, limit = 10) {
+    if (queryVector.length !== this.dimensions) {
+      throw new Error(
+        `Query vector dimension mismatch: expected ${this.dimensions}, got ${queryVector.length}`
+      );
+    }
+    const results = this.inner.search(queryVector, limit);
+    return results.map((r) => ({
+      id: r.id,
+      score: r.score,
+      metadata: JSON.parse(r.metadata)
+    }));
+  }
+  remove(id) {
+    return this.inner.remove(id);
+  }
+  save() {
+    this.inner.save();
+  }
+  load() {
+    this.inner.load();
+  }
+  count() {
+    return this.inner.count();
+  }
+  clear() {
+    this.inner.clear();
+  }
+  getDimensions() {
+    return this.dimensions;
+  }
+  getAllKeys() {
+    return this.inner.getAllKeys();
+  }
+  getAllMetadata() {
+    const results = this.inner.getAllMetadata();
+    return results.map((r) => ({
+      key: r.key,
+      metadata: JSON.parse(r.metadata)
+    }));
+  }
+  getMetadata(id) {
+    const result = this.inner.getMetadata(id);
+    if (result === null || result === void 0) {
+      return void 0;
+    }
+    return JSON.parse(result);
+  }
+  getMetadataBatch(ids) {
+    const results = this.inner.getMetadataBatch(ids);
+    const map = /* @__PURE__ */ new Map();
+    for (const { key, metadata } of results) {
+      map.set(key, JSON.parse(metadata));
+    }
+    return map;
+  }
+};
+var CHARS_PER_TOKEN = 4;
+var MAX_BATCH_TOKENS = 7500;
+var MAX_SINGLE_CHUNK_TOKENS = 2e3;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function createEmbeddingText(chunk, filePath) {
+  const parts = [];
+  const fileName = filePath.split("/").pop() || filePath;
+  const dirPath = filePath.split("/").slice(-3, -1).join("/");
+  const langDescriptors = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    python: "Python",
+    rust: "Rust",
+    go: "Go",
+    java: "Java"
+  };
+  const typeDescriptors = {
+    function_declaration: "function",
+    function: "function",
+    arrow_function: "arrow function",
+    method_definition: "method",
+    class_declaration: "class",
+    interface_declaration: "interface",
+    type_alias_declaration: "type alias",
+    enum_declaration: "enum",
+    export_statement: "export",
+    lexical_declaration: "variable declaration",
+    function_definition: "function",
+    class_definition: "class",
+    function_item: "function",
+    impl_item: "implementation",
+    struct_item: "struct",
+    enum_item: "enum",
+    trait_item: "trait"
+  };
+  const lang = langDescriptors[chunk.language] || chunk.language;
+  const typeDesc = typeDescriptors[chunk.chunkType] || chunk.chunkType;
+  if (chunk.name) {
+    parts.push(`${lang} ${typeDesc} "${chunk.name}"`);
+  } else {
+    parts.push(`${lang} ${typeDesc}`);
+  }
+  if (dirPath) {
+    parts.push(`in ${dirPath}/${fileName}`);
+  } else {
+    parts.push(`in ${fileName}`);
+  }
+  const semanticHints = extractSemanticHints(chunk.name || "", chunk.content);
+  if (semanticHints.length > 0) {
+    parts.push(`Purpose: ${semanticHints.join(", ")}`);
+  }
+  parts.push("");
+  let content = chunk.content;
+  const headerLength = parts.join("\n").length;
+  const maxContentChars = MAX_SINGLE_CHUNK_TOKENS * CHARS_PER_TOKEN - headerLength;
+  if (content.length > maxContentChars) {
+    content = content.slice(0, maxContentChars) + "\n... [truncated]";
+  }
+  parts.push(content);
+  return parts.join("\n");
+}
+function createDynamicBatches(chunks) {
+  const batches = [];
+  let currentBatch = [];
+  let currentTokens = 0;
+  for (const chunk of chunks) {
+    const chunkTokens = estimateTokens(chunk.text);
+    if (currentBatch.length > 0 && currentTokens + chunkTokens > MAX_BATCH_TOKENS) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentTokens = 0;
+    }
+    currentBatch.push(chunk);
+    currentTokens += chunkTokens;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+function extractSemanticHints(name, content) {
+  const hints = [];
+  const combined = `${name} ${content}`.toLowerCase();
+  const signature = extractFunctionSignature(content);
+  if (signature) {
+    hints.push(signature);
+  }
+  const patterns = [
+    [/auth|login|logout|signin|signout|credential/i, "authentication"],
+    [/password|hash|bcrypt|argon/i, "password handling"],
+    [/token|jwt|bearer|oauth/i, "token management"],
+    [/user|account|profile|member/i, "user management"],
+    [/permission|role|access|authorize/i, "authorization"],
+    [/validate|verify|check|assert/i, "validation"],
+    [/error|exception|throw|catch/i, "error handling"],
+    [/log|debug|trace|info|warn/i, "logging"],
+    [/cache|memoize|store/i, "caching"],
+    [/fetch|request|response|api|http/i, "HTTP/API"],
+    [/database|db|query|sql|mongo/i, "database"],
+    [/file|read|write|stream|path/i, "file operations"],
+    [/parse|serialize|json|xml/i, "data parsing"],
+    [/encrypt|decrypt|crypto|secret|cipher|cryptographic/i, "encryption/cryptography"],
+    [/test|spec|mock|stub|expect/i, "testing"],
+    [/config|setting|option|env/i, "configuration"],
+    [/route|endpoint|handler|controller|middleware/i, "routing/middleware"],
+    [/render|component|view|template/i, "UI rendering"],
+    [/state|redux|store|dispatch/i, "state management"],
+    [/hook|effect|memo|callback/i, "React hooks"]
+  ];
+  for (const [pattern, hint] of patterns) {
+    if (pattern.test(combined) && !hints.includes(hint)) {
+      hints.push(hint);
+    }
+  }
+  return hints.slice(0, 6);
+}
+function extractFunctionSignature(content) {
+  const tsJsPatterns = [
+    /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)\s*(?::\s*([^{]+))?/,
+    /(?:export\s+)?const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*([^=>{]+))?\s*=>/,
+    /(?:export\s+)?const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?function\s*\(([^)]*)\)/
+  ];
+  const pyPatterns = [
+    /def\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^:]+))?:/,
+    /async\s+def\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^:]+))?:/
+  ];
+  const goPatterns = [
+    /func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(([^)]*)\)\s*(?:\(([^)]+)\)|([^{\n]+))?/
+  ];
+  const rustPatterns = [
+    /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*(?:<[^>]+>)?\s*\(([^)]*)\)\s*(?:->\s*([^{]+))?/
+  ];
+  for (const pattern of [...tsJsPatterns, ...pyPatterns, ...goPatterns, ...rustPatterns]) {
+    const match = content.match(pattern);
+    if (match) {
+      const funcName = match[1];
+      const params = match[2]?.trim() || "";
+      const returnType = (match[3] || match[4])?.trim();
+      const paramNames = extractParamNames(params);
+      let sig = `${funcName}(${paramNames.join(", ")})`;
+      if (returnType && returnType.length < 50) {
+        sig += ` -> ${returnType.replace(/\s+/g, " ").trim()}`;
+      }
+      if (sig.length < 100) {
+        return sig;
+      }
+    }
+  }
+  return null;
+}
+function extractParamNames(params) {
+  if (!params.trim()) return [];
+  const names = [];
+  const parts = params.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const tsMatch = trimmed.match(/^(\w+)\s*[?:]?/);
+    const pyMatch = trimmed.match(/^(\w+)\s*(?::|=)/);
+    const goMatch = trimmed.match(/^(\w+)\s+\w/);
+    const rustMatch = trimmed.match(/^(\w+)\s*:/);
+    const match = tsMatch || pyMatch || goMatch || rustMatch;
+    if (match && match[1] !== "self" && match[1] !== "this") {
+      names.push(match[1]);
+    }
+  }
+  return names.slice(0, 5);
+}
+function generateChunkId(filePath, chunk) {
+  const hash = hashContent(`${filePath}:${chunk.startLine}:${chunk.endLine}:${chunk.content}`);
+  return `chunk_${hash.slice(0, 16)}`;
+}
+function generateChunkHash(chunk) {
+  return hashContent(chunk.content);
+}
+var InvertedIndex = class {
+  inner;
+  constructor(indexPath) {
+    this.inner = new native.InvertedIndex(indexPath);
+  }
+  load() {
+    this.inner.load();
+  }
+  save() {
+    this.inner.save();
+  }
+  addChunk(chunkId, content) {
+    this.inner.addChunk(chunkId, content);
+  }
+  removeChunk(chunkId) {
+    return this.inner.removeChunk(chunkId);
+  }
+  search(query, limit) {
+    const results = this.inner.search(query, limit ?? 100);
+    const map = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      map.set(r.chunkId, r.score);
+    }
+    return map;
+  }
+  hasChunk(chunkId) {
+    return this.inner.hasChunk(chunkId);
+  }
+  clear() {
+    this.inner.clear();
+  }
+  getDocumentCount() {
+    return this.inner.documentCount();
+  }
+};
+var Database = class {
+  inner;
+  constructor(dbPath) {
+    this.inner = new native.Database(dbPath);
+  }
+  embeddingExists(contentHash) {
+    return this.inner.embeddingExists(contentHash);
+  }
+  getEmbedding(contentHash) {
+    return this.inner.getEmbedding(contentHash) ?? null;
+  }
+  upsertEmbedding(contentHash, embedding, chunkText, model) {
+    this.inner.upsertEmbedding(contentHash, embedding, chunkText, model);
+  }
+  upsertEmbeddingsBatch(items) {
+    if (items.length === 0) return;
+    this.inner.upsertEmbeddingsBatch(items);
+  }
+  getMissingEmbeddings(contentHashes) {
+    return this.inner.getMissingEmbeddings(contentHashes);
+  }
+  upsertChunk(chunk) {
+    this.inner.upsertChunk(chunk);
+  }
+  upsertChunksBatch(chunks) {
+    if (chunks.length === 0) return;
+    this.inner.upsertChunksBatch(chunks);
+  }
+  getChunk(chunkId) {
+    return this.inner.getChunk(chunkId) ?? null;
+  }
+  getChunksByFile(filePath) {
+    return this.inner.getChunksByFile(filePath);
+  }
+  deleteChunksByFile(filePath) {
+    return this.inner.deleteChunksByFile(filePath);
+  }
+  addChunksToBranch(branch, chunkIds) {
+    this.inner.addChunksToBranch(branch, chunkIds);
+  }
+  addChunksToBranchBatch(branch, chunkIds) {
+    if (chunkIds.length === 0) return;
+    this.inner.addChunksToBranchBatch(branch, chunkIds);
+  }
+  clearBranch(branch) {
+    return this.inner.clearBranch(branch);
+  }
+  getBranchChunkIds(branch) {
+    return this.inner.getBranchChunkIds(branch);
+  }
+  getBranchDelta(branch, baseBranch) {
+    return this.inner.getBranchDelta(branch, baseBranch);
+  }
+  chunkExistsOnBranch(branch, chunkId) {
+    return this.inner.chunkExistsOnBranch(branch, chunkId);
+  }
+  getAllBranches() {
+    return this.inner.getAllBranches();
+  }
+  getMetadata(key) {
+    return this.inner.getMetadata(key) ?? null;
+  }
+  setMetadata(key, value) {
+    this.inner.setMetadata(key, value);
+  }
+  deleteMetadata(key) {
+    return this.inner.deleteMetadata(key);
+  }
+  gcOrphanEmbeddings() {
+    return this.inner.gcOrphanEmbeddings();
+  }
+  gcOrphanChunks() {
+    return this.inner.gcOrphanChunks();
+  }
+  getStats() {
+    return this.inner.getStats();
+  }
+};
+
+// src/git/index.ts
+var import_fs3 = require("fs");
+var path4 = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+function resolveGitDir(repoRoot) {
+  const gitPath = path4.join(repoRoot, ".git");
+  if (!(0, import_fs3.existsSync)(gitPath)) {
+    return null;
+  }
+  try {
+    const stat = (0, import_fs3.statSync)(gitPath);
+    if (stat.isDirectory()) {
+      return gitPath;
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs3.readFileSync)(gitPath, "utf-8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1];
+        const resolvedPath = path4.isAbsolute(gitdir) ? gitdir : path4.resolve(repoRoot, gitdir);
+        if ((0, import_fs3.existsSync)(resolvedPath)) {
+          return resolvedPath;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isGitRepo(dir) {
+  return resolveGitDir(dir) !== null;
+}
+function getCurrentBranch(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (!gitDir) {
+    return null;
+  }
+  const headPath = path4.join(gitDir, "HEAD");
+  if (!(0, import_fs3.existsSync)(headPath)) {
+    return null;
+  }
+  try {
+    const headContent = (0, import_fs3.readFileSync)(headPath, "utf-8").trim();
+    const match = headContent.match(/^ref: refs\/heads\/(.+)$/);
+    if (match) {
+      return match[1];
+    }
+    if (/^[0-9a-f]{40}$/i.test(headContent)) {
+      return headContent.slice(0, 7);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getBaseBranch(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  const candidates = ["main", "master", "develop", "trunk"];
+  if (gitDir) {
+    for (const candidate of candidates) {
+      const refPath = path4.join(gitDir, "refs", "heads", candidate);
+      if ((0, import_fs3.existsSync)(refPath)) {
+        return candidate;
+      }
+      const packedRefsPath = path4.join(gitDir, "packed-refs");
+      if ((0, import_fs3.existsSync)(packedRefsPath)) {
+        try {
+          const content = (0, import_fs3.readFileSync)(packedRefsPath, "utf-8");
+          if (content.includes(`refs/heads/${candidate}`)) {
+            return candidate;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    const result = (0, import_child_process.execSync)("git remote show origin", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = result.match(/HEAD branch: (.+)/);
+    if (match) {
+      return match[1].trim();
+    }
+  } catch {
+  }
+  return getCurrentBranch(repoRoot) ?? "main";
+}
+function getBranchOrDefault(repoRoot) {
+  if (!isGitRepo(repoRoot)) {
+    return "default";
+  }
+  return getCurrentBranch(repoRoot) ?? "default";
+}
+
+// src/indexer/index.ts
+function float32ArrayToBuffer(arr) {
+  const float32 = new Float32Array(arr);
+  return Buffer.from(float32.buffer);
+}
+function bufferToFloat32Array(buf) {
+  return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return String(error);
+}
+function isRateLimitError(error) {
+  const message = getErrorMessage(error);
+  return message.includes("429") || message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("too many requests");
+}
+var INDEX_METADATA_VERSION = "1";
+var Indexer = class {
+  config;
+  projectRoot;
+  indexPath;
+  store = null;
+  invertedIndex = null;
+  database = null;
+  provider = null;
+  configuredProviderInfo = null;
+  fileHashCache = /* @__PURE__ */ new Map();
+  fileHashCachePath = "";
+  failedBatchesPath = "";
+  currentBranch = "default";
+  baseBranch = "main";
+  logger;
+  queryEmbeddingCache = /* @__PURE__ */ new Map();
+  maxQueryCacheSize = 100;
+  queryCacheTtlMs = 5 * 60 * 1e3;
+  querySimilarityThreshold = 0.85;
+  indexCompatibility = null;
+  indexingLockPath = "";
+  constructor(projectRoot, config) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.indexPath = this.getIndexPath();
+    this.fileHashCachePath = path5.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path5.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path5.join(this.indexPath, "indexing.lock");
+    this.logger = initializeLogger(config.debug);
+  }
+  getIndexPath() {
+    if (this.config.scope === "global") {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+      return path5.join(homeDir, ".opencode", "global-index");
+    }
+    return path5.join(this.projectRoot, ".opencode", "index");
+  }
+  loadFileHashCache() {
+    try {
+      if ((0, import_fs4.existsSync)(this.fileHashCachePath)) {
+        const data = (0, import_fs4.readFileSync)(this.fileHashCachePath, "utf-8");
+        const parsed = JSON.parse(data);
+        this.fileHashCache = new Map(Object.entries(parsed));
+      }
+    } catch {
+      this.fileHashCache = /* @__PURE__ */ new Map();
+    }
+  }
+  saveFileHashCache() {
+    const obj = {};
+    for (const [k, v] of this.fileHashCache) {
+      obj[k] = v;
+    }
+    this.atomicWriteSync(this.fileHashCachePath, JSON.stringify(obj));
+  }
+  atomicWriteSync(targetPath, data) {
+    const tempPath = `${targetPath}.tmp`;
+    (0, import_fs4.writeFileSync)(tempPath, data);
+    (0, import_fs4.renameSync)(tempPath, targetPath);
+  }
+  checkForInterruptedIndexing() {
+    return (0, import_fs4.existsSync)(this.indexingLockPath);
+  }
+  acquireIndexingLock() {
+    const lockData = {
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid
+    };
+    (0, import_fs4.writeFileSync)(this.indexingLockPath, JSON.stringify(lockData));
+  }
+  releaseIndexingLock() {
+    if ((0, import_fs4.existsSync)(this.indexingLockPath)) {
+      (0, import_fs4.unlinkSync)(this.indexingLockPath);
+    }
+  }
+  async recoverFromInterruptedIndexing() {
+    this.logger.warn("Detected interrupted indexing session, recovering...");
+    if ((0, import_fs4.existsSync)(this.fileHashCachePath)) {
+      (0, import_fs4.unlinkSync)(this.fileHashCachePath);
+    }
+    await this.healthCheck();
+    this.releaseIndexingLock();
+    this.logger.info("Recovery complete, next index will re-process all files");
+  }
+  loadFailedBatches() {
+    try {
+      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
+        const data = (0, import_fs4.readFileSync)(this.failedBatchesPath, "utf-8");
+        return JSON.parse(data);
+      }
+    } catch {
+      return [];
+    }
+    return [];
+  }
+  saveFailedBatches(batches) {
+    if (batches.length === 0) {
+      if ((0, import_fs4.existsSync)(this.failedBatchesPath)) {
+        import_fs4.promises.unlink(this.failedBatchesPath).catch(() => {
+        });
+      }
+      return;
+    }
+    (0, import_fs4.writeFileSync)(this.failedBatchesPath, JSON.stringify(batches, null, 2));
+  }
+  addFailedBatch(batch, error) {
+    const existing = this.loadFailedBatches();
+    existing.push({
+      chunks: batch,
+      error,
+      attemptCount: 1,
+      lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.saveFailedBatches(existing);
+  }
+  getProviderRateLimits(provider) {
+    switch (provider) {
+      case "github-copilot":
+        return { concurrency: 1, intervalMs: 4e3, minRetryMs: 5e3, maxRetryMs: 6e4 };
+      case "openai":
+        return { concurrency: 3, intervalMs: 500, minRetryMs: 1e3, maxRetryMs: 3e4 };
+      case "google":
+        return { concurrency: 5, intervalMs: 200, minRetryMs: 1e3, maxRetryMs: 3e4 };
+      case "ollama":
+        return { concurrency: 5, intervalMs: 0, minRetryMs: 500, maxRetryMs: 5e3 };
+      default:
+        return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
+    }
+  }
+  async initialize() {
+    if (this.config.embeddingProvider === "auto") {
+      this.configuredProviderInfo = await tryDetectProvider();
+    } else {
+      this.configuredProviderInfo = await detectEmbeddingProvider(this.config.embeddingProvider, this.config.embeddingModel);
+    }
+    if (!this.configuredProviderInfo) {
+      throw new Error(
+        "No embedding provider available. Configure GitHub, OpenAI, Google, or Ollama."
+      );
+    }
+    this.logger.info("Initializing indexer", {
+      provider: this.configuredProviderInfo.provider,
+      model: this.configuredProviderInfo.modelInfo.model,
+      scope: this.config.scope
+    });
+    this.provider = createEmbeddingProvider(this.configuredProviderInfo);
+    await import_fs4.promises.mkdir(this.indexPath, { recursive: true });
+    if (this.checkForInterruptedIndexing()) {
+      await this.recoverFromInterruptedIndexing();
+    }
+    const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
+    const storePath = path5.join(this.indexPath, "vectors");
+    this.store = new VectorStore(storePath, dimensions);
+    const indexFilePath = path5.join(this.indexPath, "vectors.usearch");
+    if ((0, import_fs4.existsSync)(indexFilePath)) {
+      this.store.load();
+    }
+    const invertedIndexPath = path5.join(this.indexPath, "inverted-index.json");
+    this.invertedIndex = new InvertedIndex(invertedIndexPath);
+    try {
+      this.invertedIndex.load();
+    } catch {
+      if ((0, import_fs4.existsSync)(invertedIndexPath)) {
+        await import_fs4.promises.unlink(invertedIndexPath);
+      }
+      this.invertedIndex = new InvertedIndex(invertedIndexPath);
+    }
+    const dbPath = path5.join(this.indexPath, "codebase.db");
+    const dbIsNew = !(0, import_fs4.existsSync)(dbPath);
+    this.database = new Database(dbPath);
+    if (dbIsNew && this.store.count() > 0) {
+      this.migrateFromLegacyIndex();
+    }
+    this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+    if (!this.indexCompatibility.compatible) {
+      this.logger.warn("Index compatibility issue detected", {
+        reason: this.indexCompatibility.reason,
+        storedMetadata: this.indexCompatibility.storedMetadata,
+        configuredProviderInfo: this.configuredProviderInfo
+      });
+    }
+    if (isGitRepo(this.projectRoot)) {
+      this.currentBranch = getBranchOrDefault(this.projectRoot);
+      this.baseBranch = getBaseBranch(this.projectRoot);
+      this.logger.branch("info", "Detected git repository", {
+        currentBranch: this.currentBranch,
+        baseBranch: this.baseBranch
+      });
+    } else {
+      this.currentBranch = "default";
+      this.baseBranch = "default";
+      this.logger.branch("debug", "Not a git repository, using default branch");
+    }
+    if (this.config.indexing.autoGc) {
+      await this.maybeRunAutoGc();
+    }
+  }
+  async maybeRunAutoGc() {
+    if (!this.database) return;
+    const lastGcTimestamp = this.database.getMetadata("lastGcTimestamp");
+    const now = Date.now();
+    const intervalMs = this.config.indexing.gcIntervalDays * 24 * 60 * 60 * 1e3;
+    let shouldRunGc = false;
+    if (!lastGcTimestamp) {
+      shouldRunGc = true;
+    } else {
+      const lastGcTime = parseInt(lastGcTimestamp, 10);
+      if (!isNaN(lastGcTime) && now - lastGcTime > intervalMs) {
+        shouldRunGc = true;
+      }
+    }
+    if (shouldRunGc) {
+      await this.healthCheck();
+      this.database.setMetadata("lastGcTimestamp", now.toString());
+    }
+  }
+  async maybeRunOrphanGc() {
+    if (!this.database) return;
+    const stats = this.database.getStats();
+    if (!stats) return;
+    const orphanCount = stats.embeddingCount - stats.chunkCount;
+    if (orphanCount > this.config.indexing.gcOrphanThreshold) {
+      this.database.gcOrphanEmbeddings();
+      this.database.gcOrphanChunks();
+      this.database.setMetadata("lastGcTimestamp", Date.now().toString());
+    }
+  }
+  migrateFromLegacyIndex() {
+    if (!this.store || !this.database) return;
+    const allMetadata = this.store.getAllMetadata();
+    const chunkIds = [];
+    const chunkDataBatch = [];
+    for (const { key, metadata } of allMetadata) {
+      const chunkData = {
+        chunkId: key,
+        contentHash: metadata.hash,
+        filePath: metadata.filePath,
+        startLine: metadata.startLine,
+        endLine: metadata.endLine,
+        nodeType: metadata.chunkType,
+        name: metadata.name,
+        language: metadata.language
+      };
+      chunkDataBatch.push(chunkData);
+      chunkIds.push(key);
+    }
+    if (chunkDataBatch.length > 0) {
+      this.database.upsertChunksBatch(chunkDataBatch);
+    }
+    this.database.addChunksToBranchBatch(this.currentBranch || "default", chunkIds);
+  }
+  loadIndexMetadata() {
+    if (!this.database) return null;
+    const version = this.database.getMetadata("index.version");
+    if (!version) return null;
+    return {
+      indexVersion: version,
+      embeddingProvider: this.database.getMetadata("index.embeddingProvider") ?? "",
+      embeddingModel: this.database.getMetadata("index.embeddingModel") ?? "",
+      embeddingDimensions: parseInt(this.database.getMetadata("index.embeddingDimensions") ?? "0", 10),
+      createdAt: this.database.getMetadata("index.createdAt") ?? "",
+      updatedAt: this.database.getMetadata("index.updatedAt") ?? ""
+    };
+  }
+  saveIndexMetadata(provider) {
+    if (!this.database) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existingCreatedAt = this.database.getMetadata("index.createdAt");
+    this.database.setMetadata("index.version", INDEX_METADATA_VERSION);
+    this.database.setMetadata("index.embeddingProvider", provider.provider);
+    this.database.setMetadata("index.embeddingModel", provider.modelInfo.model);
+    this.database.setMetadata("index.embeddingDimensions", provider.modelInfo.dimensions.toString());
+    this.database.setMetadata("index.updatedAt", now);
+    if (!existingCreatedAt) {
+      this.database.setMetadata("index.createdAt", now);
+    }
+  }
+  validateIndexCompatibility(provider) {
+    const storedMetadata = this.loadIndexMetadata();
+    if (!storedMetadata) {
+      return { compatible: true };
+    }
+    const currentProvider = provider.provider;
+    const currentModel = provider.modelInfo.model;
+    const currentDimensions = provider.modelInfo.dimensions;
+    if (storedMetadata.embeddingDimensions !== currentDimensions) {
+      return {
+        compatible: false,
+        code: "DIMENSION_MISMATCH" /* DIMENSION_MISMATCH */,
+        reason: `Dimension mismatch: index has ${storedMetadata.embeddingDimensions}D vectors (${storedMetadata.embeddingProvider}/${storedMetadata.embeddingModel}), but current provider uses ${currentDimensions}D (${currentProvider}/${currentModel}). Run index_codebase with force=true to rebuild.`,
+        storedMetadata
+      };
+    }
+    if (storedMetadata.embeddingModel !== currentModel) {
+      return {
+        compatible: false,
+        code: "MODEL_MISMATCH" /* MODEL_MISMATCH */,
+        reason: `Model mismatch: index was built with "${storedMetadata.embeddingModel}", but current model is "${currentModel}". Embeddings are incompatible. Run index_codebase with force=true to rebuild.`,
+        storedMetadata
+      };
+    }
+    if (storedMetadata.embeddingProvider !== currentProvider) {
+      this.logger.warn("Provider changed", {
+        storedProvider: storedMetadata.embeddingProvider,
+        currentProvider
+      });
+    }
+    return {
+      compatible: true,
+      storedMetadata
+    };
+  }
+  checkCompatibility() {
+    if (!this.indexCompatibility) {
+      if (!this.configuredProviderInfo) {
+        throw new Error("No embedding provider info, you must initialize the indexer first.");
+      }
+      this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+    }
+    return this.indexCompatibility;
+  }
+  async ensureInitialized() {
+    if (!this.store || !this.provider || !this.invertedIndex || !this.configuredProviderInfo || !this.database) {
+      await this.initialize();
+    }
+    return {
+      store: this.store,
+      provider: this.provider,
+      invertedIndex: this.invertedIndex,
+      configuredProviderInfo: this.configuredProviderInfo,
+      database: this.database
+    };
+  }
+  async estimateCost() {
+    const { configuredProviderInfo } = await this.ensureInitialized();
+    const { files } = await collectFiles(
+      this.projectRoot,
+      this.config.include,
+      this.config.exclude,
+      this.config.indexing.maxFileSize
+    );
+    return createCostEstimate(files, configuredProviderInfo);
+  }
+  async index(onProgress) {
+    const { store, provider, invertedIndex, database, configuredProviderInfo } = await this.ensureInitialized();
+    if (!this.indexCompatibility?.compatible) {
+      throw new Error(
+        `${this.indexCompatibility?.reason} Run index_codebase with force=true to rebuild the index.`
+      );
+    }
+    this.acquireIndexingLock();
+    this.logger.recordIndexingStart();
+    this.logger.info("Starting indexing", { projectRoot: this.projectRoot });
+    const startTime = Date.now();
+    const stats = {
+      totalFiles: 0,
+      totalChunks: 0,
+      indexedChunks: 0,
+      failedChunks: 0,
+      tokensUsed: 0,
+      durationMs: 0,
+      existingChunks: 0,
+      removedChunks: 0,
+      skippedFiles: [],
+      parseFailures: []
+    };
+    onProgress?.({
+      phase: "scanning",
+      filesProcessed: 0,
+      totalFiles: 0,
+      chunksProcessed: 0,
+      totalChunks: 0
+    });
+    this.loadFileHashCache();
+    const { files, skipped } = await collectFiles(
+      this.projectRoot,
+      this.config.include,
+      this.config.exclude,
+      this.config.indexing.maxFileSize
+    );
+    stats.totalFiles = files.length;
+    stats.skippedFiles = skipped;
+    this.logger.recordFilesScanned(files.length);
+    this.logger.cache("debug", "Scanning files for changes", {
+      totalFiles: files.length,
+      skippedFiles: skipped.length
+    });
+    const changedFiles = [];
+    const unchangedFilePaths = /* @__PURE__ */ new Set();
+    const currentFileHashes = /* @__PURE__ */ new Map();
+    for (const f of files) {
+      const currentHash = hashFile(f.path);
+      currentFileHashes.set(f.path, currentHash);
+      if (this.fileHashCache.get(f.path) === currentHash) {
+        unchangedFilePaths.add(f.path);
+        this.logger.recordCacheHit();
+      } else {
+        const content = await import_fs4.promises.readFile(f.path, "utf-8");
+        changedFiles.push({ path: f.path, content, hash: currentHash });
+        this.logger.recordCacheMiss();
+      }
+    }
+    this.logger.cache("info", "File hash cache results", {
+      unchanged: unchangedFilePaths.size,
+      changed: changedFiles.length
+    });
+    onProgress?.({
+      phase: "parsing",
+      filesProcessed: 0,
+      totalFiles: files.length,
+      chunksProcessed: 0,
+      totalChunks: 0
+    });
+    const parseStartTime = import_perf_hooks.performance.now();
+    const parsedFiles = parseFiles(changedFiles);
+    const parseMs = import_perf_hooks.performance.now() - parseStartTime;
+    this.logger.recordFilesParsed(parsedFiles.length);
+    this.logger.recordParseDuration(parseMs);
+    this.logger.debug("Parsed changed files", { parsedCount: parsedFiles.length, parseMs: parseMs.toFixed(2) });
+    const existingChunks = /* @__PURE__ */ new Map();
+    const existingChunksByFile = /* @__PURE__ */ new Map();
+    for (const { key, metadata } of store.getAllMetadata()) {
+      existingChunks.set(key, metadata.hash);
+      const fileChunks = existingChunksByFile.get(metadata.filePath) || /* @__PURE__ */ new Set();
+      fileChunks.add(key);
+      existingChunksByFile.set(metadata.filePath, fileChunks);
+    }
+    const currentChunkIds = /* @__PURE__ */ new Set();
+    const currentFilePaths = /* @__PURE__ */ new Set();
+    const pendingChunks = [];
+    for (const filePath of unchangedFilePaths) {
+      currentFilePaths.add(filePath);
+      const fileChunks = existingChunksByFile.get(filePath);
+      if (fileChunks) {
+        for (const chunkId of fileChunks) {
+          currentChunkIds.add(chunkId);
+        }
+      }
+    }
+    const chunkDataBatch = [];
+    for (const parsed of parsedFiles) {
+      currentFilePaths.add(parsed.path);
+      if (parsed.chunks.length === 0) {
+        const relativePath = path5.relative(this.projectRoot, parsed.path);
+        stats.parseFailures.push(relativePath);
+      }
+      let fileChunkCount = 0;
+      for (const chunk of parsed.chunks) {
+        if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
+          break;
+        }
+        if (this.config.indexing.semanticOnly && chunk.chunkType === "other") {
+          continue;
+        }
+        const id = generateChunkId(parsed.path, chunk);
+        const contentHash = generateChunkHash(chunk);
+        currentChunkIds.add(id);
+        chunkDataBatch.push({
+          chunkId: id,
+          contentHash,
+          filePath: parsed.path,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          nodeType: chunk.chunkType,
+          name: chunk.name,
+          language: chunk.language
+        });
+        if (existingChunks.get(id) === contentHash) {
+          fileChunkCount++;
+          continue;
+        }
+        const text = createEmbeddingText(chunk, parsed.path);
+        const metadata = {
+          filePath: parsed.path,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          chunkType: chunk.chunkType,
+          name: chunk.name,
+          language: chunk.language,
+          hash: contentHash
+        };
+        pendingChunks.push({ id, text, content: chunk.content, contentHash, metadata });
+        fileChunkCount++;
+      }
+    }
+    if (chunkDataBatch.length > 0) {
+      database.upsertChunksBatch(chunkDataBatch);
+    }
+    let removedCount = 0;
+    for (const [chunkId] of existingChunks) {
+      if (!currentChunkIds.has(chunkId)) {
+        store.remove(chunkId);
+        invertedIndex.removeChunk(chunkId);
+        removedCount++;
+      }
+    }
+    stats.totalChunks = pendingChunks.length;
+    stats.existingChunks = currentChunkIds.size - pendingChunks.length;
+    stats.removedChunks = removedCount;
+    this.logger.recordChunksProcessed(currentChunkIds.size);
+    this.logger.recordChunksRemoved(removedCount);
+    this.logger.info("Chunk analysis complete", {
+      pending: pendingChunks.length,
+      existing: stats.existingChunks,
+      removed: removedCount
+    });
+    if (pendingChunks.length === 0 && removedCount === 0) {
+      database.clearBranch(this.currentBranch);
+      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+      this.fileHashCache = currentFileHashes;
+      this.saveFileHashCache();
+      stats.durationMs = Date.now() - startTime;
+      onProgress?.({
+        phase: "complete",
+        filesProcessed: files.length,
+        totalFiles: files.length,
+        chunksProcessed: 0,
+        totalChunks: 0
+      });
+      this.releaseIndexingLock();
+      return stats;
+    }
+    if (pendingChunks.length === 0) {
+      database.clearBranch(this.currentBranch);
+      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+      store.save();
+      invertedIndex.save();
+      this.fileHashCache = currentFileHashes;
+      this.saveFileHashCache();
+      stats.durationMs = Date.now() - startTime;
+      onProgress?.({
+        phase: "complete",
+        filesProcessed: files.length,
+        totalFiles: files.length,
+        chunksProcessed: 0,
+        totalChunks: 0
+      });
+      this.releaseIndexingLock();
+      return stats;
+    }
+    onProgress?.({
+      phase: "embedding",
+      filesProcessed: files.length,
+      totalFiles: files.length,
+      chunksProcessed: 0,
+      totalChunks: pendingChunks.length
+    });
+    const allContentHashes = pendingChunks.map((c) => c.contentHash);
+    const missingHashes = new Set(database.getMissingEmbeddings(allContentHashes));
+    const chunksNeedingEmbedding = pendingChunks.filter((c) => missingHashes.has(c.contentHash));
+    const chunksWithExistingEmbedding = pendingChunks.filter((c) => !missingHashes.has(c.contentHash));
+    this.logger.cache("info", "Embedding cache lookup", {
+      needsEmbedding: chunksNeedingEmbedding.length,
+      fromCache: chunksWithExistingEmbedding.length
+    });
+    this.logger.recordChunksFromCache(chunksWithExistingEmbedding.length);
+    for (const chunk of chunksWithExistingEmbedding) {
+      const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+      if (embeddingBuffer) {
+        const vector = bufferToFloat32Array(embeddingBuffer);
+        store.add(chunk.id, Array.from(vector), chunk.metadata);
+        invertedIndex.removeChunk(chunk.id);
+        invertedIndex.addChunk(chunk.id, chunk.content);
+        stats.indexedChunks++;
+      }
+    }
+    const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
+    const queue = new PQueue({
+      concurrency: providerRateLimits.concurrency,
+      interval: providerRateLimits.intervalMs,
+      intervalCap: providerRateLimits.concurrency
+    });
+    const dynamicBatches = createDynamicBatches(chunksNeedingEmbedding);
+    let rateLimitBackoffMs = 0;
+    for (const batch of dynamicBatches) {
+      queue.add(async () => {
+        if (rateLimitBackoffMs > 0) {
+          await new Promise((resolve4) => setTimeout(resolve4, rateLimitBackoffMs));
+        }
+        try {
+          const result = await pRetry(
+            async () => {
+              const texts = batch.map((c) => c.text);
+              return provider.embedBatch(texts);
+            },
+            {
+              retries: this.config.indexing.retries,
+              minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
+              maxTimeout: providerRateLimits.maxRetryMs,
+              factor: 2,
+              onFailedAttempt: (error) => {
+                const message = getErrorMessage(error);
+                if (isRateLimitError(error)) {
+                  rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
+                  this.logger.embedding("warn", `Rate limited, backing off`, {
+                    attempt: error.attemptNumber,
+                    retriesLeft: error.retriesLeft,
+                    backoffMs: rateLimitBackoffMs
+                  });
+                } else {
+                  this.logger.embedding("error", `Embedding batch failed`, {
+                    attempt: error.attemptNumber,
+                    error: message
+                  });
+                }
+              }
+            }
+          );
+          if (rateLimitBackoffMs > 0) {
+            rateLimitBackoffMs = Math.max(0, rateLimitBackoffMs - 2e3);
+          }
+          const items = batch.map((chunk, idx) => ({
+            id: chunk.id,
+            vector: result.embeddings[idx],
+            metadata: chunk.metadata
+          }));
+          store.addBatch(items);
+          const embeddingBatchItems = batch.map((chunk, i) => ({
+            contentHash: chunk.contentHash,
+            embedding: float32ArrayToBuffer(result.embeddings[i]),
+            chunkText: chunk.text,
+            model: configuredProviderInfo.modelInfo.model
+          }));
+          database.upsertEmbeddingsBatch(embeddingBatchItems);
+          for (const chunk of batch) {
+            invertedIndex.removeChunk(chunk.id);
+            invertedIndex.addChunk(chunk.id, chunk.content);
+          }
+          stats.indexedChunks += batch.length;
+          stats.tokensUsed += result.totalTokensUsed;
+          this.logger.recordChunksEmbedded(batch.length);
+          this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
+          this.logger.embedding("debug", `Embedded batch`, {
+            batchSize: batch.length,
+            tokens: result.totalTokensUsed
+          });
+          onProgress?.({
+            phase: "embedding",
+            filesProcessed: files.length,
+            totalFiles: files.length,
+            chunksProcessed: stats.indexedChunks,
+            totalChunks: pendingChunks.length
+          });
+        } catch (error) {
+          stats.failedChunks += batch.length;
+          this.addFailedBatch(batch, getErrorMessage(error));
+          this.logger.recordEmbeddingError();
+          this.logger.embedding("error", `Failed to embed batch after retries`, {
+            batchSize: batch.length,
+            error: getErrorMessage(error)
+          });
+        }
+      });
+    }
+    await queue.onIdle();
+    onProgress?.({
+      phase: "storing",
+      filesProcessed: files.length,
+      totalFiles: files.length,
+      chunksProcessed: stats.indexedChunks,
+      totalChunks: pendingChunks.length
+    });
+    database.clearBranch(this.currentBranch);
+    database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
+    store.save();
+    invertedIndex.save();
+    this.fileHashCache = currentFileHashes;
+    this.saveFileHashCache();
+    if (this.config.indexing.autoGc && stats.removedChunks > 0) {
+      await this.maybeRunOrphanGc();
+    }
+    stats.durationMs = Date.now() - startTime;
+    this.saveIndexMetadata(configuredProviderInfo);
+    this.indexCompatibility = { compatible: true };
+    this.logger.recordIndexingEnd();
+    this.logger.info("Indexing complete", {
+      files: stats.totalFiles,
+      indexed: stats.indexedChunks,
+      existing: stats.existingChunks,
+      removed: stats.removedChunks,
+      failed: stats.failedChunks,
+      tokens: stats.tokensUsed,
+      durationMs: stats.durationMs
+    });
+    if (stats.failedChunks > 0) {
+      stats.failedBatchesPath = this.failedBatchesPath;
+    }
+    onProgress?.({
+      phase: "complete",
+      filesProcessed: files.length,
+      totalFiles: files.length,
+      chunksProcessed: stats.indexedChunks,
+      totalChunks: pendingChunks.length
+    });
+    this.releaseIndexingLock();
+    return stats;
+  }
+  async getQueryEmbedding(query, provider) {
+    const now = Date.now();
+    const cached = this.queryEmbeddingCache.get(query);
+    if (cached && now - cached.timestamp < this.queryCacheTtlMs) {
+      this.logger.cache("debug", "Query embedding cache hit (exact)", { query: query.slice(0, 50) });
+      this.logger.recordQueryCacheHit();
+      return cached.embedding;
+    }
+    const similarMatch = this.findSimilarCachedQuery(query, now);
+    if (similarMatch) {
+      this.logger.cache("debug", "Query embedding cache hit (similar)", {
+        query: query.slice(0, 50),
+        similarTo: similarMatch.key.slice(0, 50),
+        similarity: similarMatch.similarity.toFixed(3)
+      });
+      this.logger.recordQueryCacheSimilarHit();
+      return similarMatch.embedding;
+    }
+    this.logger.cache("debug", "Query embedding cache miss", { query: query.slice(0, 50) });
+    this.logger.recordQueryCacheMiss();
+    const { embedding, tokensUsed } = await provider.embedQuery(query);
+    this.logger.recordEmbeddingApiCall(tokensUsed);
+    if (this.queryEmbeddingCache.size >= this.maxQueryCacheSize) {
+      const oldestKey = this.queryEmbeddingCache.keys().next().value;
+      if (oldestKey) {
+        this.queryEmbeddingCache.delete(oldestKey);
+      }
+    }
+    this.queryEmbeddingCache.set(query, { embedding, timestamp: now });
+    return embedding;
+  }
+  findSimilarCachedQuery(query, now) {
+    const queryTokens = this.tokenize(query);
+    if (queryTokens.size === 0) return null;
+    let bestMatch = null;
+    for (const [cachedQuery, { embedding, timestamp }] of this.queryEmbeddingCache) {
+      if (now - timestamp >= this.queryCacheTtlMs) continue;
+      const cachedTokens = this.tokenize(cachedQuery);
+      const similarity = this.jaccardSimilarity(queryTokens, cachedTokens);
+      if (similarity >= this.querySimilarityThreshold) {
+        if (!bestMatch || similarity > bestMatch.similarity) {
+          bestMatch = { key: cachedQuery, embedding, similarity };
+        }
+      }
+    }
+    return bestMatch;
+  }
+  tokenize(text) {
+    return new Set(
+      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 1)
+    );
+  }
+  jaccardSimilarity(a, b) {
+    if (a.size === 0 && b.size === 0) return 1;
+    if (a.size === 0 || b.size === 0) return 0;
+    let intersection = 0;
+    for (const token of a) {
+      if (b.has(token)) intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return intersection / union;
+  }
+  async search(query, limit, options) {
+    const { store, provider, database } = await this.ensureInitialized();
+    const compatibility = this.checkCompatibility();
+    if (!compatibility.compatible) {
+      throw new Error(
+        `${compatibility.reason ?? "Index is incompatible with current embedding provider."} A possible solution is to run index_codebase with force=true to rebuild the index.`
+      );
+    }
+    const searchStartTime = import_perf_hooks.performance.now();
+    if (store.count() === 0) {
+      this.logger.search("debug", "Search on empty index", { query });
+      return [];
+    }
+    const maxResults = limit ?? this.config.search.maxResults;
+    const hybridWeight = options?.hybridWeight ?? this.config.search.hybridWeight;
+    const filterByBranch = options?.filterByBranch ?? true;
+    this.logger.search("debug", "Starting search", {
+      query,
+      maxResults,
+      hybridWeight,
+      filterByBranch
+    });
+    const embeddingStartTime = import_perf_hooks.performance.now();
+    const embedding = await this.getQueryEmbedding(query, provider);
+    const embeddingMs = import_perf_hooks.performance.now() - embeddingStartTime;
+    const vectorStartTime = import_perf_hooks.performance.now();
+    const semanticResults = store.search(embedding, maxResults * 4);
+    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
+    const keywordStartTime = import_perf_hooks.performance.now();
+    const keywordResults = await this.keywordSearch(query, maxResults * 4);
+    const keywordMs = import_perf_hooks.performance.now() - keywordStartTime;
+    const fusionStartTime = import_perf_hooks.performance.now();
+    const combined = this.fuseResults(semanticResults, keywordResults, hybridWeight, maxResults * 4);
+    const fusionMs = import_perf_hooks.performance.now() - fusionStartTime;
+    let branchChunkIds = null;
+    if (filterByBranch && this.currentBranch !== "default") {
+      branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
+    }
+    const filtered = combined.filter((r) => {
+      if (r.score < this.config.search.minScore) return false;
+      if (branchChunkIds && !branchChunkIds.has(r.id)) return false;
+      if (options?.fileType) {
+        const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
+        if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
+      }
+      if (options?.directory) {
+        const normalizedDir = options.directory.replace(/^\/|\/$/g, "");
+        if (!r.metadata.filePath.includes(`/${normalizedDir}/`) && !r.metadata.filePath.includes(`${normalizedDir}/`)) return false;
+      }
+      if (options?.chunkType) {
+        if (r.metadata.chunkType !== options.chunkType) return false;
+      }
+      return true;
+    }).slice(0, maxResults);
+    const totalSearchMs = import_perf_hooks.performance.now() - searchStartTime;
+    this.logger.recordSearch(totalSearchMs, {
+      embeddingMs,
+      vectorMs,
+      keywordMs,
+      fusionMs
+    });
+    this.logger.search("info", "Search complete", {
+      query,
+      results: filtered.length,
+      totalMs: Math.round(totalSearchMs * 100) / 100,
+      embeddingMs: Math.round(embeddingMs * 100) / 100,
+      vectorMs: Math.round(vectorMs * 100) / 100,
+      keywordMs: Math.round(keywordMs * 100) / 100,
+      fusionMs: Math.round(fusionMs * 100) / 100
+    });
+    const metadataOnly = options?.metadataOnly ?? false;
+    return Promise.all(
+      filtered.map(async (r) => {
+        let content = "";
+        let contextStartLine = r.metadata.startLine;
+        let contextEndLine = r.metadata.endLine;
+        if (!metadataOnly && this.config.search.includeContext) {
+          try {
+            const fileContent = await import_fs4.promises.readFile(
+              r.metadata.filePath,
+              "utf-8"
+            );
+            const lines = fileContent.split("\n");
+            const contextLines = options?.contextLines ?? this.config.search.contextLines;
+            contextStartLine = Math.max(1, r.metadata.startLine - contextLines);
+            contextEndLine = Math.min(lines.length, r.metadata.endLine + contextLines);
+            content = lines.slice(contextStartLine - 1, contextEndLine).join("\n");
+          } catch {
+            content = "[File not accessible]";
+          }
+        }
+        return {
+          filePath: r.metadata.filePath,
+          startLine: contextStartLine,
+          endLine: contextEndLine,
+          content,
+          score: r.score,
+          chunkType: r.metadata.chunkType,
+          name: r.metadata.name
+        };
+      })
+    );
+  }
+  async keywordSearch(query, limit) {
+    const { store, invertedIndex } = await this.ensureInitialized();
+    const scores = invertedIndex.search(query);
+    if (scores.size === 0) {
+      return [];
+    }
+    const chunkIds = Array.from(scores.keys());
+    const metadataMap = store.getMetadataBatch(chunkIds);
+    const results = [];
+    for (const [chunkId, score] of scores) {
+      const metadata = metadataMap.get(chunkId);
+      if (metadata && score > 0) {
+        results.push({ id: chunkId, score, metadata });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  fuseResults(semanticResults, keywordResults, keywordWeight, limit) {
+    const semanticWeight = 1 - keywordWeight;
+    const fusedScores = /* @__PURE__ */ new Map();
+    for (const r of semanticResults) {
+      fusedScores.set(r.id, {
+        score: r.score * semanticWeight,
+        metadata: r.metadata
+      });
+    }
+    for (const r of keywordResults) {
+      const existing = fusedScores.get(r.id);
+      if (existing) {
+        existing.score += r.score * keywordWeight;
+      } else {
+        fusedScores.set(r.id, {
+          score: r.score * keywordWeight,
+          metadata: r.metadata
+        });
+      }
+    }
+    const results = Array.from(fusedScores.entries()).map(([id, data]) => ({
+      id,
+      score: data.score,
+      metadata: data.metadata
+    }));
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  async getStatus() {
+    const { store, configuredProviderInfo } = await this.ensureInitialized();
+    return {
+      indexed: store.count() > 0,
+      vectorCount: store.count(),
+      provider: configuredProviderInfo.provider,
+      model: configuredProviderInfo.modelInfo.model,
+      indexPath: this.indexPath,
+      currentBranch: this.currentBranch,
+      baseBranch: this.baseBranch,
+      compatibility: this.indexCompatibility
+    };
+  }
+  async clearIndex() {
+    const { store, invertedIndex, database } = await this.ensureInitialized();
+    store.clear();
+    store.save();
+    invertedIndex.clear();
+    invertedIndex.save();
+    this.fileHashCache.clear();
+    this.saveFileHashCache();
+    database.clearBranch(this.currentBranch);
+    database.deleteMetadata("index.version");
+    database.deleteMetadata("index.embeddingProvider");
+    database.deleteMetadata("index.embeddingModel");
+    database.deleteMetadata("index.embeddingDimensions");
+    database.deleteMetadata("index.createdAt");
+    database.deleteMetadata("index.updatedAt");
+    this.indexCompatibility = this.validateIndexCompatibility(this.configuredProviderInfo);
+  }
+  async healthCheck() {
+    const { store, invertedIndex, database } = await this.ensureInitialized();
+    this.logger.gc("info", "Starting health check");
+    const allMetadata = store.getAllMetadata();
+    const filePathsToChunkKeys = /* @__PURE__ */ new Map();
+    for (const { key, metadata } of allMetadata) {
+      const existing = filePathsToChunkKeys.get(metadata.filePath) || [];
+      existing.push(key);
+      filePathsToChunkKeys.set(metadata.filePath, existing);
+    }
+    const removedFilePaths = [];
+    let removedCount = 0;
+    for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
+      if (!(0, import_fs4.existsSync)(filePath)) {
+        for (const key of chunkKeys) {
+          store.remove(key);
+          invertedIndex.removeChunk(key);
+          removedCount++;
+        }
+        database.deleteChunksByFile(filePath);
+        removedFilePaths.push(filePath);
+      }
+    }
+    if (removedCount > 0) {
+      store.save();
+      invertedIndex.save();
+    }
+    const gcOrphanEmbeddings = database.gcOrphanEmbeddings();
+    const gcOrphanChunks = database.gcOrphanChunks();
+    this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
+    this.logger.gc("info", "Health check complete", {
+      removedStale: removedCount,
+      orphanEmbeddings: gcOrphanEmbeddings,
+      orphanChunks: gcOrphanChunks,
+      removedFiles: removedFilePaths.length
+    });
+    return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks };
+  }
+  async retryFailedBatches() {
+    const { store, provider, invertedIndex } = await this.ensureInitialized();
+    const failedBatches = this.loadFailedBatches();
+    if (failedBatches.length === 0) {
+      return { succeeded: 0, failed: 0, remaining: 0 };
+    }
+    let succeeded = 0;
+    let failed = 0;
+    const stillFailing = [];
+    for (const batch of failedBatches) {
+      try {
+        const result = await pRetry(
+          async () => {
+            const texts = batch.chunks.map((c) => c.text);
+            return provider.embedBatch(texts);
+          },
+          {
+            retries: this.config.indexing.retries,
+            minTimeout: this.config.indexing.retryDelayMs
+          }
+        );
+        const items = batch.chunks.map((chunk, idx) => ({
+          id: chunk.id,
+          vector: result.embeddings[idx],
+          metadata: chunk.metadata
+        }));
+        store.addBatch(items);
+        for (const chunk of batch.chunks) {
+          invertedIndex.removeChunk(chunk.id);
+          invertedIndex.addChunk(chunk.id, chunk.content);
+        }
+        this.logger.recordChunksEmbedded(batch.chunks.length);
+        this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
+        succeeded += batch.chunks.length;
+      } catch (error) {
+        failed += batch.chunks.length;
+        this.logger.recordEmbeddingError();
+        stillFailing.push({
+          ...batch,
+          attemptCount: batch.attemptCount + 1,
+          lastAttempt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: String(error)
+        });
+      }
+    }
+    this.saveFailedBatches(stillFailing);
+    if (succeeded > 0) {
+      store.save();
+      invertedIndex.save();
+    }
+    return { succeeded, failed, remaining: stillFailing.length };
+  }
+  getFailedBatchesCount() {
+    return this.loadFailedBatches().length;
+  }
+  getCurrentBranch() {
+    return this.currentBranch;
+  }
+  getBaseBranch() {
+    return this.baseBranch;
+  }
+  refreshBranchInfo() {
+    if (isGitRepo(this.projectRoot)) {
+      this.currentBranch = getBranchOrDefault(this.projectRoot);
+      this.baseBranch = getBaseBranch(this.projectRoot);
+    }
+  }
+  async getDatabaseStats() {
+    const { database } = await this.ensureInitialized();
+    return database.getStats();
+  }
+  getLogger() {
+    return this.logger;
+  }
+  async findSimilar(code, limit = this.config.search.maxResults, options) {
+    const { store, provider, database } = await this.ensureInitialized();
+    const compatibility = this.checkCompatibility();
+    if (!compatibility.compatible) {
+      throw new Error(
+        `${compatibility.reason ?? "Index is incompatible with current embedding provider."} Run index_codebase with force=true to rebuild the index.`
+      );
+    }
+    const searchStartTime = import_perf_hooks.performance.now();
+    if (store.count() === 0) {
+      this.logger.search("debug", "Find similar on empty index");
+      return [];
+    }
+    const filterByBranch = options?.filterByBranch ?? true;
+    this.logger.search("debug", "Starting find similar", {
+      codeLength: code.length,
+      limit,
+      filterByBranch
+    });
+    const embeddingStartTime = import_perf_hooks.performance.now();
+    const { embedding, tokensUsed } = await provider.embedDocument(code);
+    const embeddingMs = import_perf_hooks.performance.now() - embeddingStartTime;
+    this.logger.recordEmbeddingApiCall(tokensUsed);
+    const vectorStartTime = import_perf_hooks.performance.now();
+    const semanticResults = store.search(embedding, limit * 2);
+    const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
+    let branchChunkIds = null;
+    if (filterByBranch && this.currentBranch !== "default") {
+      branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
+    }
+    const filtered = semanticResults.filter((r) => {
+      if (r.score < this.config.search.minScore) return false;
+      if (branchChunkIds && !branchChunkIds.has(r.id)) return false;
+      if (options?.excludeFile) {
+        if (r.metadata.filePath === options.excludeFile) return false;
+      }
+      if (options?.fileType) {
+        const ext = r.metadata.filePath.split(".").pop()?.toLowerCase();
+        if (ext !== options.fileType.toLowerCase().replace(/^\./, "")) return false;
+      }
+      if (options?.directory) {
+        const normalizedDir = options.directory.replace(/^\/|\/$/g, "");
+        if (!r.metadata.filePath.includes(`/${normalizedDir}/`) && !r.metadata.filePath.includes(`${normalizedDir}/`)) return false;
+      }
+      if (options?.chunkType) {
+        if (r.metadata.chunkType !== options.chunkType) return false;
+      }
+      return true;
+    }).slice(0, limit);
+    const totalSearchMs = import_perf_hooks.performance.now() - searchStartTime;
+    this.logger.recordSearch(totalSearchMs, {
+      embeddingMs,
+      vectorMs,
+      keywordMs: 0,
+      fusionMs: 0
+    });
+    this.logger.search("info", "Find similar complete", {
+      codeLength: code.length,
+      results: filtered.length,
+      totalMs: Math.round(totalSearchMs * 100) / 100,
+      embeddingMs: Math.round(embeddingMs * 100) / 100,
+      vectorMs: Math.round(vectorMs * 100) / 100
+    });
+    return Promise.all(
+      filtered.map(async (r) => {
+        let content = "";
+        if (this.config.search.includeContext) {
+          try {
+            const fileContent = await import_fs4.promises.readFile(
+              r.metadata.filePath,
+              "utf-8"
+            );
+            const lines = fileContent.split("\n");
+            content = lines.slice(r.metadata.startLine - 1, r.metadata.endLine).join("\n");
+          } catch {
+            content = "[File not accessible]";
+          }
+        }
+        return {
+          filePath: r.metadata.filePath,
+          startLine: r.metadata.startLine,
+          endLine: r.metadata.endLine,
+          content,
+          score: r.score,
+          chunkType: r.metadata.chunkType,
+          name: r.metadata.name
+        };
+      })
+    );
+  }
+};
+
+// src/mcp-server.ts
+var MAX_CONTENT_LINES = 30;
+function truncateContent(content) {
+  const lines = content.split("\n");
+  if (lines.length <= MAX_CONTENT_LINES) return content;
+  return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
+// ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
+}
+function formatIndexStats(stats, verbose = false) {
+  const lines = [];
+  if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
+    lines.push(`Indexed. ${stats.totalFiles} files processed, ${stats.existingChunks} code chunks already up to date.`);
+  } else if (stats.indexedChunks === 0) {
+    lines.push(`Indexed. ${stats.totalFiles} files, removed ${stats.removedChunks} stale chunks, ${stats.existingChunks} chunks remain.`);
+  } else {
+    let main2 = `Indexed. ${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
+    if (stats.existingChunks > 0) {
+      main2 += ` ${stats.existingChunks} unchanged chunks skipped.`;
+    }
+    lines.push(main2);
+    if (stats.removedChunks > 0) {
+      lines.push(`Removed ${stats.removedChunks} stale chunks.`);
+    }
+    if (stats.failedChunks > 0) {
+      lines.push(`Failed: ${stats.failedChunks} chunks.`);
+    }
+    lines.push(`Tokens: ${stats.tokensUsed.toLocaleString()}, Duration: ${(stats.durationMs / 1e3).toFixed(1)}s`);
+  }
+  if (verbose) {
+    if (stats.skippedFiles.length > 0) {
+      const tooLarge = stats.skippedFiles.filter((f) => f.reason === "too_large");
+      const excluded = stats.skippedFiles.filter((f) => f.reason === "excluded");
+      const gitignored = stats.skippedFiles.filter((f) => f.reason === "gitignore");
+      lines.push("");
+      lines.push(`Skipped files: ${stats.skippedFiles.length}`);
+      if (tooLarge.length > 0) {
+        lines.push(`  Too large (${tooLarge.length}): ${tooLarge.slice(0, 5).map((f) => f.path).join(", ")}${tooLarge.length > 5 ? "..." : ""}`);
+      }
+      if (excluded.length > 0) {
+        lines.push(`  Excluded (${excluded.length}): ${excluded.slice(0, 5).map((f) => f.path).join(", ")}${excluded.length > 5 ? "..." : ""}`);
+      }
+      if (gitignored.length > 0) {
+        lines.push(`  Gitignored (${gitignored.length}): ${gitignored.slice(0, 5).map((f) => f.path).join(", ")}${gitignored.length > 5 ? "..." : ""}`);
+      }
+    }
+    if (stats.parseFailures.length > 0) {
+      lines.push("");
+      lines.push(`Files with no extractable chunks (${stats.parseFailures.length}): ${stats.parseFailures.slice(0, 10).join(", ")}${stats.parseFailures.length > 10 ? "..." : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatStatus(status) {
+  if (!status.indexed) {
+    return "Codebase is not indexed. Run index_codebase to create an index.";
+  }
+  const lines = [
+    `Index status:`,
+    `  Indexed chunks: ${status.vectorCount.toLocaleString()}`,
+    `  Provider: ${status.provider}`,
+    `  Model: ${status.model}`,
+    `  Location: ${status.indexPath}`
+  ];
+  if (status.currentBranch !== "default") {
+    lines.push(`  Current branch: ${status.currentBranch}`);
+    lines.push(`  Base branch: ${status.baseBranch}`);
+  }
+  return lines.join("\n");
+}
+var CHUNK_TYPE_ENUM = [
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type",
+  "enum",
+  "struct",
+  "impl",
+  "trait",
+  "module",
+  "other"
+];
+function createMcpServer(projectRoot, config) {
+  const server = new import_mcp.McpServer({
+    name: "opencode-codebase-index",
+    version: "0.5.0"
+  });
+  const indexer = new Indexer(projectRoot, config);
+  let initialized = false;
+  async function ensureInitialized() {
+    if (!initialized) {
+      await indexer.initialize();
+      initialized = true;
+    }
+  }
+  server.tool(
+    "codebase_search",
+    "Search codebase by MEANING, not keywords. Returns full code content. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead.",
+    {
+      query: import_zod.z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
+      limit: import_zod.z.number().optional().default(5).describe("Maximum number of results to return"),
+      fileType: import_zod.z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: import_zod.z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: import_zod.z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
+      contextLines: import_zod.z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
+    },
+    async (args) => {
+      await ensureInitialized();
+      const results = await indexer.search(args.query, args.limit ?? 5, {
+        fileType: args.fileType,
+        directory: args.directory,
+        chunkType: args.chunkType,
+        contextLines: args.contextLines
+      });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: "No matching code found. Try a different query or run index_codebase first." }] };
+      }
+      const formatted = results.map((r, idx) => {
+        const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
+        return `${header} (score: ${r.score.toFixed(2)})
+\`\`\`
+${truncateContent(r.content)}
+\`\`\``;
+      });
+      return { content: [{ type: "text", text: `Found ${results.length} results for "${args.query}":
+
+${formatted.join("\n\n")}` }] };
+    }
+  );
+  server.tool(
+    "codebase_peek",
+    "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Saves ~90% tokens vs codebase_search.",
+    {
+      query: import_zod.z.string().describe("Natural language description of what code you're looking for."),
+      limit: import_zod.z.number().optional().default(10).describe("Maximum number of results to return"),
+      fileType: import_zod.z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: import_zod.z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: import_zod.z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type")
+    },
+    async (args) => {
+      await ensureInitialized();
+      const results = await indexer.search(args.query, args.limit ?? 10, {
+        fileType: args.fileType,
+        directory: args.directory,
+        chunkType: args.chunkType,
+        metadataOnly: true
+      });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: "No matching code found. Try a different query or run index_codebase first." }] };
+      }
+      const formatted = results.map((r, idx) => {
+        const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
+        const name = r.name ? `"${r.name}"` : "(anonymous)";
+        return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})`;
+      });
+      return { content: [{ type: "text", text: `Found ${results.length} locations for "${args.query}":
+
+${formatted.join("\n")}
+
+Use Read tool to examine specific files.` }] };
+    }
+  );
+  server.tool(
+    "index_codebase",
+    "Index the codebase for semantic search. Creates vector embeddings of code chunks. Incremental - only re-indexes changed files. Run before first codebase_search.",
+    {
+      force: import_zod.z.boolean().optional().default(false).describe("Force reindex even if already indexed"),
+      estimateOnly: import_zod.z.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
+      verbose: import_zod.z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
+    },
+    async (args) => {
+      await ensureInitialized();
+      if (args.estimateOnly) {
+        const estimate = await indexer.estimateCost();
+        return { content: [{ type: "text", text: formatCostEstimate(estimate) }] };
+      }
+      if (args.force) {
+        await indexer.clearIndex();
+      }
+      const stats = await indexer.index();
+      return { content: [{ type: "text", text: formatIndexStats(stats, args.verbose ?? false) }] };
+    }
+  );
+  server.tool(
+    "index_status",
+    "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
+    {},
+    async () => {
+      await ensureInitialized();
+      const status = await indexer.getStatus();
+      return { content: [{ type: "text", text: formatStatus(status) }] };
+    }
+  );
+  server.tool(
+    "index_health_check",
+    "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
+    {},
+    async () => {
+      await ensureInitialized();
+      const result = await indexer.healthCheck();
+      if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0) {
+        return { content: [{ type: "text", text: "Index is healthy. No stale entries found." }] };
+      }
+      const lines = [`Health check complete:`];
+      if (result.removed > 0) {
+        lines.push(`  Removed stale entries: ${result.removed}`);
+      }
+      if (result.gcOrphanEmbeddings > 0) {
+        lines.push(`  Garbage collected orphan embeddings: ${result.gcOrphanEmbeddings}`);
+      }
+      if (result.gcOrphanChunks > 0) {
+        lines.push(`  Garbage collected orphan chunks: ${result.gcOrphanChunks}`);
+      }
+      if (result.filePaths.length > 0) {
+        lines.push(`  Cleaned paths: ${result.filePaths.join(", ")}`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.tool(
+    "index_metrics",
+    "Get metrics and performance statistics for the codebase index. Requires debug.enabled=true and debug.metrics=true in config.",
+    {},
+    async () => {
+      await ensureInitialized();
+      const logger = indexer.getLogger();
+      if (!logger.isEnabled()) {
+        return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```' }] };
+      }
+      if (!logger.isMetricsEnabled()) {
+        return { content: [{ type: "text", text: 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```' }] };
+      }
+      return { content: [{ type: "text", text: logger.formatMetrics() }] };
+    }
+  );
+  server.tool(
+    "index_logs",
+    "Get recent debug logs from the codebase indexer. Requires debug.enabled=true in config.",
+    {
+      limit: import_zod.z.number().optional().default(20).describe("Maximum number of log entries to return"),
+      category: import_zod.z.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
+      level: import_zod.z.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
+    },
+    async (args) => {
+      await ensureInitialized();
+      const logger = indexer.getLogger();
+      if (!logger.isEnabled()) {
+        return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```' }] };
+      }
+      let logs;
+      if (args.category) {
+        logs = logger.getLogsByCategory(args.category, args.limit);
+      } else if (args.level) {
+        logs = logger.getLogsByLevel(args.level, args.limit);
+      } else {
+        logs = logger.getLogs(args.limit);
+      }
+      if (logs.length === 0) {
+        return { content: [{ type: "text", text: "No logs recorded yet. Logs are captured during indexing and search operations." }] };
+      }
+      const text = logs.map((l) => {
+        const dataStr = l.data ? ` ${JSON.stringify(l.data)}` : "";
+        return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
+      }).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.tool(
+    "find_similar",
+    "Find code similar to a given snippet. Use for duplicate detection, pattern discovery, or refactoring prep.",
+    {
+      code: import_zod.z.string().describe("The code snippet to find similar code for"),
+      limit: import_zod.z.number().optional().default(10).describe("Maximum number of results to return"),
+      fileType: import_zod.z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+      directory: import_zod.z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+      chunkType: import_zod.z.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type"),
+      excludeFile: import_zod.z.string().optional().describe("Exclude results from this file path")
+    },
+    async (args) => {
+      await ensureInitialized();
+      const results = await indexer.findSimilar(args.code, args.limit ?? 10, {
+        fileType: args.fileType,
+        directory: args.directory,
+        chunkType: args.chunkType,
+        excludeFile: args.excludeFile
+      });
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: "No similar code found. Try a different snippet or run index_codebase first." }] };
+      }
+      const formatted = results.map((r, idx) => {
+        const header = r.name ? `[${idx + 1}] ${r.chunkType} "${r.name}" in ${r.filePath}:${r.startLine}-${r.endLine}` : `[${idx + 1}] ${r.chunkType} in ${r.filePath}:${r.startLine}-${r.endLine}`;
+        return `${header} (similarity: ${(r.score * 100).toFixed(1)}%)
+\`\`\`
+${truncateContent(r.content)}
+\`\`\``;
+      });
+      return { content: [{ type: "text", text: `Found ${results.length} similar code blocks:
+
+${formatted.join("\n\n")}` }] };
+    }
+  );
+  server.prompt(
+    "search",
+    "Search codebase by meaning using semantic search",
+    { query: import_zod.z.string().describe("What to search for in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Search the codebase for: "${args.query}"
+
+Use the codebase_search tool with this query. If you need just locations first, use codebase_peek instead to save tokens.`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "find",
+    "Find code using hybrid approach (semantic + grep)",
+    { query: import_zod.z.string().describe("What to find in the codebase") },
+    (args) => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: `Find code related to: "${args.query}"
+
+Use a hybrid approach:
+1. First use codebase_peek to find semantic matches by meaning
+2. Then use grep for exact identifier matches
+3. Combine results for comprehensive coverage`
+        }
+      }]
+    })
+  );
+  server.prompt(
+    "index",
+    "Index the codebase for semantic search",
+    { options: import_zod.z.string().optional().describe("Options: 'force' to rebuild, 'estimate' to check costs") },
+    (args) => {
+      const opts = args.options?.toLowerCase() ?? "";
+      let instruction = "Use the index_codebase tool to index the codebase for semantic search.";
+      if (opts.includes("force")) {
+        instruction = "Use the index_codebase tool with force=true to rebuild the entire index from scratch.";
+      } else if (opts.includes("estimate")) {
+        instruction = "Use the index_codebase tool with estimateOnly=true to check the cost estimate before indexing.";
+      }
+      return {
+        messages: [{
+          role: "user",
+          content: { type: "text", text: instruction }
+        }]
+      };
+    }
+  );
+  server.prompt(
+    "status",
+    "Check if the codebase is indexed and ready",
+    {},
+    () => ({
+      messages: [{
+        role: "user",
+        content: {
+          type: "text",
+          text: "Use the index_status tool to check if the codebase index is ready and show its current state."
+        }
+      }]
+    })
+  );
+  return server;
+}
+
+// src/cli.ts
+function loadJsonFile(filePath) {
+  try {
+    if ((0, import_fs5.existsSync)(filePath)) {
+      const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return null;
+}
+function loadPluginConfig(projectRoot, configPath) {
+  if (configPath) {
+    const config = loadJsonFile(configPath);
+    if (config) return config;
+  }
+  const projectConfig = loadJsonFile(path6.join(projectRoot, ".opencode", "codebase-index.json"));
+  if (projectConfig) return projectConfig;
+  const globalConfig = loadJsonFile(path6.join(os3.homedir(), ".config", "opencode", "codebase-index.json"));
+  if (globalConfig) return globalConfig;
+  return {};
+}
+function parseArgs(argv) {
+  let project = process.cwd();
+  let config;
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--project" && argv[i + 1]) {
+      project = path6.resolve(argv[++i]);
+    } else if (argv[i] === "--config" && argv[i + 1]) {
+      config = path6.resolve(argv[++i]);
+    }
+  }
+  return { project, config };
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  const rawConfig = loadPluginConfig(args.project, args.config);
+  const config = parseConfig(rawConfig);
+  const server = createMcpServer(args.project, config);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = () => {
+    server.close().catch(() => {
+    });
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Fatal: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map