@javierkaiser/opencode-indexing 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,104 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-14
+
+### Added
+
+- **`gemini`, `voyage` and `openrouter` are implemented.** They were selectable in
+  the provider list, passed every validation gate, and then threw
+  `Unsupported embedder provider` once indexing had already started and been billed
+  for a probe. A test asserted that they were unimplemented, which pinned the gap in
+  place.
+- **The model catalog is visible.** The TUI model field is now a chooser built from
+  the catalog, with a *Custom* entry for anything not listed and for providers with
+  no catalog at all. `indexing_config` lists every model with its dimension and
+  whether Kilo also knows it — which is the whole answer to whether a free import
+  will work.
+- **Per-model input ceilings and per-provider batch limits.** The ceilings differ by
+  more than an order of magnitude (`mxbai-embed-large` takes 512 tokens,
+  `voyage-code-4` takes 32,000), and one global constant truncated every chunk past
+  the smallest model's limit. Batch limits are now per provider: OpenAI caps a
+  request at 300,000 tokens whatever the item count, Gemini accepts a fixed number of
+  items, Voyage has both.
+- `voyage-code-4`, `voyage-4`, `voyage-4-large`, `voyage-4-lite`,
+  `gemini-embedding-2` and Ollama's `bge-m3` in the catalog, each marked as not
+  present in Kilo's registry so it is clear they cannot be imported.
+- `indexing_status` warns before a model change re-embeds the workspace, with the
+  point count, rather than after the embeddings have been paid for.
+
+### Changed
+
+- **A search that cannot read part of the corpus now fails instead of shrinking.**
+  An embedding failure per profile was pushed onto a list rendered as "Warnings", and
+  the results that came back looked exactly like a complete set whose missing half
+  ranked lower. An index holding points whose profile cannot be embedded is now an
+  error naming the profile. An index with no points is not an error, so the common
+  case is unaffected.
+- Changing provider clears the model, because model ids are namespaced per provider.
+  The previous code claimed to do this and did not, so switching to Voyage produced
+  `voyage` + `codestral-embed-2505`, which outranks the provider default.
+- The stored dimension of a previous index is no longer inherited across a provider
+  change. A 1536-wide Mistral index made any new model look 1536-dimensional, and the
+  inherited number was then persisted as though it had been measured, making the
+  mismatch self-consistent and invisible on every later run.
+- The `apiKeys` merge is derived from the incoming keys instead of a hand-written list
+  of provider names, which silently dropped any credential added to the shape but not
+  to the list.
+- The settings page reports which providers have credentials instead of deriving it
+  from two booleans, which reported "none configured" for a Gemini, Voyage,
+  OpenRouter, Ollama or OpenAI-compatible setup.
+- `indexing_config` and `settings test kilo` pass a target profile to the Kilo source
+  scan. Without it every source was reported as compatible, including ones that would
+  be refused a moment later.
+- Ollama and Voyage are sent `truncate` / `truncation: false`, so an over-long chunk
+  fails instead of being silently shortened into a valid-looking wrong vector.
+- Embedding results are placed by `data[].index` where the provider supplies it.
+  OpenAI documents the field rather than promising response order, and its own samples
+  fetch by it; a repeated or out-of-range index is now an error.
+- The catalog's `openrouter` Gemini entry names `google/gemini-embedding-2-preview`,
+  which is what Kilo writes. It said `google/gemini-embedding-001`, and since the
+  profile comparison is exact string equality the drift was invisible and made every
+  such index un-importable.
+
+### Fixed
+
+- The model field is cleared on a provider change in the TUI as well as the chat
+  command; both paths had the same stale-model bug.
+- `searchCode` and `getStatus` had no unit tests — only the e2e and cli scripts
+  exercised them, and those assert nothing. Both have tests now.
+
+### Documentation
+
+- The README states how far each provider has actually been tested. `mistral` has
+  touched its real API; `openrouter` reached the API and authenticated but was
+  refused by the key's own spend limit; `openai`, `gemini`, `voyage`,
+  `openai-compatible` and `ollama` have never contacted a real endpoint and are
+  covered only by fixtures written alongside their adapters. The same fact is
+  surfaced in the model chooser and in `indexing_config`, and a test pins the list so
+  the claim cannot quietly widen.
+
+## [0.1.1] - 2026-10-14
+
+### Added
+
+- `src/lancedb-support.ts` reports up front that LanceDB ships one native binary per
+  platform and that there is no `lancedb-darwin-x64` build (there is no WASM
+  fallback), so the embedded store is unavailable on macOS on Intel — instead of
+  failing later with a module-not-found error.
+
+### Changed
+
+- **The own index now defaults to embedded LanceDB** instead of inheriting Kilo's
+  `vectorStore`. Kilo's setting is read as `kiloVectorStore`: it still decides where
+  an *import* reads from, and it is still reported, but it no longer decides where
+  the own index writes to. Dropping that inheritance is reported as a warning rather
+  than applied silently, so an existing Qdrant own index is not discovered to be
+  empty.
+- npm releases are now automated: pushing a `v*` tag triggers a GitHub Actions
+  workflow that publishes through npm trusted publishing (OIDC), with no
+  long-lived token.
+
 ## [0.1.0] - 2026-10-09
 
 First public release.
