@javierkaiser/opencode-indexing 0.1.1 → 0.2.1

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
@@ -153,6 +217,19 @@ const plugin = {
       const directory = (input as { directory?: string } | undefined)?.directory
       return typeof directory === "string" && directory.trim() !== "" ? directory : root
     }
+
+    /**
+     * Directory of the session a command was typed in.
+     *
+     * The plugin instance belongs to the directory the service runs in, which is
+     * usually a different one entirely, so a command issued from a session has to
+     * ask the host where that session is rather than assume its own.
+     */
+    const sessionDirectory = async (sessionID: string): Promise<string | undefined> =>
+      ctx.session
+        .get({ sessionID } as never)
+        .then((info: { location?: { directory?: string } }) => info?.location?.directory)
+        .catch(() => undefined)
     const options = (ctx.options ?? {}) as unknown as PluginOptionsInput
     const kv: KVStore = createPluginStorage(ctx.storage as never)
     const getSettings = (): Promise<IndexingSettings> => Promise.resolve(resolveSettings(options))
@@ -293,7 +370,7 @@ Behavior:
      * Extracted so the `settings.test` RPC and the `/indexing-config test`
      * subcommand answer identically instead of drifting apart.
      */
-    async function testTarget(target: string): Promise<{ ok: boolean; message: string }> {
+    async function testTarget(target: string, workspace: string): Promise<{ ok: boolean; message: string }> {
       const settings = await getSettings()
       try {
         if (target === "qdrant") {
@@ -315,11 +392,23 @@ 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 problems: string[] = []
+          const sources = await discoverKiloSources(workspace, {
+            qdrant: createSettingsQdrant(settings),
+            homeDir: undefined,
+            targetProfile: profileFor(settings),
+            onProblem: (message) => problems.push(message),
+          })
           const list = sources.map((s) => `${s.kind} ${s.name} (${s.pointsCount ?? "?"} pts, ${s.compatible ? "compatible" : "INCOMPATIBLE"})`)
+          // A readable source does not make an unreadable one irrelevant: a
+          // partial answer ("Qdrant works, LanceDB does not") is the one that
+          // explains why an import picked the source it did.
+          const found = sources.length > 0 ? list.join(" · ") : `No importable Kilo index for ${workspace}`
           return {
             ok: sources.length > 0,
-            message: sources.length > 0 ? list.join(" · ") : "No Kilo index found for this workspace",
+            // With nothing found, a reason beats a bare "not found": the two
+            // need completely different actions from the user.
+            message: problems.length > 0 ? `${found}. ${problems.join(" · ")}` : found,
           }
         }
         return { ok: false, message: `Unknown test target: ${target}` }
@@ -344,11 +433,24 @@ Behavior:
       const dimension = settings.dimension || (await store.info()).profile?.dimension || 0
       if (!dimension) throw new Error("Embedding dimension unknown")
       const targetProfile = { provider: settings.provider, modelId: settings.modelId, dimension }
-      const sources = await discoverKiloSources(workspace, { qdrant: createSettingsQdrant(settings), targetProfile })
+      const problems: string[] = []
+      const sources = await discoverKiloSources(workspace, {
+        qdrant: createSettingsQdrant(settings),
+        targetProfile,
+        onProblem: (message) => problems.push(message),
+      })
       const source = wanted
         ? sources.find((item) => item.name === wanted)
         : (sources.find((item) => item.compatible) ?? sources[0])
-      if (!source) throw new Error("No Kilo source found for this workspace")
+      if (!source) {
+        // Naming the cause turns "nothing here" into something actionable when
+        // the index is present but unreadable.
+        throw new Error(
+          problems.length > 0
+            ? `No Kilo source found for ${workspace}. ${problems.join(" · ")}`
+            : "No Kilo source found for this workspace",
+        )
+      }
       if (!source.compatible) throw new Error(`Source ${source.name} has an incompatible embedding profile`)
       await store.ensure(dimension, targetProfile)
       const report = await importFromKilo({
@@ -462,6 +564,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"}`,
@@ -479,9 +582,16 @@ class ForgetRefusedError extends Error {}
         }
         lines.push("")
       }
+      const problems: string[] = []
       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),
+        onProblem: (message) => problems.push(message),
       }).catch(() => [])
       lines.push(
         "",
@@ -489,6 +599,9 @@ class ForgetRefusedError extends Error {}
           ? `**Kilo sources detected:** ${sources.map((source) => `${source.kind} ${source.name} (${source.pointsCount ?? "?"} pts, ${source.compatible ? "compatible" : "INCOMPATIBLE"})`).join("; ")}`
           : "**Kilo sources detected:** none for this workspace",
       )
+      // "None" and "none I could read" are different answers, and only one of
+      // them is fixed by indexing from scratch.
+      if (problems.length > 0) lines.push("", `**Kilo sources unreadable:** ${problems.join(" · ")}`)
       lines.push(
         "",
         "To change settings:",
@@ -548,11 +661,15 @@ class ForgetRefusedError extends Error {}
                   return
                 }
                 case "test": {
+                  // Like `import` below, this has to name the session's directory:
+                  // `test kilo` asks whether an index exists *for a workspace*, and
+                  // answering about the service's own directory is always wrong.
                   const targets =
                     parsed.target === "all" ? ["qdrant", "lancedb", "provider", "kilo"] : [parsed.target]
+                  const workspace = (await sessionDirectory(sessionID)) ?? root
                   const results: string[] = []
                   for (const target of targets) {
-                    const result = await testTarget(target)
+                    const result = await testTarget(target, workspace)
                     results.push(`${target}: ${result.ok ? "OK" : "FAIL"} — ${result.message}`)
                   }
                   await reply(results.join("\n"))
@@ -562,11 +679,7 @@ class ForgetRefusedError extends Error {}
                   // The session knows which workspace the user is in; the plugin
                   // instance directory is the one the service runs in, which is
                   // usually a different directory entirely.
-                  const sessionDirectory = await ctx.session
-                    .get({ sessionID } as never)
-                    .then((info: { location?: { directory?: string } }) => info?.location?.directory)
-                    .catch(() => undefined)
-                  await reply(await runImport(sessionDirectory, parsed.source))
+                  await reply(await runImport(await sessionDirectory(sessionID), parsed.source))
                   return
                 }
               }
@@ -604,17 +717,19 @@ class ForgetRefusedError extends Error {}
         },
 
         "settings.test": async (input: unknown) => {
-          return testTarget((input as { target: string }).target)
+          return testTarget((input as { target: string }).target, rootFor(input))
         },
 
-        "kilo.discover": async () => {
+        "kilo.discover": async (input: unknown) => {
           const settings = await getSettings()
           const targetProfile =
             settings.dimension > 0 ? { provider: settings.provider, modelId: settings.modelId, dimension: settings.dimension } : undefined
-          const sources = await discoverKiloSources(root, {
+          const problems: string[] = []
+          const sources = await discoverKiloSources(rootFor(input), {
             qdrant: createSettingsQdrant(settings),
             homeDir: undefined,
             targetProfile,
+            onProblem: (message) => problems.push(message),
           })
           return {
             sources: sources.map((source) => ({
@@ -627,6 +742,7 @@ class ForgetRefusedError extends Error {}
                 : null,
               compatible: source.compatible,
             })),
+            problems,
           }
         },