opencode-codebase-index 0.15.0 → 0.17.0

package/dist/index.js

@@ -6,7 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   try {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   } catch (e) {
@@ -650,6 +656,467 @@ var require_ignore = __commonJS({
   }
 });
 
+// node_modules/tiktoken/tiktoken_bg.cjs
+var require_tiktoken_bg = __commonJS({
+  "node_modules/tiktoken/tiktoken_bg.cjs"(exports, module2) {
+    "use strict";
+    var wasm;
+    module2.exports.__wbg_set_wasm = function(val) {
+      wasm = val;
+    };
+    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module2.require)("util").TextDecoder : TextDecoder;
+    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    var cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+      }
+      return cachedUint8ArrayMemory0;
+    }
+    function getStringFromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+    var heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    var heap_next = heap.length;
+    function addHeapObject(obj) {
+      if (heap_next === heap.length) heap.push(heap.length + 1);
+      const idx = heap_next;
+      heap_next = heap[idx];
+      heap[idx] = obj;
+      return idx;
+    }
+    function handleError(f, args) {
+      try {
+        return f.apply(this, args);
+      } catch (e) {
+        wasm.__wbindgen_export_0(addHeapObject(e));
+      }
+    }
+    function getObject(idx) {
+      return heap[idx];
+    }
+    function dropObject(idx) {
+      if (idx < 132) return;
+      heap[idx] = heap_next;
+      heap_next = idx;
+    }
+    function takeObject(idx) {
+      const ret = getObject(idx);
+      dropObject(idx);
+      return ret;
+    }
+    var WASM_VECTOR_LEN = 0;
+    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module2.require)("util").TextEncoder : TextEncoder;
+    var cachedTextEncoder = new lTextEncoder("utf-8");
+    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+      return cachedTextEncoder.encodeInto(arg, view);
+    } : function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+    function passStringToWasm0(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory0();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 127) break;
+        mem[ptr + offset] = code;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN = offset;
+      return ptr;
+    }
+    function isLikeNone(x) {
+      return x === void 0 || x === null;
+    }
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    var cachedUint32ArrayMemory0 = null;
+    function getUint32ArrayMemory0() {
+      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+      }
+      return cachedUint32ArrayMemory0;
+    }
+    function getArrayU32FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    }
+    function passArray8ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 1, 1) >>> 0;
+      getUint8ArrayMemory0().set(arg, ptr / 1);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function passArray32ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 4, 4) >>> 0;
+      getUint32ArrayMemory0().set(arg, ptr / 4);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+    module2.exports.get_encoding = function(encoding, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(encoding, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.encoding_for_model = function(model, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.get_encoding_name_for_model = function(model) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      let deferred3_0;
+      let deferred3_1;
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.get_encoding_name_for_model(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+          ptr2 = 0;
+          len2 = 0;
+          throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
+      }
+    };
+    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_tiktoken_free(ptr >>> 0, 1));
+    var Tiktoken = class _Tiktoken {
+      /**
+       * @param {string} tiktoken_bfe
+       * @param {any} special_tokens
+       * @param {string} pat_str
+       */
+      constructor(tiktoken_bfe, special_tokens, pat_str) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pat_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        TiktokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /** @returns {string | undefined} */
+      get name() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_name(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          let v1;
+          if (r0 !== 0) {
+            v1 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          }
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Tiktoken.prototype);
+        obj.__wbg_ptr = ptr;
+        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TiktokenFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tiktoken_free(ptr, 0);
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {Uint32Array}
+       */
+      encode(text, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          if (r3) {
+            throw takeObject(r2);
+          }
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @returns {Uint32Array}
+       */
+      encode_ordinary(text) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {any}
+       */
+      encode_with_unstable(text, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {Uint8Array} bytes
+       * @returns {number}
+       */
+      encode_single_token(bytes) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+      }
+      /**
+       * @param {Uint32Array} tokens
+       * @returns {Uint8Array}
+       */
+      decode(tokens) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArray32ToWasm0(tokens, wasm.__wbindgen_export_1);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {number} token
+       * @returns {Uint8Array}
+       */
+      decode_single_token_bytes(token) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v1 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /** @returns {any} */
+      token_byte_values() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ret = wasm.tiktoken_token_byte_values(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+    };
+    module2.exports.Tiktoken = Tiktoken;
+    module2.exports.__wbg_parse_def2e24ef1252aff = function() {
+      return handleError(function(arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
+      return handleError(function(arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbindgen_error_new = function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    };
+    module2.exports.__wbindgen_is_undefined = function(arg0) {
+      const ret = getObject(arg0) === void 0;
+      return ret;
+    };
+    module2.exports.__wbindgen_object_drop_ref = function(arg0) {
+      takeObject(arg0);
+    };
+    module2.exports.__wbindgen_string_get = function(arg0, arg1) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      const obj = getObject(arg1);
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    module2.exports.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+  }
+});
+
+// node_modules/tiktoken/tiktoken.cjs
+var require_tiktoken = __commonJS({
+  "node_modules/tiktoken/tiktoken.cjs"(exports) {
+    "use strict";
+    var wasm = require_tiktoken_bg();
+    var imports = {};
+    imports["./tiktoken_bg.js"] = wasm;
+    var path24 = __require("path");
+    var fs = __require("fs");
+    var candidates = __dirname.split(path24.sep).reduce((memo, _, index, array) => {
+      const prefix = array.slice(0, index + 1).join(path24.sep) + path24.sep;
+      if (!prefix.includes("node_modules" + path24.sep)) {
+        memo.unshift(
+          path24.join(
+            prefix,
+            "node_modules",
+            "tiktoken",
+            "",
+            "./tiktoken_bg.wasm"
+          )
+        );
+      }
+      return memo;
+    }, []);
+    candidates.unshift(path24.join(__dirname, "./tiktoken_bg.wasm"));
+    var bytes = null;
+    for (const candidate of candidates) {
+      try {
+        bytes = fs.readFileSync(candidate);
+        break;
+      } catch {
+      }
+    }
+    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
+    var wasmModule = new WebAssembly.Module(bytes);
+    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+    wasm.__wbg_set_wasm(wasmInstance.exports);
+    exports["get_encoding"] = wasm["get_encoding"];
+    exports["encoding_for_model"] = wasm["encoding_for_model"];
+    exports["get_encoding_name_for_model"] = wasm["get_encoding_name_for_model"];
+    exports["Tiktoken"] = wasm["Tiktoken"];
+  }
+});
+
 // src/index.ts
 import * as os6 from "os";
 import * as path23 from "path";
@@ -1708,7 +2175,12 @@ function sameReclaimOwner(left, right) {
 }
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${randomUUID()}`;
-  mkdirSync2(candidatePath, { mode: 448 });
+  try {
+    mkdirSync2(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
   try {
     writeFileSync2(path7.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
@@ -1721,8 +2193,12 @@ function publishJsonDirectory(finalPath, value) {
       return true;
     } catch (error) {
       if (existsSync5(finalPath)) return false;
+      if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
   } finally {
     if (existsSync5(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
   }
@@ -6578,6 +7054,27 @@ function mergeTieredResults(symbolLane, hybridLane, limit) {
   }
   return out;
 }
+function selectChunksWithFileCoverage(chunks, limit) {
+  if (limit <= 0 || chunks.length === 0) {
+    return [];
+  }
+  if (chunks.length <= limit) {
+    return chunks;
+  }
+  if (limit === 1) {
+    return [chunks[Math.floor((chunks.length - 1) / 2)]];
+  }
+  const selected = [];
+  for (let index = 0; index < limit; index++) {
+    const sourceIndex = Math.round(index * (chunks.length - 1) / (limit - 1));
+    selected.push(chunks[sourceIndex]);
+  }
+  return selected;
+}
+function selectIndexableChunks(chunks, limit, semanticOnly) {
+  const indexableChunks = semanticOnly ? chunks.filter((chunk) => chunk.chunkType !== "other") : chunks;
+  return selectChunksWithFileCoverage(indexableChunks, limit);
+}
 function matchesSearchFilters(candidate, options, minScore) {
   if (candidate.score < minScore) return false;
   if (options?.fileType) {
@@ -8316,7 +8813,6 @@ var Indexer = class {
         const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
-      let fileChunkCount = 0;
       let chunksToProcess = parsed.chunks;
       if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
         const changedFile = changedFiles.find((f) => f.path === parsed.path);
@@ -8325,13 +8821,12 @@ var Indexer = class {
           chunksToProcess = textChunks;
         }
       }
+      chunksToProcess = selectIndexableChunks(
+        chunksToProcess,
+        this.config.indexing.maxChunksPerFile,
+        this.config.indexing.semanticOnly
+      );
       for (const chunk of chunksToProcess) {
-        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);
         const existingContentHash = existingChunks.get(id);
@@ -8355,7 +8850,6 @@ var Indexer = class {
           blameSummary: blameMetadata.blameSummary
         });
         if (existingContentHash === contentHash) {
-          fileChunkCount++;
           continue;
         }
         const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
@@ -8380,7 +8874,6 @@ var Indexer = class {
           contentHash,
           metadata
         });
-        fileChunkCount++;
       }
     }
     const retryableFailedChunks = this.collectRetryableFailedChunks(
@@ -8942,10 +9435,19 @@ var Indexer = class {
     });
     const embeddingStartTime = performance2.now();
     const embeddingQuery = stripFilePathHint(query);
-    const embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    let embedding;
+    try {
+      embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    } catch (error) {
+      this.logger.warn("Query embedding failed; falling back to keyword-only search", {
+        query,
+        error: getErrorMessage2(error),
+        action: "Check the embedding provider configuration and retry search after restoring provider health."
+      });
+    }
     const embeddingMs = performance2.now() - embeddingStartTime;
     const vectorStartTime = performance2.now();
-    const semanticResults = store.search(embedding, maxResults * 4);
+    const semanticResults = embedding ? store.search(embedding, maxResults * 4) : [];
     const vectorMs = performance2.now() - vectorStartTime;
     const keywordStartTime = performance2.now();
     const keywordResults = await this.keywordSearch(query, maxResults * 4, store, invertedIndex);
@@ -8980,12 +9482,13 @@ var Indexer = class {
       });
     }
     const fusionStartTime = performance2.now();
+    const rankingHybridWeight = embedding === void 0 && fusionStrategy === "weighted" ? 1 : effectiveHybridWeight;
     const combined = rankHybridResults(query, semanticCandidates, keywordCandidates, {
       fusionStrategy,
       rrfK,
       rerankTopN,
       limit: maxResults,
-      hybridWeight: effectiveHybridWeight,
+      hybridWeight: rankingHybridWeight,
       prioritizeSourcePaths: sourceIntent
     });
     const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
@@ -9961,6 +10464,159 @@ function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
 }
 
 // src/tools/utils.ts
+var import_tiktoken = __toESM(require_tiktoken(), 1);
+var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
+var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
+var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
+var CONTEXT_TOKENIZER = (0, import_tiktoken.get_encoding)("cl100k_base");
+function clampContextPackTokenBudget(tokenBudget) {
+  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
+    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  }
+  return Math.min(
+    MAX_CONTEXT_PACK_TOKEN_BUDGET,
+    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
+  );
+}
+function countContextTokens(text) {
+  return CONTEXT_TOKENIZER.encode(text).length;
+}
+function fitTextToContextBudget(text, tokenBudget) {
+  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
+  const tokenEstimate = countContextTokens(text);
+  if (tokenEstimate <= normalizedBudget) {
+    return {
+      text,
+      tokenBudget: normalizedBudget,
+      tokenEstimate,
+      truncated: false
+    };
+  }
+  const suffix = "\n...[truncated to context token budget]";
+  const codePoints = Array.from(text);
+  let low = 0;
+  let high = codePoints.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = `${codePoints.slice(0, middle).join("").trimEnd()}${suffix}`;
+    if (countContextTokens(candidate) <= normalizedBudget) low = middle;
+    else high = middle - 1;
+  }
+  const fitted = `${codePoints.slice(0, low).join("").trimEnd()}${suffix}`;
+  return {
+    text: fitted,
+    tokenBudget: normalizedBudget,
+    tokenEstimate: countContextTokens(fitted),
+    truncated: true
+  };
+}
+function normalizedLineRange(result) {
+  return result.startLine <= result.endLine ? { start: result.startLine, end: result.endLine } : { start: result.endLine, end: result.startLine };
+}
+function rankContextCandidates(results) {
+  return results.map((result, originalIndex) => ({ result, originalIndex })).sort((left, right) => right.result.score - left.result.score || left.originalIndex - right.originalIndex);
+}
+function deduplicateContextCandidates(candidates) {
+  const acceptedByFile = /* @__PURE__ */ new Map();
+  const deduplicated = [];
+  for (const { result } of candidates) {
+    const range = normalizedLineRange(result);
+    const accepted = acceptedByFile.get(result.filePath) ?? [];
+    if (accepted.some((item) => item.start <= range.end && range.start <= item.end)) {
+      continue;
+    }
+    accepted.push(range);
+    acceptedByFile.set(result.filePath, accepted);
+    deduplicated.push(result);
+  }
+  return deduplicated;
+}
+function diversifyContextCandidates(results) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const bucket = byFile.get(result.filePath) ?? [];
+    bucket.push(result);
+    byFile.set(result.filePath, bucket);
+  }
+  const files = [...byFile.keys()];
+  const diversified = [];
+  for (let depth = 0; diversified.length < results.length; depth += 1) {
+    for (const file of files) {
+      const result = byFile.get(file)?.[depth];
+      if (result) diversified.push(result);
+    }
+  }
+  return diversified;
+}
+function compactEvidenceValue(value, maxChars) {
+  const characters = [...value];
+  if (characters.length <= maxChars) return value;
+  return `\u2026${characters.slice(-(maxChars - 1)).join("")}`;
+}
+function formatContextEvidence(result, index) {
+  const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
+  const path24 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path24}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+}
+function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount) {
+  const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
+  const notes = [];
+  if (duplicateCount > 0) notes.push(`${duplicateCount} overlapping duplicate${duplicateCount === 1 ? "" : "s"} removed`);
+  if (limitOmittedCount > 0) notes.push(`${limitOmittedCount} additional result${limitOmittedCount === 1 ? "" : "s"} excluded by result limit`);
+  if (budgetOmittedCount > 0) notes.push(`${budgetOmittedCount} additional result${budgetOmittedCount === 1 ? "" : "s"} omitted by token budget`);
+  const footer = notes.length > 0 ? `Selected ${selected.length} of ${candidateCount} candidates; ${notes.join("; ")}.` : `Selected ${selected.length} of ${candidateCount} candidates.`;
+  return `${heading}
+
+${lines.join("\n")}
+
+${footer}`;
+}
+function buildContextPack(results, options = {}) {
+  const requestedTokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  const tokenBudget = clampContextPackTokenBudget(options.tokenBudget);
+  const heading = compactEvidenceValue(options.heading?.trim() || "Codebase evidence", 160);
+  const maxResults = Math.max(0, Math.floor(options.maxResults ?? results.length));
+  const candidateCount = results.length;
+  const deduplicated = deduplicateContextCandidates(rankContextCandidates(results));
+  const diversified = diversifyContextCandidates(deduplicated);
+  const duplicateCount = candidateCount - deduplicated.length;
+  const selectable = diversified.slice(0, maxResults);
+  const limitOmittedCount = deduplicated.length - selectable.length;
+  let selected = [];
+  let text = formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, selectable.length);
+  for (let count = 1; count <= selectable.length; count += 1) {
+    const candidateSelection = selectable.slice(0, count);
+    const budgetOmittedCount2 = selectable.length - candidateSelection.length;
+    const candidateText = formatContextPack(
+      heading,
+      candidateSelection,
+      candidateCount,
+      duplicateCount,
+      limitOmittedCount,
+      budgetOmittedCount2
+    );
+    if (countContextTokens(candidateText) > tokenBudget) break;
+    selected = candidateSelection;
+    text = candidateText;
+  }
+  const fitted = fitTextToContextBudget(text, tokenBudget);
+  const budgetOmittedCount = selectable.length - selected.length;
+  const omittedCount = candidateCount - selected.length;
+  return {
+    requestedTokenBudget,
+    tokenBudget,
+    text: fitted.text,
+    tokenEstimate: fitted.tokenEstimate,
+    results: selected,
+    candidateCount,
+    deduplicatedCount: deduplicated.length,
+    selectedCount: selected.length,
+    omittedCount,
+    duplicateCount,
+    limitOmittedCount,
+    budgetOmittedCount
+  };
+}
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
   const lines = content.split("\n");
@@ -12790,6 +13446,253 @@ var pr_impact = tool({
   }
 });
 
+// src/tools/symbol-inference.ts
+var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
+var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
+var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
+var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
+var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
+var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "for",
+  "find",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "that",
+  "the",
+  "definition",
+  "show",
+  "to",
+  "where",
+  "which",
+  "what",
+  "you",
+  "your",
+  "with"
+]);
+function stripCallSuffix(token) {
+  return token.replace(/\(\s*\)$/, "");
+}
+function isLikelySymbolName(token) {
+  if (!SYMBOL_LIKE_RE.test(token)) {
+    return false;
+  }
+  if (STOP_WORDS.has(token.toLowerCase())) {
+    return false;
+  }
+  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
+}
+function extractQuotedIdentifiers(query) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function extractBareIdentifiers(query) {
+  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
+    const candidate = stripCallSuffix(match[0]);
+    if (isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function isSingleMeaningfulToken(query, symbol) {
+  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
+  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
+}
+function inferExactSymbolFromQuery(query) {
+  const quoted = extractQuotedIdentifiers(query);
+  if (quoted.length === 1) {
+    return quoted[0];
+  }
+  if (quoted.length > 1) {
+    return void 0;
+  }
+  const candidates = extractBareIdentifiers(query);
+  if (candidates.length !== 1) {
+    return void 0;
+  }
+  const candidate = candidates[0];
+  if (DEFINITION_INTENT_RE.test(query)) {
+    return candidate;
+  }
+  if (isSingleMeaningfulToken(query, candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
+
+// src/tools/context.ts
+var MIN_CONTEXT_RESULT_LIMIT = 1;
+var MAX_CONTEXT_RESULT_LIMIT = 100;
+var MIN_CONTEXT_PATH_DEPTH = 1;
+var MAX_CONTEXT_PATH_DEPTH = 100;
+function locations(results) {
+  return results.map((result) => ({
+    filePath: result.filePath,
+    startLine: result.startLine,
+    endLine: result.endLine,
+    score: result.score,
+    chunkType: result.chunkType,
+    name: result.name
+  }));
+}
+function packedResult(route, routedQuery, pack) {
+  return {
+    text: pack.text,
+    details: {
+      route,
+      routedQuery,
+      tokenBudget: pack.tokenBudget,
+      tokenEstimate: pack.tokenEstimate,
+      candidateCount: pack.candidateCount,
+      deduplicatedCount: pack.deduplicatedCount,
+      selectedCount: pack.selectedCount,
+      omittedCount: pack.omittedCount,
+      duplicateCount: pack.duplicateCount,
+      limitOmittedCount: pack.limitOmittedCount,
+      budgetOmittedCount: pack.budgetOmittedCount,
+      results: locations(pack.results)
+    }
+  };
+}
+async function resolveSearchContext(input, operations) {
+  const explicitSymbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  const lookupSymbol = explicitSymbol ?? inferExactSymbolFromQuery(input.query);
+  if (lookupSymbol) {
+    const definitions = await operations.lookup(lookupSymbol, MAX_CONTEXT_RESULT_LIMIT);
+    if (definitions.length > 0) {
+      return packedResult("definition", lookupSymbol, buildContextPack(definitions, {
+        tokenBudget,
+        maxResults: limit,
+        heading: `Definition evidence for ${JSON.stringify(lookupSymbol)}`
+      }));
+    }
+    if (explicitSymbol) {
+      const fitted = fitTextToContextBudget(
+        formatDefinitionLookup(definitions, lookupSymbol),
+        tokenBudget
+      );
+      return { text: fitted.text };
+    }
+  }
+  const results = await operations.search(input.query, MAX_CONTEXT_RESULT_LIMIT);
+  if (results.length === 0) {
+    const fitted = fitTextToContextBudget(
+      "No matching code found. Try a different query or run index_codebase first.",
+      tokenBudget
+    );
+    return { text: fitted.text };
+  }
+  return packedResult("conceptual", input.query, buildContextPack(results, {
+    tokenBudget,
+    maxResults: limit,
+    heading: `Codebase evidence for ${JSON.stringify(input.query)}`
+  }));
+}
+function fittedDetails(route, fitted) {
+  return {
+    route,
+    tokenBudget: fitted.tokenBudget,
+    tokenEstimate: fitted.tokenEstimate,
+    truncated: fitted.truncated
+  };
+}
+async function resolveCodebaseContext(projectRoot, host, input) {
+  const from = input.from ?? void 0;
+  const to = input.to ?? void 0;
+  const symbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const maxDepth = input.maxDepth ?? 10;
+  const fileType = input.fileType ?? void 0;
+  const directory = input.directory ?? void 0;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  if (from && to) {
+    const path24 = await getCallGraphPath(projectRoot, host, from, to, maxDepth);
+    if (path24.length > 0) {
+      const fitted2 = fitTextToContextBudget(
+        formatCallGraphPath(from, to, path24),
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("path", fitted2)
+      };
+    }
+    const { callers } = await getCallGraphData(projectRoot, host, {
+      name: to,
+      direction: "callers"
+    });
+    const directEdge = callers.find((edge) => edge.fromSymbolName === from);
+    if (directEdge) {
+      const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
+      const fitted2 = fitTextToContextBudget(
+        `Direct path: ${from} --${directEdge.callType}--> ${to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("direct-edge", fitted2)
+      };
+    }
+    const fitted = fitTextToContextBudget(
+      formatCallGraphPath(from, to, path24),
+      tokenBudget
+    );
+    return {
+      text: fitted.text,
+      details: fittedDetails("path", fitted)
+    };
+  }
+  return resolveSearchContext({ query: input.query, symbol, limit, tokenBudget }, {
+    lookup: (lookupSymbol, retrievalLimit) => implementationLookup(projectRoot, host, lookupSymbol, {
+      limit: retrievalLimit,
+      fileType,
+      directory
+    }),
+    search: (query, retrievalLimit) => searchCodebase(projectRoot, host, query, {
+      limit: retrievalLimit,
+      fileType,
+      directory,
+      metadataOnly: true
+    })
+  });
+}
+
 // src/tools/index.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 import * as os5 from "os";
@@ -13521,6 +14424,23 @@ function initializeTools2(projectRoot, config) {
 function getIndexerForProject2(directory) {
   return getIndexerForProject(directory, DEFAULT_HOST);
 }
+var codebase_context = tool2({
+  description: "PREFERRED FIRST TOOL for repository questions. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Provide from and to for dependency paths, symbol for definitions, or only query for conceptual discovery.",
+  args: {
+    query: z2.string().describe("The repository question or behavior to locate"),
+    from: z2.string().nullable().optional().describe("Source symbol for a dependency path"),
+    to: z2.string().nullable().optional().describe("Target symbol for a dependency path"),
+    symbol: z2.string().nullable().optional().describe("Exact symbol for authoritative definition lookup"),
+    limit: z2.number().int().min(MIN_CONTEXT_RESULT_LIMIT).max(MAX_CONTEXT_RESULT_LIMIT).nullable().optional().default(10).describe(`Maximum number of results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})`),
+    maxDepth: z2.number().int().min(MIN_CONTEXT_PATH_DEPTH).max(MAX_CONTEXT_PATH_DEPTH).nullable().optional().default(10).describe(`Maximum call-path traversal depth (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})`),
+    fileType: z2.string().nullable().optional().describe("Filter by file extension"),
+    directory: z2.string().nullable().optional().describe("Filter by directory path"),
+    tokenBudget: z2.number().int().min(MIN_CONTEXT_PACK_TOKEN_BUDGET).max(MAX_CONTEXT_PACK_TOKEN_BUDGET).nullable().optional().default(DEFAULT_CONTEXT_PACK_TOKEN_BUDGET).describe(`Maximum response tokens (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`)
+  },
+  async execute(args, context) {
+    return (await resolveCodebaseContext(context?.worktree, DEFAULT_HOST, args)).text;
+  }
+});
 var codebase_peek = tool2({
   description: "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Use this first to find WHERE code is, then use Read tool to examine specific files. Saves tokens by not returning full code blocks. Best for: discovery, navigation, finding multiple related locations.",
   args: {
@@ -14203,6 +15123,7 @@ var plugin = async ({ directory, worktree }) => {
     }
     return {
       tool: {
+        codebase_context,
         codebase_search,
         codebase_peek,
         index_codebase,