@@ -29,5 +127,7 @@ First public release.
 - Cross-platform installer (`install.mjs`, plus `install.sh` / `install.ps1`
   wrappers).
 
-[Unreleased]: https://github.com/Javierkaiser/opencode-indexing/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/Javierkaiser/opencode-indexing/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/Javierkaiser/opencode-indexing/releases/tag/v0.2.0
+[0.1.1]: https://github.com/Javierkaiser/opencode-indexing/releases/tag/v0.1.1
 [0.1.0]: https://github.com/Javierkaiser/opencode-indexing/releases/tag/v0.1.0

package/README.md

@@ -4,7 +4,7 @@
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![node: >=22.6](https://img.shields.io/badge/node-%3E%3D22.6-brightgreen.svg)](https://nodejs.org)
 
-OpenCode plugin that adds **semantic code search** by reusing the code index created by [Kilo Code](https://kilo.ai) and maintaining its **own independent index** (Qdrant or embedded LanceDB), so search keeps working even when Kilo isn't installed, is disabled, or its index is stale.
+OpenCode plugin that adds **semantic code search** by reusing the code index created by [Kilo Code](https://kilo.ai) and maintaining its **own independent index** (embedded LanceDB by default, or Qdrant if you prefer), so search keeps working even when Kilo isn't installed, is disabled, or its index is stale.
 
 ## TL;DR
 
@@ -69,7 +69,7 @@ If no package manager is available the copy still happens and the plugin runs wi
 
 ```
 OpenCode ──► indexing_search ──┬──► Kilo's index (read-only)      Qdrant ws-*  ·  Kilo LanceDB
-                               └──► own index (read/write)        Qdrant oc-*  ·  own LanceDB
+                               └──► own index (read/write)        own LanceDB (default)  ·  Qdrant oc-*
 ```
 
 - **Read-only reuse**: the plugin computes the same collection name Kilo uses (`ws-` + sha256 of the workspace path, first 16 hex chars), validates the embedding profile stored in the metadata point, and queries with an embedding from the *same* model (e.g. Mistral `codestral-embed-2505`, 1536d).
@@ -176,12 +176,126 @@ Configurable from all three:
 - **Vector store** for the own index: Qdrant or LanceDB.
 - **Qdrant URL + API key** (local or remote) with connection test.
 - **LanceDB directory** with availability test.
-- **Embedding provider/model** (mistral, openai, ollama, openai-compatible, gemini, voyage, openrouter) and **API key**.
+- **Embedding provider/model** (mistral, openai, ollama, openai-compatible, gemini, voyage, openrouter) and **API key**. The model is chosen from a catalog rather than typed blind. The model is chosen from a catalog rather than typed blind.
 - **Import from Kilo** toggle with live source detection ("Qdrant ws-… (31,261 pts) · LanceDB …").
 - **Auto-refresh on search** toggle.
 - Build / refresh / import actions and a status summary.
 
-Settings are stored in `~/.config/opencode/indexing.json` (plugin options → `indexing.json` → environment → `~/.config/kilo/kilo.jsonc` → defaults). Plugin options in `opencode.json` still work and take precedence. API keys are never written to `indexing.json` in plain text; set them through the environment or plugin options.
+### Embedding providers
+
+All seven have an adapter. Every model below is in the catalog, which is what
+supplies the dimension, the score threshold and the input ceiling; a model that
+is not listed still works, and its dimension is probed from the provider on
+first use. See the next section for how far each one has actually been tested.
+
+| Provider | Default model | Also in the catalog | Input ceiling |
+| --- | --- | --- | --- |
+| `mistral` | `codestral-embed-2505` | `codestral-embed`, `mistral-embed` | 8,192 |
+| `openai` | `text-embedding-3-small` | `text-embedding-3-large`, `text-embedding-ada-002` | 8,192 |
+| `voyage` | `voyage-code-3` | **`voyage-code-4`**, `voyage-4`, `voyage-4-large`, `voyage-4-lite`, `voyage-3-lite` | **32,000** |
+| `gemini` | `gemini-embedding-001` | **`gemini-embedding-2`**, `text-embedding-004`, `embedding-001` | 2,048 (001) / 8,192 (2) |
+| `openrouter` | `openai/text-embedding-3-small` | `openai/text-embedding-3-large`, `google/gemini-embedding-2-preview` | 8,192 |
+| `ollama` | `nomic-embed-text` | `mxbai-embed-large`, `all-minilm`, `bge-m3` | 512 – 8,192 |
+| `openai-compatible` | none | whatever your endpoint serves | probed |
+
+#### Getting an API key (Mistral)
+
+Mistral is the default provider and the only one tested end to end here, so it is
+the shortest path to a working index. API access is enabled by default on a free
+account — **no credit card** — with a usage limit that is enough to index a
+repository.
+
+1. Create an account at <https://console.mistral.ai> if you do not have one.
+2. Open the **Studio** console and click **API Keys** in the left sidebar.
+3. Click **Create new key**: give it a name, set an expiration date, and choose the
+   connector access scope (*Shared connectors only* is enough for an API key).
+4. Click **Create new key** and **copy the key right away** — it is shown once and
+   cannot be retrieved later.
+
+Then hand it to the plugin. The simplest way keeps the key out of any file:
+
+```bash
+export KILO_INDEX_MISTRAL_KEY=...          # Linux / macOS
+# PowerShell: $env:KILO_INDEX_MISTRAL_KEY = "..."
+```
+
+Equivalently, set it from **`/indexing-config`** in any client or the `/indexing`
+page in the terminal (the field is masked), or through the plugin's options in
+`opencode.json` — see
+[Configuration](#configuration-optional-opencodejson). Settings resolve in the
+order *plugin options → `indexing.json` → environment → defaults*, so an
+environment variable is overridden by anything set in the file or in the options.
+
+To check the key before indexing:
+
+```bash
+curl -s https://api.mistral.ai/v1/models \
+  -H "Authorization: Bearer $KILO_INDEX_MISTRAL_KEY" | head -c 200
+```
+
+A list of models means it works; a `401` means the key is wrong or the header is
+missing.
+
+#### How far each provider has actually been tested
+
+Worth stating plainly, because "implemented" and "seen working" are not the
+same claim and only one of them is safe to rely on.
+
+| Provider | Against the real API | What that means |
+| --- | --- | --- |
+| `mistral` | **Yes** | Two inputs, 1536 dimensions, distinct vectors, ~680 ms |
+| `openrouter` | **Partly** | The request reached the API and authenticated; it was refused by the key's own $0 spend limit, so the response parser is unverified |
+| `ollama` | **No** | The local server was not running during the check |
+| `openai`, `gemini`, `voyage`, `openai-compatible` | **No** | No credentials available; only mock-based tests |
+
+The adapters for the last four were written from each provider's documentation
+and tested against fixtures written alongside them, which means the tests encode
+the same reading of the docs as the code. A wrong assumption about a field name
+or a response shape would pass every test and fail on first use.
+
+Three specific things this leaves open, in descending order of how quietly they
+would fail:
+
+- **Gemini's aggregation.** `gemini-embedding-2` returns a single aggregated
+  vector for a plain list of inputs, where `gemini-embedding-001` returns one per
+  input. The adapter wraps each input in its own `Content` to make both behave
+  the same way, and a test asserts the count — but the test is against a fixture,
+  not the model. If the wrapping is wrong, N inputs silently become one vector.
+- **Voyage's response shape.** It is treated as OpenAI-shaped
+  (`data[].embedding` with an `index`). This matches its published API reference
+  and was not confirmed against the service.
+- **Voyage and Ollama truncation.** Both are sent `truncation`/`truncate: false`
+  so that an over-long chunk fails instead of being silently shortened. If a
+  provider rejects that field rather than honouring it, indexing stops with an
+  error rather than degrading — which is the intended direction to fail, but it
+  is a guess about the field being accepted.
+
+If you use one of these providers and it fails, the error message names the
+provider and the endpoint; please report it, since this is the part of the
+plugin most likely to be wrong.
+
+Two things worth knowing before switching:
+
+- **Model ids are namespaced per provider.** Changing provider clears the model
+  so the new provider's default applies. A leftover id like
+  `codestral-embed-2505` under `provider: "voyage"` would be sent to Voyage and
+  rejected.
+- **Changing the model invalidates the own index.** A different model means a
+  different vector space, so the next build deletes the existing points and
+  re-embeds the whole workspace. `indexing_status` warns with the point count
+  *before* that happens. Re-embedding a repository is cheap — well under a
+  couple of dollars at any paid provider — but a large one takes a while.
+
+**Which models can import from Kilo.** Kilo's registry is mirrored entry for
+entry, because an import is accepted only when provider, model id and dimension
+match exactly. Models marked *ours* in the table above are not in Kilo's
+registry and can never be imported; `indexing_config` says which is which. If
+your Kilo index uses a different model, set the same provider and model here and
+the import costs nothing.
+
+Settings are stored in `~/.config/opencode/indexing.json` (plugin options → `indexing.json` → environment → defaults). Plugin options in `opencode.json` still work and take precedence. API keys are never written to `indexing.json` in plain text; set them through the environment or plugin options.
+
+`~/.config/kilo/kilo.jsonc` is still read, and still supplies the embedding provider, model, dimensions and API keys — and it still says where *Kilo* keeps its index. It no longer decides where this plugin's own index is written; that stopped being coupled so that the default could actually take effect for people running Kilo. See [Where each index lives](#where-each-index-lives).
 
 ## Configuration (optional, `opencode.json`)
 
@@ -200,7 +314,7 @@ Settings are stored in `~/.config/opencode/indexing.json` (plugin options → `i
 
 | Variable | Meaning |
 | --- | --- |
-| `KILO_INDEX_VECTOR_STORE` | `qdrant` (default) or `lancedb` for the own index |
+| `KILO_INDEX_VECTOR_STORE` | `lancedb` (default) or `qdrant` for the own index |
 | `KILO_INDEX_QDRANT_URL` / `KILO_INDEX_QDRANT_API_KEY` | Qdrant connection |
 | `KILO_INDEX_LANCEDB_DIR` | Base directory for the own LanceDB stores |
 | `KILO_INDEX_KILO_LANCEDB_DIR` | Override Kilo's LanceDB directory (import source) |
@@ -211,9 +325,56 @@ Word about data safety: Kilo's indexes (`ws-*` collections and its LanceDB direc
 ## Requirements
 
 - OpenCode v2 (plugin API `@opencode/plugin@2.x`).
-- For search/index: a Qdrant server (default `http://localhost:6333`) and/or the optional LanceDB module (`@lancedb/lancedb@0.26.2`).
+- **For the own index: nothing to run.** The default store is embedded LanceDB
+  (`@lancedb/lancedb@0.26.2`), so there is no server to start, no port to free and
+  no container to keep alive.
+- **A Qdrant server is only needed if you ask for it**, either by setting
+  `vectorStore=qdrant` or because a Kilo index you want to import lives in Qdrant.
+  In that case the default URL is `http://localhost:6333`.
 - Embedding credentials compatible with the collection you search (the profile is read from the metadata point).
 
+### Where each index lives
+
+The own index and Kilo's index are independent, and each one is chosen on its
+own:
+
+| Index | Default | Configured by |
+| --- | --- | --- |
+| Own index | embedded LanceDB, under `~/.local/state/opencode-indexing/lancedb` | `vectorStore` |
+| Kilo index (read-only) | whatever `kilo.jsonc` says | Kilo itself |
+
+Kilo's `vectorStore` used to decide where this plugin's own index was written,
+because both were read from the same setting chain. That is no longer the case:
+Kilo decides where an import **reads from**, and your own index decides where it
+**writes to**. If Kilo is on Qdrant and you have not set `vectorStore` yourself,
+the own index still goes to LanceDB and `indexing_status` says so.
+
+### Platform support for the embedded store
+
+`@lancedb/lancedb` is a JavaScript wrapper around a native library, with one
+prebuilt binary per platform and no WebAssembly fallback. The platforms it ships
+a binary for are:
+
+| Platform | `platform-arch` | Own index on LanceDB |
+| --- | --- | --- |
+| Windows x64 / arm64 | `win32-x64`, `win32-arm64` | yes |
+| Linux x64 / arm64 (glibc and musl) | `linux-x64`, `linux-arm64` | yes |
+| macOS Apple Silicon | `darwin-arm64` | yes |
+| **macOS Intel** | `darwin-x64` | **no binary is published** |
+
+On macOS Intel the default store cannot load, and installing it again will not
+help. The plugin says so explicitly and asks you to pick Qdrant:
+
+```
+LanceDB is the default store for the own index but has no native binary for
+darwin-x64. It cannot run on this platform and reinstalling will not change
+that. Set vectorStore=qdrant explicitly in
+~/.config/opencode/indexing.json to use a Qdrant server instead.
+```
+
+Set `vectorStore=qdrant` in `~/.config/opencode/indexing.json` (or run
+`/indexing-config set vectorstore=qdrant`) to use a Qdrant server instead.
+
 ## Semantic search vs. code graphs (roadmap)
 
 `opencode-indexing` implements **semantic (vector) search**. It is worth being

package/index.ts

@@ -32,7 +32,8 @@ import {
   parseIndexingCommand,
   settingReport,
 } from "./src/settings-commands.ts"
-import type { IndexingSettings, KVStore } from "./src/types.ts"
+import { getModelDimension, isKiloMirrored, isLiveTested, listModelIds } from "./src/registry.ts"
+import type { EmbeddingProfile, IndexingSettings, KVStore, ProviderCredentials } from "./src/types.ts"
 import type { Qdrant } from "./src/qdrant.ts"
 import { describeError } from "./src/errors.ts"
 
@@ -114,13 +115,76 @@ function settingsView(settings: IndexingSettings, homeDir?: string): Record<stri
     autoRefresh: settings.autoRefresh,
     enabled: settings.enabled,
     searchMaxResults: settings.searchMaxResults,
-    hasMistralKey: Boolean(settings.credentials.mistralApiKey),
-    hasOpenAiKey: Boolean(settings.credentials.openAiApiKey),
+    // Which providers actually have a credential, as a list rather than one
+    // boolean per provider. The booleans only ever covered Mistral and OpenAI,
+    // so a settings page with a Gemini key configured reported "none
+    // configured" - and every provider added afterwards would have needed
+    // another field threaded through the RPC, the schema and the page.
+    configuredProviders: configuredProviders(settings.credentials),
     settingsFile: settingsFilePath(homeDir),
     warnings: settings.warnings,
   }
 }
 
+/**
+ * Providers with a usable credential.
+ *
+ * A base URL counts for the two providers that authenticate with one, since a
+ * configured Ollama or OpenAI-compatible server needs no key.
+ */
+function configuredProviders(credentials: ProviderCredentials): string[] {
+  const configured: string[] = []
+  if (credentials.mistralApiKey) configured.push("mistral")
+  if (credentials.openAiApiKey) configured.push("openai")
+  if (credentials.geminiApiKey) configured.push("gemini")
+  if (credentials.voyageApiKey) configured.push("voyage")
+  if (credentials.openRouterApiKey) configured.push("openrouter")
+  if (credentials.ollamaBaseUrl) configured.push("ollama")
+  if (credentials.openAiCompatibleBaseUrl) configured.push("openai-compatible")
+  return configured
+}
+
+/**
+ * The profile the settings describe.
+ *
+ * Only the identity of the model is needed to compare against a Kilo index;
+ * the dimension is part of the comparison, so it has to come from somewhere.
+ * `settings.dimension` is 0 for a model the catalog does not know, and a
+ * comparison against a zero dimension would report every source as
+ * incompatible, which is as wrong as reporting every one as compatible.
+ */
+function profileFor(settings: IndexingSettings): EmbeddingProfile | undefined {
+  const dimension = settings.dimension || getModelDimension(settings.provider, settings.modelId) || 0
+  if (!dimension) return undefined
+  return { provider: settings.provider, modelId: settings.modelId, dimension }
+}
+
+/**
+ * The models this provider offers, and which of them can import from Kilo.
+ *
+ * The catalog was only ever used to look up a dimension, so it was invisible:
+ * a model id had to be known in advance to be used. Which entries Kilo also
+ * knows is the one thing that decides whether an import will be accepted, so
+ * it is stated rather than left to be discovered by a refused build.
+ */
+function describeAvailableModels(settings: IndexingSettings): string[] {
+  const models = listModelIds(settings.provider)
+  const note = isLiveTested(settings.provider)
+    ? []
+    : [
+        `- **Note:** the ${settings.provider} adapter has not been exercised against the real API; it is built from the provider's documentation. See "How far each provider has actually been tested" in the README.`,
+      ]
+  if (models.length === 0) {
+    return [...note, `- **Models:** this provider has no catalog; set \`model\` to whatever your endpoint serves`]
+  }
+  const render = (modelId: string) => {
+    const dimension = getModelDimension(settings.provider, modelId)
+    const importer = isKiloMirrored(settings.provider, modelId) === false ? " — not importable from Kilo" : ""
+    return `\`${modelId}\`${dimension ? ` (${dimension}d)` : ""}${importer}`
+  }
+  return [...note, `- **Models for ${settings.provider}:** ${models.map(render).join(" · ")}`]
+}
+
 function summarizeReport(report: {
   durationMs: number
   chunksUpserted: number
@@ -315,7 +379,11 @@ Behavior:
           return { ok: true, message: `${settings.provider}/${settings.modelId} OK (${vector?.length ?? 0} dimensions)` }
         }
         if (target === "kilo") {
-          const sources = await discoverKiloSources(root, { qdrant: createSettingsQdrant(settings), homeDir: undefined })
+          const sources = await discoverKiloSources(root, {
+            qdrant: createSettingsQdrant(settings),
+            homeDir: undefined,
+            targetProfile: profileFor(settings),
+          })
           const list = sources.map((s) => `${s.kind} ${s.name} (${s.pointsCount ?? "?"} pts, ${s.compatible ? "compatible" : "INCOMPATIBLE"})`)
           return {
             ok: sources.length > 0,
@@ -462,6 +530,7 @@ class ForgetRefusedError extends Error {}
         "",
         `- **Vector store (own index):** ${settings.vectorStore}${settings.vectorStore === "qdrant" ? ` — ${settings.qdrantUrl}` : ` — ${settings.lancedbDirectory}`}`,
         `- **Embedding model:** ${settings.provider}/${settings.modelId}${settings.dimension ? ` (${settings.dimension}d)` : ""}`,
+        ...describeAvailableModels(settings),
         `- **Import from Kilo:** ${settings.importFromKilo ? "ON (build imports existing Kilo indexes without embedding cost)" : "OFF (always index from scratch)"}`,
         `- **Auto-refresh on search:** ${settings.autoRefresh ? "ON" : "OFF"}`,
         `- **Indexing:** ${settings.enabled === false ? "PAUSED (nothing is written or refreshed; search still reads Kilo's index)" : "ON"}`,
@@ -482,6 +551,11 @@ class ForgetRefusedError extends Error {}
       const sources = await discoverKiloSources(root, {
         qdrant: createSettingsQdrant(settings),
         homeDir: undefined,
+        // Without this every source reported "compatible", including ones whose
+        // profile differs: the check returns true when it has no target to
+        // compare against, so the report claimed an import would work when it
+        // would be refused a moment later.
+        targetProfile: profileFor(settings),
       }).catch(() => [])
       lines.push(
         "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javierkaiser/opencode-indexing",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenCode plugin: semantic code search that reuses Kilo Code indexes (Qdrant/LanceDB) and maintains its own independent index",
   "license": "MIT",
   "author": "Carlos Javier Lust <javierkaiser@gmail.com>",

package/src/config.ts

@@ -1,7 +1,8 @@
 import * as os from "node:os"
 
 import type { EmbedderProvider, IndexingSettings, ProviderCredentials } from "./types.ts"
-import { defaultLanceDbDirectory, readSettingsFile, type SettingsFile } from "./settings.ts"
+import { defaultLanceDbDirectory, readSettingsFile, settingsFilePath, type SettingsFile } from "./settings.ts"
+import { lanceDbSupport } from "./lancedb-support.ts"
 import { stripJsonComments } from "./jsonc.ts"
 import {
   DEFAULT_EMBEDDING_BATCH_SIZE,
@@ -62,7 +63,7 @@ interface KiloConfigIndexing {
   openrouter?: { apiKey?: string }
 }
 
-const VALID_PROVIDERS: readonly EmbedderProvider[] = [
+export const VALID_PROVIDERS: readonly EmbedderProvider[] = [
   "mistral",
   "openai",
   "ollama",
@@ -184,9 +185,33 @@ export function resolveSettings(options: PluginOptionsInput): IndexingSettings {
       nonEmpty(kilo?.openrouter?.apiKey),
   }
 
-  const vectorStore =
-    pickVectorStore(options.vectorStore, file?.vectorStore, process.env.KILO_INDEX_VECTOR_STORE, kilo?.vectorStore) ??
-    "qdrant"
+  // Kilo decides where an import reads FROM; it does not decide where the own
+  // index writes TO. Those were coupled through this one chain, and that is
+  // what made "LanceDB by default" unreachable for exactly the people most
+  // likely to have Kilo installed: kilo.jsonc's vectorStore sat above the
+  // fallback, so a Kilo-on-Qdrant setup silently kept pinning the own index to
+  // Qdrant. The coupling is reported below rather than dropped in silence.
+  const kiloVectorStore = pickVectorStore(kilo?.vectorStore)
+  const ownVectorStore = pickVectorStore(
+    options.vectorStore,
+    file?.vectorStore,
+    process.env.KILO_INDEX_VECTOR_STORE,
+  )
+  if (kiloVectorStore && !ownVectorStore && kiloVectorStore !== "lancedb") {
+    warnings.push(
+      `Kilo indexes with ${kiloVectorStore}; your own index no longer inherits that. ` +
+        `Set vectorStore explicitly in ${settingsFilePath(options.homeDir)} to change it.`,
+    )
+  }
+  const vectorStore = ownVectorStore ?? "lancedb"
+
+  if (vectorStore === "lancedb" && !lanceDbSupport().supported) {
+    const { id } = lanceDbSupport()
+    warnings.push(
+      `LanceDB is the default store but has no native binary for ${id}. ` +
+        `Indexing will fail until you set vectorStore=qdrant in ${settingsFilePath(options.homeDir)}.`,
+    )
+  }
 
   const qdrantUrl =
     nonEmpty(options.qdrantUrl) ??
@@ -264,6 +289,7 @@ export function resolveSettings(options: PluginOptionsInput): IndexingSettings {
     modelId,
     dimension: dimension ?? 0,
     vectorStore,
+    kiloVectorStore: kiloVectorStore ?? null,
     qdrantUrl,
     qdrantApiKey,
     lancedbDirectory,