@javierkaiser/opencode-indexing 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-10-14
+
+### Changed
+
+- 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 +37,6 @@ 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.1.1...HEAD
+[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).
@@ -181,7 +181,9 @@ Configurable from all three:
 - **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.
+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 +202,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 +213,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javierkaiser/opencode-indexing",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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,
@@ -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,

package/src/lancedb-store.ts

@@ -3,6 +3,7 @@ import * as path from "node:path"
 
 import { workspaceHash } from "./registry.ts"
 import { defaultLanceDbDirectory } from "./settings.ts"
+import { lanceDbUnavailableMessage } from "./lancedb-support.ts"
 import type { VectorStoreAdapter, VectorStoreInfo, StoreSearchOptions, ExportBatch } from "./vector-store.ts"
 import type { EmbeddingProfile, QdrantPoint, QueryHit } from "./types.ts"
 import { describeError } from "./errors.ts"
@@ -71,9 +72,7 @@ let lancedbPromise: Promise<any> | undefined
 function loadLanceDb(): Promise<any> {
   lancedbPromise ??= import("@lancedb/lancedb").catch((error) => {
     lancedbPromise = undefined
-    throw new Error(
-      `LanceDB no está disponible (instala @lancedb/lancedb@0.26.2 o usa vectorStore=qdrant): ${describeError(error)}`,
-    )
+    throw new Error(lanceDbUnavailableMessage(error), { cause: error })
   })
   return lancedbPromise
 }

package/src/lancedb-support.ts

@@ -0,0 +1,83 @@
+import { settingsFilePath } from "./settings.ts"
+
+/**
+ * Which platforms the LanceDB binding can actually run on.
+ *
+ * `@lancedb/lancedb` is a JavaScript wrapper that `require()`s one of seven
+ * per-platform native binaries, each published as its own optional dependency.
+ * There is no WASM build, so a platform outside that list cannot use LanceDB at
+ * all, and installing it again will not change that.
+ *
+ * macOS on Intel is the one that bites: `lancedb-darwin-x64` is not published,
+ * so LanceDB works on Apple Silicon only. The list is here so the plugin can say
+ * so plainly instead of surfacing a module-resolution stack trace; the import
+ * itself stays the authority on whether the binary loaded.
+ */
+
+export const LANCEDB_VERSION = "0.26.2"
+
+/** `platform-arch`, the way a native package would be named. */
+export function platformId(platform: string = process.platform, arch: string = process.arch): string {
+  return `${platform}-${arch}`
+}
+
+const SUPPORTED = new Set([
+  "win32-x64",
+  "win32-arm64",
+  "darwin-arm64",
+  "linux-x64",
+  "linux-arm64",
+])
+
+export interface LanceDbSupport {
+  /** `platform-arch` of the current process. */
+  id: string
+  /** Whether a native binary is published for it. */
+  supported: boolean
+}
+
+export function lanceDbSupport(
+  platform: string = process.platform,
+  arch: string = process.arch,
+): LanceDbSupport {
+  const id = platformId(platform, arch)
+  return { id, supported: SUPPORTED.has(id) }
+}
+
+/**
+ * Node appends the resolution chain to a MODULE_NOT_FOUND message, which buries
+ * the one line that says what went wrong under seven lines of internal files.
+ * The cause is still there; it is just what a reader acts on that is kept.
+ */
+function causeSummary(cause: unknown): string {
+  const message = cause instanceof Error ? cause.message : String(cause)
+  const atRequireStack = message.indexOf("Require stack:")
+  return (atRequireStack === -1 ? message : message.slice(0, atRequireStack)).trim()
+}
+
+/**
+ * The message shown when LanceDB cannot be loaded.
+ *
+ * The two cases need different advice, so they get different words: a platform
+ * with no binary cannot be fixed by installing anything, while a supported
+ * platform that failed to load usually means the optional dependency was
+ * skipped.
+ */
+export function lanceDbUnavailableMessage(
+  cause: unknown,
+  support: LanceDbSupport = lanceDbSupport(),
+): string {
+  const { id, supported } = support
+  if (!supported) {
+    return (
+      `LanceDB is the default store for the own index but has no native binary for ${id}. ` +
+      `It cannot run on this platform and reinstalling will not change that. ` +
+      `Set vectorStore=qdrant explicitly in ${settingsFilePath()} to use a Qdrant server instead.`
+    )
+  }
+  return (
+    `LanceDB could not be loaded for ${id}. It ships as an optional dependency: ` +
+    `install @lancedb/lancedb@${LANCEDB_VERSION}, or set vectorStore=qdrant. ` +
+    `Cause: ${causeSummary(cause)}`
+  )
+}

package/src/status.ts

@@ -56,13 +56,26 @@ const KILO_CACHE_PREFIX = "kiloCollection/"
 
 export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: boolean }): Promise<IndexStatus> {
   const { qdrant, kv, root, settings } = deps
-  const warnings: string[] = []
+  // Configuration warnings are produced once per resolution and were previously
+  // never shown, so a store that cannot work on this platform looked simply
+  // absent rather than misconfigured.
+  const warnings: string[] = [...settings.warnings]
   let reachable = true
   try {
     await qdrant.listCollections()
   } catch (error) {
     reachable = false
-    warnings.push(`Qdrant unreachable at ${settings.qdrantUrl}: ${describeError(error)}`)
+    // Only worth reporting when Qdrant is actually part of this setup. With the
+    // own index on LanceDB and no Qdrant-backed Kilo index, a dead Qdrant is
+    // not a problem the user has, and saying so would train them to ignore it.
+    const qdrantIsOurs = settings.vectorStore === "qdrant" || settings.kiloVectorStore === "qdrant"
+    if (qdrantIsOurs) {
+      warnings.push(
+        settings.vectorStore === "qdrant"
+          ? `Qdrant unreachable at ${settings.qdrantUrl}: ${describeError(error)}`
+          : `Qdrant unreachable at ${settings.qdrantUrl}, so a Kilo index stored there cannot be imported: ${describeError(error)}`,
+      )
+    }
   }
 
   const ownStore = createOwnStore(settings, root)

package/src/types.ts

@@ -39,6 +39,15 @@ export interface ProviderCredentials {
 export interface IndexingSettings extends EmbeddingProfile {
   /** Backend for the plugin's OWN index. */
   vectorStore: "qdrant" | "lancedb"
+  /**
+   * Store Kilo keeps its own index in, when kilo.jsonc says so.
+   *
+   * Kept alongside `vectorStore` rather than folded into it: Kilo decides where
+   * an import reads from, the own index decides where it writes, and the status
+   * report needs both to know whether an unreachable Qdrant is a problem here or
+   * simply not this user's business.
+   */
+  kiloVectorStore: "qdrant" | "lancedb" | null
   qdrantUrl: string
   qdrantApiKey?: string
   /** Base directory for the plugin's own LanceDB stores. */