opencode-codebase-index 0.4.1 → 0.5.1

package/dist/index.cjs

@@ -662,7 +662,7 @@ var path8 = __toESM(require("path"), 1);
 var os3 = __toESM(require("os"), 1);
 var import_url2 = require("url");
 
-// src/config/schema.ts
+// src/config/constants.ts
 var DEFAULT_INCLUDE = [
   "**/*.{ts,tsx,js,jsx,mjs,cjs}",
   "**/*.{py,pyi}",
@@ -690,6 +690,80 @@ var DEFAULT_EXCLUDE = [
   "**/.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,
@@ -726,11 +800,13 @@ function getDefaultDebugConfig() {
     metrics: true
   };
 }
-var VALID_PROVIDERS = ["auto", "github-copilot", "openai", "google", "ollama"];
 var VALID_SCOPES = ["project", "global"];
 var VALID_LOG_LEVELS = ["error", "warn", "info", "debug"];
 function isValidProvider(value) {
-  return typeof value === "string" && VALID_PROVIDERS.includes(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);
@@ -779,9 +855,45 @@ function parseConfig(raw) {
     logBranch: typeof rawDebug.logBranch === "boolean" ? rawDebug.logBranch : defaultDebug.logBranch,
     metrics: typeof rawDebug.metrics === "boolean" ? rawDebug.metrics : defaultDebug.metrics
   };
+  let embeddingProvider;
+  let embeddingModel = void 0;
+  let customProvider = void 0;
+  if (input.embeddingProvider === "custom") {
+    embeddingProvider = "custom";
+    const rawCustom = input.customProvider && typeof input.customProvider === "object" ? input.customProvider : null;
+    if (rawCustom && typeof rawCustom.baseUrl === "string" && rawCustom.baseUrl.trim().length > 0 && typeof rawCustom.model === "string" && rawCustom.model.trim().length > 0 && typeof rawCustom.dimensions === "number" && Number.isInteger(rawCustom.dimensions) && rawCustom.dimensions > 0) {
+      customProvider = {
+        baseUrl: rawCustom.baseUrl.trim().replace(/\/+$/, ""),
+        model: rawCustom.model,
+        dimensions: rawCustom.dimensions,
+        apiKey: typeof rawCustom.apiKey === "string" ? rawCustom.apiKey : void 0,
+        maxTokens: typeof rawCustom.maxTokens === "number" ? rawCustom.maxTokens : void 0,
+        timeoutMs: typeof rawCustom.timeoutMs === "number" ? Math.max(1e3, rawCustom.timeoutMs) : void 0,
+        concurrency: typeof rawCustom.concurrency === "number" ? Math.max(1, Math.floor(rawCustom.concurrency)) : void 0,
+        requestIntervalMs: typeof rawCustom.requestIntervalMs === "number" ? Math.max(0, Math.floor(rawCustom.requestIntervalMs)) : void 0
+      };
+      if (!/\/v\d+\/?$/.test(customProvider.baseUrl)) {
+        console.warn(
+          `[codebase-index] Warning: customProvider.baseUrl ("${customProvider.baseUrl}") does not end with an API version path like /v1. The plugin appends /embeddings automatically, so the full URL will be "${customProvider.baseUrl}/embeddings". If your provider expects /v1/embeddings, set baseUrl to "${customProvider.baseUrl}/v1".`
+        );
+      }
+    } else {
+      throw new Error(
+        "embeddingProvider is 'custom' but customProvider config is missing or invalid. Required fields: baseUrl (string), model (string), dimensions (positive integer)."
+      );
+    }
+  } else 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: isValidProvider(input.embeddingProvider) ? input.embeddingProvider : "auto",
-    embeddingModel: typeof input.embeddingModel === "string" ? input.embeddingModel : "auto",
+    embeddingProvider,
+    embeddingModel,
+    customProvider,
     scope: isValidScope(input.scope) ? input.scope : "project",
     include: isStringArray(input.include) ? input.include : DEFAULT_INCLUDE,
     exclude: isStringArray(input.exclude) ? input.exclude : DEFAULT_EXCLUDE,
@@ -790,64 +902,12 @@ function parseConfig(raw) {
     debug
   };
 }
-var EMBEDDING_MODELS = {
-  "github-copilot/text-embedding-3-small": {
-    provider: "github-copilot",
-    model: "text-embedding-3-small",
-    dimensions: 1536,
-    maxTokens: 8191,
-    costPer1MTokens: 0
-  },
-  "openai/text-embedding-3-small": {
-    provider: "openai",
-    model: "text-embedding-3-small",
-    dimensions: 1536,
-    maxTokens: 8191,
-    costPer1MTokens: 0.02
-  },
-  "openai/text-embedding-3-large": {
-    provider: "openai",
-    model: "text-embedding-3-large",
-    dimensions: 3072,
-    maxTokens: 8191,
-    costPer1MTokens: 0.13
-  },
-  "google/text-embedding-004": {
-    provider: "google",
-    model: "text-embedding-004",
-    dimensions: 768,
-    maxTokens: 2048,
-    costPer1MTokens: 0
-  },
-  "ollama/nomic-embed-text": {
-    provider: "ollama",
-    model: "nomic-embed-text",
-    dimensions: 768,
-    maxTokens: 8192,
-    costPer1MTokens: 0
-  },
-  "ollama/mxbai-embed-large": {
-    provider: "ollama",
-    model: "mxbai-embed-large",
-    dimensions: 1024,
-    maxTokens: 512,
-    costPer1MTokens: 0
-  }
-};
 function getDefaultModelForProvider(provider) {
-  switch (provider) {
-    case "github-copilot":
-      return EMBEDDING_MODELS["github-copilot/text-embedding-3-small"];
-    case "openai":
-      return EMBEDDING_MODELS["openai/text-embedding-3-small"];
-    case "google":
-      return EMBEDDING_MODELS["google/text-embedding-004"];
-    case "ollama":
-      return EMBEDDING_MODELS["ollama/nomic-embed-text"];
-    default:
-      return EMBEDDING_MODELS["github-copilot/text-embedding-3-small"];
-  }
+  const models = EMBEDDING_MODELS[provider];
+  const providerDefault = DEFAULT_PROVIDER_MODELS[provider];
+  return models[providerDefault];
 }
+var availableProviders = Object.keys(EMBEDDING_MODELS);
 
 // src/indexer/index.ts
 var import_fs4 = require("fs");
@@ -876,7 +936,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve4, reject) => {
+  const wrappedPromise = new Promise((resolve5, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -890,7 +950,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve4, reject);
+    promise.then(resolve5, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -898,7 +958,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve4(fallback());
+          resolve5(fallback());
         } catch (error) {
           reject(error);
         }
@@ -908,7 +968,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve4();
+        resolve5();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1298,7 +1358,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
@@ -1336,7 +1396,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve4(result);
+          resolve5(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1493,13 +1553,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve4();
+        resolve5();
       };
       this.on(event, listener);
     });
