@javierkaiser/opencode-indexing 0.1.1 → 0.2.1

package/tui.ts

@@ -24,10 +24,13 @@ import type { ThemeLike } from "./tui/page-style.ts"
 import { PAGE_ACTIONS, PAGE_ROWS, type SettingsPageRpc } from "./tui/settings-page-data.ts"
 import { footerAction, footerState, type IndexingState } from "./tui/footer.ts"
 import { activeWorkspace, type WorkspaceSources } from "./tui/footer.ts"
+import { bindWorkspace } from "./tui/workspace-rpc.ts"
 import { describeRow, forgetWorkspaceFlow, type WorkspacesRpc } from "./tui/workspaces.ts"
 import { pagePalette } from "./tui/page-style.ts"
 import type { FooterHandle, FooterState } from "./tui/footer-view.tsx"
 import { describeError } from "./src/errors.ts"
+import { getDefaultModelId, isLiveTested, listModelIds } from "./src/registry.ts"
+import type { EmbedderProvider } from "./src/types.ts"
 
 /**
  * Navigable rows on the page.
@@ -40,11 +43,21 @@ const PAGE_ROW_COUNT = PAGE_ROWS.length
 
 const ID = "opencode.indexing"
 
+/** Sentinel for the "type it yourself" entry in the model chooser. */
+const CUSTOM_MODEL = "\u0000custom-model"
+
 type RpcClient = {
   "settings.get": (input: Record<string, never>) => Promise<{ settings: SettingsView }>
   "settings.set": (input: { patch: Record<string, unknown> }) => Promise<{ settings: SettingsView }>
-  "settings.test": (input: { target: "qdrant" | "lancedb" | "provider" | "kilo" }) => Promise<{ ok: boolean; message: string }>
-  "kilo.discover": () => Promise<{ sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }> }>
+  "settings.test": (input: {
+    target: "qdrant" | "lancedb" | "provider" | "kilo"
+    directory?: string
+  }) => Promise<{ ok: boolean; message: string }>
+  "kilo.discover": (input?: { directory?: string }) => Promise<{
+    sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }>
+    /** Sources that exist but could not be read. */
+    problems?: string[]
+  }>
   "status.get": (input: { checkFreshness?: boolean; directory?: string }) => Promise<{ summary: string; recommendation: string; ownKind: string; ownStore: string; ownPoints?: number | null; ownComplete?: boolean | null; kiloCollection?: string | null; directory?: string; ownStoreReachable?: boolean }>
   "index.build": (input: { rebuild?: boolean; skipImport?: boolean; directory?: string }) => Promise<{ summary: string; error?: string }>
   "index.refresh": (input: { maxFiles?: number; directory?: string }) => Promise<{ summary: string; error?: string }>
