opencode-codebase-index 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -857,7 +857,32 @@ function parseConfig(raw) {
   };
   let embeddingProvider;
   let embeddingModel = void 0;
-  if (isValidProvider(input.embeddingProvider)) {
+  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];
@@ -868,6 +893,7 @@ function parseConfig(raw) {
   return {
     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,
@@ -2033,12 +2059,39 @@ 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
+var CustomProviderNonRetryableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomProviderNonRetryableError";
+  }
+};
 function createEmbeddingProvider(configuredProviderInfo) {
   switch (configuredProviderInfo.provider) {
     case "github-copilot":
@@ -2049,6 +2102,8 @@ function createEmbeddingProvider(configuredProviderInfo) {
       return new GoogleEmbeddingProvider(configuredProviderInfo.credentials, configuredProviderInfo.modelInfo);
     case "ollama":
       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}`);
@@ -2283,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);
@@ -3468,19 +3607,33 @@ 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() {
-    if (this.config.embeddingProvider === "auto") {
+    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", {
@@ -3490,9 +3643,6 @@ var Indexer = class {
     });
     this.provider = createEmbeddingProvider(this.configuredProviderInfo);
     await import_fs4.promises.mkdir(this.indexPath, { recursive: true });
-    if (this.checkForInterruptedIndexing()) {
-      await this.recoverFromInterruptedIndexing();
-    }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
     const storePath = path5.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
@@ -3513,6 +3663,9 @@ 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();
     }
@@ -3933,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)) {