@@ -1784,7 +1844,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -1792,7 +1852,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve4();
+        resolve5();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -1856,12 +1916,6 @@ async function pRetry(input, options = {}) {
 var import_fs = require("fs");
 var path = __toESM(require("path"), 1);
 var os = __toESM(require("os"), 1);
-var EMBEDDING_CAPABLE_PROVIDERS = [
-  "github-copilot",
-  "openai",
-  "google",
-  "ollama"
-];
 function getOpenCodeAuthPath() {
   return path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
 }
@@ -1875,21 +1929,34 @@ function loadOpenCodeAuth() {
   }
   return {};
 }
-async function detectEmbeddingProvider(preferredProvider) {
-  if (preferredProvider && preferredProvider !== "auto") {
-    const credentials = await getProviderCredentials(preferredProvider);
-    if (credentials) {
+async function detectEmbeddingProvider(preferredProvider, model) {
+  const credentials = await getProviderCredentials(preferredProvider);
+  if (credentials) {
+    if (!model) {
       return {
         provider: preferredProvider,
         credentials,
         modelInfo: getDefaultModelForProvider(preferredProvider)
       };
     }
-    throw new Error(
-      `Preferred provider '${preferredProvider}' is not configured or authenticated`
-    );
+    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]
+    };
   }
-  for (const provider of EMBEDDING_CAPABLE_PROVIDERS) {
+  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 {
@@ -1900,7 +1967,7 @@ async function detectEmbeddingProvider(preferredProvider) {
     }
   }
   throw new Error(
-    `No embedding-capable provider found. Please authenticate with OpenCode using one of: ${EMBEDDING_CAPABLE_PROVIDERS.join(", ")}.`
+    `No embedding-capable provider found. Please authenticate with OpenCode using one of: ${availableProviders.join(", ")}.`
   );
 }
 async function getProviderCredentials(provider) {
@@ -1992,24 +2059,55 @@ function getProviderDisplayName(provider) {
       return "Google (Gemini)";
     case "ollama":
       return "Ollama (Local)";
+    case "custom":
+      return "Custom (OpenAI-compatible)";
     default:
       return provider;
   }
 }
+function createCustomProviderInfo(config) {
+  const baseUrl = config.baseUrl.replace(/\/+$/, "");
+  return {
+    provider: "custom",
+    credentials: {
+      provider: "custom",
+      baseUrl,
+      apiKey: config.apiKey
+    },
+    modelInfo: {
+      provider: "custom",
+      model: config.model,
+      dimensions: config.dimensions,
+      maxTokens: config.maxTokens ?? 8192,
+      costPer1MTokens: 0,
+      timeoutMs: config.timeoutMs ?? 3e4
+    }
+  };
+}
 
 // src/embeddings/provider.ts
-function createEmbeddingProvider(credentials, modelInfo) {
-  switch (credentials.provider) {
+var CustomProviderNonRetryableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomProviderNonRetryableError";
+  }
+};
+function createEmbeddingProvider(configuredProviderInfo) {
+  switch (configuredProviderInfo.provider) {
     case "github-copilot":
-      return new GitHubCopilotEmbeddingProvider(credentials, modelInfo);
+      return new GitHubCopilotEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "openai":
-      return new OpenAIEmbeddingProvider(credentials, modelInfo);
+      return new OpenAIEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "google":
-      return new GoogleEmbeddingProvider(credentials, modelInfo);
+      return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "ollama":
-      return new OllamaEmbeddingProvider(credentials, modelInfo);
-    default:
-      throw new Error(`Unsupported embedding provider: ${credentials.provider}`);
+      return new OllamaEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    case "custom":
+      return new CustomEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
+    default: {
+      const _exhaustive = configuredProviderInfo;
+      throw new Error(`Unsupported embedding provider: ${_exhaustive.provider}`);
+    }
   }
 }
 var GitHubCopilotEmbeddingProvider = class {
@@ -2023,8 +2121,15 @@ var GitHubCopilotEmbeddingProvider = class {
     }
     return this.credentials.refreshToken;
   }
-  async embed(text) {
-    const result = await this.embedBatch([text]);
+  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
@@ -2064,8 +2169,15 @@ var OpenAIEmbeddingProvider = class {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  async embed(text) {
-    const result = await this.embedBatch([text]);
+  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
@@ -2097,33 +2209,61 @@ var OpenAIEmbeddingProvider = class {
     return this.modelInfo;
   }
 };
-var GoogleEmbeddingProvider = class {
+var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider {
   constructor(credentials, modelInfo) {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  async embed(text) {
-    const result = await this.embedBatch([text]);
+  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 results = await Promise.all(
-      texts.map(async (text) => {
+    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}:embedContent?key=${this.credentials.apiKey}`,
+          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:batchEmbedContents?key=${this.credentials.apiKey}`,
           {
             method: "POST",
             headers: {
               "Content-Type": "application/json"
             },
-            body: JSON.stringify({
-              content: {
-                parts: [{ text }]
-              }
-            })
+            body: JSON.stringify({ requests })
           }
         );
         if (!response.ok) {
@@ -2132,14 +2272,14 @@ var GoogleEmbeddingProvider = class {
         }
         const data = await response.json();
         return {
-          embedding: data.embedding.values,
-          tokensUsed: Math.ceil(text.length / 4)
+          embeddings: data.embeddings.map((e) => e.values),
+          tokensUsed: batch.reduce((sum, text) => sum + Math.ceil(text.length / 4), 0)
         };
       })
     );
     return {
-      embeddings: results.map((r) => r.embedding),
-      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
+      embeddings: batchResults.flatMap((r) => r.embeddings),
+      totalTokensUsed: batchResults.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
   getModelInfo() {
@@ -2151,29 +2291,44 @@ var OllamaEmbeddingProvider = class {
     this.credentials = credentials;
     this.modelInfo = modelInfo;
   }
-  async embed(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();
+  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: data.embedding,
-      tokensUsed: Math.ceil(text.length / 4)
+      embedding: result.embeddings[0],
+      tokensUsed: result.totalTokensUsed
     };
   }
   async embedBatch(texts) {
-    const results = await Promise.all(texts.map((text) => this.embed(text)));
+    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)
@@ -2183,6 +2338,90 @@ var OllamaEmbeddingProvider = class {
     return this.modelInfo;
   }
 };
+var CustomEmbeddingProvider = 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 headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.credentials.apiKey) {
+      headers["Authorization"] = `Bearer ${this.credentials.apiKey}`;
+    }
+    const baseUrl = this.credentials.baseUrl ?? "";
+    const timeoutMs = this.modelInfo.timeoutMs;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(`${baseUrl}/embeddings`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          input: texts
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Custom embedding API request timed out after ${timeoutMs}ms for ${baseUrl}/embeddings`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+        throw new CustomProviderNonRetryableError(`Custom embedding API error (non-retryable): ${response.status} - ${errorText}`);
+      }
+      throw new Error(`Custom embedding API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data)) {
+      if (data.data.length > 0) {
+        const actualDims = data.data[0].embedding.length;
+        if (actualDims !== this.modelInfo.dimensions) {
+          throw new Error(
+            `Dimension mismatch: customProvider.dimensions is ${this.modelInfo.dimensions}, but the API returned vectors with ${actualDims} dimensions. Update your config to match the model's actual output dimensions.`
+          );
+        }
+      }
+      if (data.data.length !== texts.length) {
+        throw new Error(
+          `Embedding count mismatch: sent ${texts.length} texts but received ${data.data.length} embeddings. The custom embedding server may not support batch input.`
+        );
+      }
+      return {
+        embeddings: data.data.map((d) => d.embedding),
+        // Rough estimate: ~4 chars per token. Used as fallback when the server
+        // doesn't return usage.total_tokens (e.g. llama.cpp, some vLLM configs).
+        totalTokensUsed: data.usage?.total_tokens ?? texts.reduce((sum, t) => sum + Math.ceil(t.length / 4), 0)
+      };
+    }
+    throw new Error("Custom embedding API returned unexpected response format. Expected OpenAI-compatible format with data[].embedding.");
+  }
+  getModelInfo() {
+    return this.modelInfo;
+  }
+};
 
 // src/utils/files.ts
 var import_ignore = __toESM(require_ignore(), 1);
@@ -3118,11 +3357,40 @@ var Database = class {
 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 stat4 = (0, import_fs3.statSync)(gitPath);
+    if (stat4.isDirectory()) {
+      return gitPath;
+    }
+    if (stat4.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 (0, import_fs3.existsSync)(path4.join(dir, ".git"));
+  return resolveGitDir(dir) !== null;
 }
 function getCurrentBranch(repoRoot) {
-  const headPath = path4.join(repoRoot, ".git", "HEAD");
+  const gitDir = resolveGitDir(repoRoot);
+  if (!gitDir) {
+    return null;
+  }
+  const headPath = path4.join(gitDir, "HEAD");
   if (!(0, import_fs3.existsSync)(headPath)) {
     return null;
   }
@@ -3141,20 +3409,23 @@ function getCurrentBranch(repoRoot) {
   }
 }
 function getBaseBranch(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
   const candidates = ["main", "master", "develop", "trunk"];
-  for (const candidate of candidates) {
-    const refPath = path4.join(repoRoot, ".git", "refs", "heads", candidate);
-    if ((0, import_fs3.existsSync)(refPath)) {
-      return candidate;
-    }
-    const packedRefsPath = path4.join(repoRoot, ".git", "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;
+  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 {
         }
-      } catch {
       }
     }
   }
@@ -3179,6 +3450,10 @@ function getBranchOrDefault(repoRoot) {
   return getCurrentBranch(repoRoot) ?? "default";
 }
 function getHeadPath(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (gitDir) {
+    return path4.join(gitDir, "HEAD");
+  }
   return path4.join(repoRoot, ".git", "HEAD");
 }
 
@@ -3206,6 +3481,7 @@ 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;
@@ -3214,7 +3490,7 @@ var Indexer = class {
   invertedIndex = null;
   database = null;
   provider = null;
-  detectedProvider = null;
+  configuredProviderInfo = null;
   fileHashCache = /* @__PURE__ */ new Map();
   fileHashCachePath = "";
   failedBatchesPath = "";
@@ -3225,12 +3501,15 @@ var Indexer = class {
   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() {
@@ -3256,7 +3535,36 @@ var Indexer = class {
     for (const [k, v] of this.fileHashCache) {
       obj[k] = v;
     }
-    (0, import_fs4.writeFileSync)(this.fileHashCachePath, JSON.stringify(obj));
+    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 {
@@ -3299,28 +3607,43 @@ var Indexer = class {
         return { concurrency: 5, intervalMs: 200, minRetryMs: 1e3, maxRetryMs: 3e4 };
       case "ollama":
         return { concurrency: 5, intervalMs: 0, minRetryMs: 500, maxRetryMs: 5e3 };
+      case "custom": {
+        const customConfig = this.config.customProvider;
+        return {
+          concurrency: customConfig?.concurrency ?? 3,
+          intervalMs: customConfig?.requestIntervalMs ?? 1e3,
+          minRetryMs: 1e3,
+          maxRetryMs: 3e4
+        };
+      }
       default:
         return { concurrency: 3, intervalMs: 1e3, minRetryMs: 1e3, maxRetryMs: 3e4 };
     }
   }
   async initialize() {
-    this.detectedProvider = await detectEmbeddingProvider(this.config.embeddingProvider);
-    if (!this.detectedProvider) {
+    if (this.config.embeddingProvider === "custom") {
+      if (!this.config.customProvider) {
+        throw new Error("embeddingProvider is 'custom' but customProvider config is missing.");
+      }
+      this.configuredProviderInfo = createCustomProviderInfo(this.config.customProvider);
+    } else 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."
+        "No embedding provider available. Configure GitHub Copilot, OpenAI, Google, Ollama, or a custom OpenAI-compatible endpoint."
       );
     }
     this.logger.info("Initializing indexer", {
-      provider: this.detectedProvider.provider,
-      model: this.detectedProvider.modelInfo.model,
+      provider: this.configuredProviderInfo.provider,
+      model: this.configuredProviderInfo.modelInfo.model,
       scope: this.config.scope
     });
-    this.provider = createEmbeddingProvider(
-      this.detectedProvider.credentials,
-      this.detectedProvider.modelInfo
-    );
+    this.provider = createEmbeddingProvider(this.configuredProviderInfo);
     await import_fs4.promises.mkdir(this.indexPath, { recursive: true });
-    const dimensions = this.detectedProvider.modelInfo.dimensions;
+    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");
@@ -3340,9 +3663,20 @@ var Indexer = class {
     const dbPath = path5.join(this.indexPath, "codebase.db");
     const dbIsNew = !(0, import_fs4.existsSync)(dbPath);
     this.database = new Database(dbPath);
+    if (this.checkForInterruptedIndexing()) {
+      await this.recoverFromInterruptedIndexing();
+    }
     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);
@@ -3413,30 +3747,106 @@ var Indexer = class {
     }
     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.detectedProvider || !this.database) {
+    if (!this.store || !this.provider || !this.invertedIndex || !this.configuredProviderInfo || !this.database) {
       await this.initialize();
     }
     return {
       store: this.store,
       provider: this.provider,
       invertedIndex: this.invertedIndex,
-      detectedProvider: this.detectedProvider,
+      configuredProviderInfo: this.configuredProviderInfo,
       database: this.database
     };
   }
   async estimateCost() {
-    const { detectedProvider } = await this.ensureInitialized();
+    const { configuredProviderInfo } = await this.ensureInitialized();
     const { files } = await collectFiles(
       this.projectRoot,
       this.config.include,
       this.config.exclude,
       this.config.indexing.maxFileSize
     );
-    return createCostEstimate(files, detectedProvider);
+    return createCostEstimate(files, configuredProviderInfo);
   }
   async index(onProgress) {
-    const { store, provider, invertedIndex, database, detectedProvider } = await this.ensureInitialized();
+    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();
@@ -3543,7 +3953,7 @@ var Indexer = class {
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
         currentChunkIds.add(id);
-        const chunkData = {
+        chunkDataBatch.push({
           chunkId: id,
           contentHash,
           filePath: parsed.path,
@@ -3552,8 +3962,7 @@ var Indexer = class {
           nodeType: chunk.chunkType,
           name: chunk.name,
           language: chunk.language
-        };
-        chunkDataBatch.push(chunkData);
+        });
         if (existingChunks.get(id) === contentHash) {
           fileChunkCount++;
           continue;
@@ -3606,6 +4015,7 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
+      this.releaseIndexingLock();
       return stats;
     }
     if (pendingChunks.length === 0) {
@@ -3623,6 +4033,7 @@ var Indexer = class {
         chunksProcessed: 0,
         totalChunks: 0
       });
+      this.releaseIndexingLock();
       return stats;
     }
     onProgress?.({
@@ -3651,7 +4062,7 @@ var Indexer = class {
         stats.indexedChunks++;
       }
     }
-    const providerRateLimits = this.getProviderRateLimits(detectedProvider.provider);
+    const providerRateLimits = this.getProviderRateLimits(configuredProviderInfo.provider);
     const queue = new PQueue({
       concurrency: providerRateLimits.concurrency,
       interval: providerRateLimits.intervalMs,
@@ -3662,7 +4073,7 @@ var Indexer = class {
     for (const batch of dynamicBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve4) => setTimeout(resolve4, rateLimitBackoffMs));
+          await new Promise((resolve5) => setTimeout(resolve5, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -3675,6 +4086,7 @@ var Indexer = class {
               minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
               maxTimeout: providerRateLimits.maxRetryMs,
               factor: 2,
+              shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError),
               onFailedAttempt: (error) => {
                 const message = getErrorMessage(error);
                 if (isRateLimitError(error)) {
@@ -3706,7 +4118,7 @@ var Indexer = class {
             contentHash: chunk.contentHash,
             embedding: float32ArrayToBuffer(result.embeddings[i]),
             chunkText: chunk.text,
-            model: detectedProvider.modelInfo.model
+            model: configuredProviderInfo.modelInfo.model
           }));
           database.upsertEmbeddingsBatch(embeddingBatchItems);
           for (const chunk of batch) {
@@ -3757,6 +4169,8 @@ var Indexer = class {
       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,
@@ -3777,6 +4191,7 @@ var Indexer = class {
       chunksProcessed: stats.indexedChunks,
       totalChunks: pendingChunks.length
     });
+    this.releaseIndexingLock();
     return stats;
   }
   async getQueryEmbedding(query, provider) {
@@ -3799,7 +4214,7 @@ var Indexer = class {
     }
     this.logger.cache("debug", "Query embedding cache miss", { query: query.slice(0, 50) });
     this.logger.recordQueryCacheMiss();
-    const { embedding, tokensUsed } = await provider.embed(query);
+    const { embedding, tokensUsed } = await provider.embedQuery(query);
     this.logger.recordEmbeddingApiCall(tokensUsed);
     if (this.queryEmbeddingCache.size >= this.maxQueryCacheSize) {
       const oldestKey = this.queryEmbeddingCache.keys().next().value;
@@ -3842,8 +4257,14 @@ var Indexer = class {
     return intersection / union;
   }
   async search(query, limit, options) {
-    const searchStartTime = import_perf_hooks.performance.now();
     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 [];
@@ -3985,15 +4406,16 @@ var Indexer = class {
     return results.slice(0, limit);
   }
   async getStatus() {
-    const { store, detectedProvider } = await this.ensureInitialized();
+    const { store, configuredProviderInfo } = await this.ensureInitialized();
     return {
       indexed: store.count() > 0,
       vectorCount: store.count(),
-      provider: detectedProvider.provider,
-      model: detectedProvider.modelInfo.model,
+      provider: configuredProviderInfo.provider,
+      model: configuredProviderInfo.modelInfo.model,
       indexPath: this.indexPath,
       currentBranch: this.currentBranch,
-      baseBranch: this.baseBranch
+      baseBranch: this.baseBranch,
+      compatibility: this.indexCompatibility
     };
   }
   async clearIndex() {
@@ -4005,6 +4427,13 @@ var Indexer = class {
     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();
@@ -4118,26 +4547,31 @@ var Indexer = class {
   getLogger() {
     return this.logger;
   }
-  async findSimilar(code, limit, options) {
-    const searchStartTime = import_perf_hooks.performance.now();
+  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 maxResults = limit ?? this.config.search.maxResults;
     const filterByBranch = options?.filterByBranch ?? true;
     this.logger.search("debug", "Starting find similar", {
       codeLength: code.length,
-      maxResults,
+      limit,
       filterByBranch
     });
     const embeddingStartTime = import_perf_hooks.performance.now();
-    const { embedding, tokensUsed } = await provider.embed(code);
+    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, maxResults * 2);
+    const semanticResults = store.search(embedding, limit * 2);
     const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
     let branchChunkIds = null;
     if (filterByBranch && this.currentBranch !== "default") {
@@ -4161,7 +4595,7 @@ var Indexer = class {
         if (r.metadata.chunkType !== options.chunkType) return false;
       }
       return true;
-    }).slice(0, maxResults);
+    }).slice(0, limit);
     const totalSearchMs = import_perf_hooks.performance.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {
       embeddingMs,
@@ -5076,7 +5510,7 @@ var NodeFsHandler = class {
         this._addToNodeFs(path9, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -5085,7 +5519,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve4(void 0);
+        resolve5(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -6132,7 +6566,8 @@ function createWatcherWithIndexer(indexer, projectRoot, config) {
 
 // src/tools/index.ts
 var import_plugin = require("@opencode-ai/plugin");
-var z = import_plugin.tool.schema;
+
+// src/tools/utils.ts
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
   const lines = content.split("\n");
@@ -6140,49 +6575,177 @@ function truncateContent(content) {
   return lines.slice(0, MAX_CONTENT_LINES).join("\n") + `
 // ... (${lines.length - MAX_CONTENT_LINES} more lines)`;
 }
-var sharedIndexer = null;
-function initializeTools(projectRoot, config) {
-  sharedIndexer = new Indexer(projectRoot, config);
-}
-function getIndexer() {
-  if (!sharedIndexer) {
-    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
-  }
-  return sharedIndexer;
-}
-var codebase_search = (0, import_plugin.tool)({
-  description: "Search codebase by MEANING, not keywords. Returns full code content. Use when you need to see actual implementation. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead. For known identifiers like 'validateToken', use grep - it's faster.",
-  args: {
-    query: z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
-    limit: z.number().optional().default(5).describe("Maximum number of results to return"),
-    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
-    contextLines: z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
-  },
-  async execute(args) {
-    const indexer = getIndexer();
-    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 "No matching code found. Try a different query or run index_codebase first.";
+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 main = `Indexed. ${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
+    if (stats.existingChunks > 0) {
+      main += ` ${stats.existingChunks} unchanged chunks skipped.`;
     }
-    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)})
+    lines.push(main);
+    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}`);
+  }
+  if (status.compatibility && !status.compatibility.compatible) {
+    lines.push("");
+    lines.push(`COMPATIBILITY WARNING: ${status.compatibility.reason}`);
+    if (status.compatibility.storedMetadata) {
+      const stored = status.compatibility.storedMetadata;
+      lines.push(`  Index was built with: ${stored.embeddingProvider}/${stored.embeddingModel} (${stored.embeddingDimensions}D)`);
+      lines.push(`  Current config:       ${status.provider}/${status.model}`);
+    }
+  } else if (!status.compatibility) {
+    lines.push(`  Compatibility: No compatibility information found. Maybe the index is not initialized yet, try running index_codebase.`);
+  } else {
+    lines.push(`  Compatibility: Index is compatible with the current provider and model.`);
+  }
+  return lines.join("\n");
+}
+function formatProgressTitle(progress) {
+  switch (progress.phase) {
+    case "scanning":
+      return "Scanning files...";
+    case "parsing":
+      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
+    case "embedding":
+      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
+    case "storing":
+      return "Storing index...";
+    case "complete":
+      return "Indexing complete";
+    default:
+      return "Indexing...";
+  }
+}
+function calculatePercentage(progress) {
+  if (progress.phase === "scanning") return 0;
+  if (progress.phase === "complete") return 100;
+  if (progress.phase === "parsing") {
+    if (progress.totalFiles === 0) return 5;
+    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
+  }
+  if (progress.phase === "embedding") {
+    if (progress.totalChunks === 0) return 20;
+    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
+  }
+  if (progress.phase === "storing") return 95;
+  return 0;
+}
+function formatCodebasePeek(results, query) {
+  if (results.length === 0) {
+    return "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 `Found ${results.length} locations for "${query}":
+
+${formatted.join("\n")}
+
+Use Read tool to examine specific files.`;
+}
+function formatHealthCheck(result) {
+  if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0) {
+    return "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 lines.join("\n");
+}
+function formatLogs(logs) {
+  if (logs.length === 0) {
+    return "No logs recorded yet. Logs are captured during indexing and search operations.";
+  }
+  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");
+}
+function formatSearchResults(results, scoreFormat = "similarity") {
+  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}`;
+    const scoreLabel = scoreFormat === "similarity" ? `(similarity: ${(r.score * 100).toFixed(1)}%)` : `(score: ${r.score.toFixed(2)})`;
+    return `${header} ${scoreLabel}
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
-    });
-    return `Found ${results.length} results for "${args.query}":
+  });
+  return formatted.join("\n\n");
+}
 
-${formatted.join("\n\n")}`;
+// src/tools/index.ts
+var z = import_plugin.tool.schema;
+var sharedIndexer = null;
+function initializeTools(projectRoot, config) {
+  sharedIndexer = new Indexer(projectRoot, config);
+}
+function getIndexer() {
+  if (!sharedIndexer) {
+    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
   }
-});
+  return sharedIndexer;
+}
 var codebase_peek = (0, import_plugin.tool)({
   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: {
@@ -6200,19 +6763,7 @@ var codebase_peek = (0, import_plugin.tool)({
       chunkType: args.chunkType,
       metadataOnly: true
     });
-    if (results.length === 0) {
-      return "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 `Found ${results.length} locations for "${args.query}":
-
-${formatted.join("\n")}
-
-Use Read tool to examine specific files.`;
+    return formatCodebasePeek(results, args.query);
   }
 });
 var index_codebase = (0, import_plugin.tool)({
@@ -6262,23 +6813,7 @@ var index_health_check = (0, import_plugin.tool)({
   async execute() {
     const indexer = getIndexer();
     const result = await indexer.healthCheck();
-    if (result.removed === 0 && result.gcOrphanEmbeddings === 0 && result.gcOrphanChunks === 0) {
-      return "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 lines.join("\n");
+    return formatHealthCheck(result);
   }
 });
 var index_metrics = (0, import_plugin.tool)({
@@ -6317,13 +6852,7 @@ var index_logs = (0, import_plugin.tool)({
     } else {
       logs = logger.getLogs(args.limit);
     }
-    if (logs.length === 0) {
-      return "No logs recorded yet. Logs are captured during indexing and search operations.";
-    }
-    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");
+    return formatLogs(logs);
   }
 });
 var find_similar = (0, import_plugin.tool)({
@@ -6338,7 +6867,7 @@ var find_similar = (0, import_plugin.tool)({
   },
   async execute(args) {
     const indexer = getIndexer();
-    const results = await indexer.findSimilar(args.code, args.limit ?? 10, {
+    const results = await indexer.findSimilar(args.code, args.limit, {
       fileType: args.fileType,
       directory: args.directory,
       chunkType: args.chunkType,
@@ -6347,109 +6876,37 @@ var find_similar = (0, import_plugin.tool)({
     if (results.length === 0) {
       return "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 `Found ${results.length} similar code blocks:
 
-${formatted.join("\n\n")}`;
+${formatSearchResults(results)}`;
   }
 });
-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 main = `Indexed. ${stats.totalFiles} files processed, ${stats.indexedChunks} new chunks embedded.`;
-    if (stats.existingChunks > 0) {
-      main += ` ${stats.existingChunks} unchanged chunks skipped.`;
-    }
-    lines.push(main);
-    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 ? "..." : ""}`);
+var codebase_search = (0, import_plugin.tool)({
+  description: "Search codebase by MEANING, not keywords. Returns full code content. Use when you need to see actual implementation. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead. For known identifiers like 'validateToken', use grep - it's faster.",
+  args: {
+    query: z.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
+    limit: z.number().optional().default(5).describe("Maximum number of results to return"),
+    fileType: z.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z.enum(["function", "class", "method", "interface", "type", "enum", "struct", "impl", "trait", "module", "other"]).optional().describe("Filter by code chunk type"),
+    contextLines: z.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
+  },
+  async execute(args) {
+    const indexer = getIndexer();
+    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 "No matching code found. Try a different query or run index_codebase first.";
     }
+    return `Found ${results.length} results for "${args.query}":
+
+${formatSearchResults(results, "score")}`;
   }
-  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");
-}
-function formatProgressTitle(progress) {
-  switch (progress.phase) {
-    case "scanning":
-      return "Scanning files...";
-    case "parsing":
-      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
-    case "embedding":
-      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
-    case "storing":
-      return "Storing index...";
-    case "complete":
-      return "Indexing complete";
-    default:
-      return "Indexing...";
-  }
-}
-function calculatePercentage(progress) {
-  if (progress.phase === "scanning") return 0;
-  if (progress.phase === "complete") return 100;
-  if (progress.phase === "parsing") {
-    if (progress.totalFiles === 0) return 5;
-    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
-  }
-  if (progress.phase === "embedding") {
-    if (progress.totalChunks === 0) return 20;
-    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
-  }
-  if (progress.phase === "storing") return 95;
-  return 0;
-}
+});
 
 // src/commands/loader.ts
 var import_fs5 = require("fs");