@@ -64,18 +77,54 @@ interface SettingsView {
   /** Master switch for writing the own index. */
   enabled: boolean
   searchMaxResults: number
-  hasMistralKey: boolean
-  hasOpenAiKey: boolean
+  /** Providers that have a usable credential or base URL configured. */
+  configuredProviders: string[]
   settingsFile: string
 }
 
 const plugin = {
   id: ID,
   async setup(context: Plugin.Context): Promise<void> {
+    /**
+     * The workspace the caller is working in.
+     *
+     * The server plugin serves its own instance directory, so every RPC that
+     * reads or writes an index must be told which workspace it is about. Without
+     * this the footer would report — and the palette command would index — the
+     * service's directory instead of the user's: the ACTIVE tab is what follows
+     * the user, and the instance directory is the fallback for a host with tabs
+     * switched off.
+     *
+     * Every accessor is optional: a host may expose neither `ui.tabs` nor
+     * `data.session`, and resolving the workspace must degrade rather than
+     * throw. Read from a reactive context (the footer slot render) the lookups
+     * re-run when the host's tab or session state changes.
+     *
+     * Declared before `rpc` because `rpc` binds the directory into every
+     * workspace-scoped call: a call made before this binding exists would be
+     * answered against the service's own directory.
+     */
+    const workspaceSources: WorkspaceSources = {
+      tabsEnabled: () => context.ui.tabs?.enabled?.() === true,
+      tabs: () => context.ui.tabs?.list?.() ?? [],
+      sessions: () => context.data?.session?.list?.() ?? [],
+      instanceDirectory: () => context.location?.directory,
+    }
+
+    const workspace = (): string | undefined => activeWorkspace(workspaceSources)
+
     // Resolve the RPC subclient lazily: the TUI may start before the server
     // plugin is ready, and calls are retried on first use.
+    //
+    // Every call goes through `bindWorkspace`, so a workspace-scoped method
+    // always names the caller's directory. Passing it per call site is what
+    // failed before: the footer did it and the palette did not, and the palette
+    // silently read and wrote the service's index instead of the user's.
     const rpc = (): RpcClient =>
-      (context.client as unknown as { rpc: (def: unknown, options?: unknown) => RpcClient }).rpc(IndexingRpc)
+      bindWorkspace(
+        (context.client as unknown as { rpc: (def: unknown, options?: unknown) => RpcClient }).rpc(IndexingRpc),
+        workspace,
+      )
 
     const toast = (message: string, variant: "success" | "error" | "info" = "info"): void => {
       context.ui.toast.show({ title: "Indexing", message, variant, duration: 5000 })
@@ -334,13 +383,49 @@ const plugin = {
       })
       if (typeof provider !== "string") return
 
-      const model = await context.ui.dialog.prompt({
-        title: `Model for ${provider} (leave empty for default)`,
-        placeholder: provider === "mistral" ? "codestral-embed-2505" : "",
+      // Offer the catalog instead of a blank text field. The model list existed
+      // all along and was never shown, so the only way to discover a valid model
+      // id was to already know it.
+      const catalog = listModelIds(provider as EmbedderProvider)
+      const defaultModel = getDefaultModelId(provider as EmbedderProvider)
+      const tested = isLiveTested(provider as EmbedderProvider)
+      const choice = await context.ui.dialog.select({
+        title: `Model for ${provider}`,
+        options: [
+          {
+            title: defaultModel ? `${defaultModel} (default)` : "(provider default)",
+            value: "",
+            description: tested
+              ? "Leave the model unset so the provider default applies"
+              : "Not yet exercised against the real API; see the README",
+          },
+          ...catalog
+            .filter((modelId) => modelId !== defaultModel)
+            .map((modelId) => ({ title: modelId, value: modelId, description: `${provider} model` })),
+          {
+            title: "Custom…",
+            value: CUSTOM_MODEL,
+            description: catalog.length > 0 ? "Type a model id that is not in the list" : "This provider has no catalog; type the model id",
+          },
+        ],
       })
-      const patch: Record<string, unknown> = { provider }
-      if (model && model.trim()) patch.model = model.trim()
-      await patchSettings(patch)
+      if (typeof choice !== "string") return
+
+      let model = choice
+      if (choice === CUSTOM_MODEL) {
+        const typed = await context.ui.dialog.prompt({
+          title: `Model id for ${provider}`,
+          placeholder: defaultModel || "e.g. bge-m3",
+        })
+        if (typed === undefined) return
+        model = typed.trim()
+      }
+
+      // `model` is always written, empty when the user accepted the default.
+      // Omitting it left the previous provider's model in the file, where it
+      // outranks the new provider's default: switching to voyage produced
+      // `voyage` + `codestral-embed-2505`.
+      await patchSettings({ provider, model })
 
       // API key for the provider (masked prompt).
       const keyLabel =
@@ -357,7 +442,7 @@ const plugin = {
                   : null
 
       if (keyLabel) {
-        const current = provider === "mistral" && settings.hasMistralKey
+        const current = settings.configuredProviders.includes(provider)
         const key = await context.ui.dialog.prompt({
           title: `${keyLabel} (leave empty to keep current)`,
           placeholder: current ? "•••••• (set)" : "not set",
@@ -405,14 +490,24 @@ const plugin = {
 
     async function kiloMenu(): Promise<void> {
       let sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }> = []
+      let problems: string[] = []
       try {
-        sources = (await rpc()["kilo.discover"]()).sources
+        const found = await rpc()["kilo.discover"]({})
+        sources = found.sources
+        problems = found.problems ?? []
       } catch (error) {
         fail(error)
         return
       }
       if (sources.length === 0) {
-        toast("No Kilo index found for this workspace", "info")
+        // "Found but unreadable" and "never indexed" look identical from here,
+        // and only one of them is fixed by indexing. Say which one it is.
+        toast(
+          problems.length > 0
+            ? `No importable Kilo index: ${problems.join(" · ")}`
+            : "No Kilo index found for this workspace",
+          problems.length > 0 ? "error" : "info",
+        )
         return
       }
       const choice = await context.ui.dialog.select({
@@ -461,7 +556,7 @@ const plugin = {
       toast("Running…", "info")
       try {
         if (action === "refresh") {
-          reportRun(await rpc()["index.refresh"]({ directory: workspace() }))
+          reportRun(await rpc()["index.refresh"]({}))
         } else if (action === "build") {
           reportRun(await rpc()["index.build"]({}))
         } else if (action === "build-scratch") {
@@ -541,30 +636,6 @@ const plugin = {
       return route?.type === "plugin" && route.name === SETTINGS_PAGE_NAME
     }
 
-    /**
-     * The workspace the caller is working in.
-     *
-     * The server plugin serves its own instance directory, so every RPC that
-     * reads or writes an index must be told which workspace it is about. Without
-     * this the footer would report — and the palette command would index — the
-     * service's directory instead of the user's: the ACTIVE tab is what follows
-     * the user, and the instance directory is the fallback for a host with tabs
-     * switched off.
-     *
-     * Every accessor is optional: a host may expose neither `ui.tabs` nor
-     * `data.session`, and resolving the workspace must degrade rather than
-     * throw. Read from a reactive context (the footer slot render) the lookups
-     * re-run when the host's tab or session state changes.
-     */
-    const workspaceSources: WorkspaceSources = {
-      tabsEnabled: () => context.ui.tabs?.enabled?.() === true,
-      tabs: () => context.ui.tabs?.list?.() ?? [],
-      sessions: () => context.data?.session?.list?.() ?? [],
-      instanceDirectory: () => context.location?.directory,
-    }
-
-    const workspace = (): string | undefined => activeWorkspace(workspaceSources)
-
     /** Opens the dialog editor, holding the page keys off for its duration. */
     async function openEditor(): Promise<void> {
       dialogOpen = true
@@ -779,8 +850,8 @@ const plugin = {
         toast("Indexing started…", "info")
         const summary =
           from.state === "stale"
-            ? await rpc()["index.refresh"]({ directory: workspace() })
-            : await rpc()["index.build"]({ skipImport: false, directory: workspace() })
+            ? await rpc()["index.refresh"]({})
+            : await rpc()["index.build"]({ skipImport: false })
         // A failed run comes back as data, not as a rejection: the reason is far
         // more useful than "something went wrong", and it is already readable.
         reportRun(summary)