@javierkaiser/opencode-indexing 0.1.1 → 0.2.1

package/src/tools.ts

@@ -10,6 +10,13 @@ import type { Qdrant } from "./qdrant.ts"
 
 export interface ToolDeps {
   kv: KVStore
+  /**
+   * Fallback workspace, used when the host does not report one per call.
+   *
+   * This is the plugin instance's own directory — the one the service runs in,
+   * which is usually not the directory the user is working in. Prefer
+   * `context.directory`; this is the last resort, not the normal path.
+   */
   root: string
   /**
    * Live settings getter. Tools resolve settings on every execution so config
@@ -18,6 +25,31 @@ export interface ToolDeps {
   getSettings: () => IndexingSettings | Promise<IndexingSettings>
 }
 
+/**
+ * Host context as far as the tools read it.
+ *
+ * `directory` is the session's workspace. Older hosts omit it, which is why it
+ * is optional: `toolRoot` falls back rather than indexing nothing.
+ */
+export interface ToolContext {
+  signal?: AbortSignal
+  progress?: (m: unknown) => Promise<void>
+  directory?: string
+}
+
+/**
+ * The workspace one tool call is about.
+ *
+ * The host knows which directory the user is in; the plugin instance does not.
+ * Indexing the service's directory because that is what `deps.root` happened to
+ * hold writes a perfectly good index of the wrong codebase and reports it as the
+ * user's, so the session directory wins whenever the host reports one.
+ */
+function toolRoot(deps: ToolDeps, context: ToolContext): string {
+  const directory = context.directory
+  return typeof directory === "string" && directory.trim() !== "" ? directory : deps.root
+}
+
 export interface ToolDefinition {
   name: string
   description: string
@@ -30,10 +62,7 @@ export interface ToolDefinition {
    * is why configuration read and write are separate tools.
    */
   permission?: string
-  execute: (
-    input: Record<string, unknown>,
-    context: { signal?: AbortSignal; progress?: (m: unknown) => Promise<void> },
-  ) => Promise<{ output: string; metadata?: Record<string, unknown> }>
+  execute: (input: Record<string, unknown>, context: ToolContext) => Promise<{ output: string; metadata?: Record<string, unknown> }>
 }
 
 const SEARCH_DESCRIPTION = `Find code snippets by semantic meaning in the project's code index.
@@ -119,9 +148,10 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         },
         ["query"],
       ),
-      async execute(input) {
+      async execute(input, context) {
         const settings = await deps.getSettings()
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const query = typeof input.query === "string" ? input.query.trim() : ""
         if (!query) throw new Error("query is required")
         const pathPrefix = typeof input.path === "string" && input.path.trim() !== "" ? input.path.trim() : undefined
@@ -130,13 +160,13 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         // Skipped while indexing is paused, otherwise a search would keep writing.
         if (settings.autoRefresh && settings.enabled !== false) {
           try {
-            await maybeAutoRefresh(deps, settings, qdrant)
+            await maybeAutoRefresh(root, deps, settings, qdrant)
           } catch {
             // Auto-refresh failures never block the search.
           }
         }
 
-        const outcome = await searchCode({ qdrant, kv: deps.kv, root: deps.root, settings }, query, pathPrefix)
+        const outcome = await searchCode({ qdrant, kv: deps.kv, root, settings }, query, pathPrefix)
         const { hits, meta, errors } = outcome
         if (hits.length === 0) {
           const lines: string[] = [`No results for "${query}" in ${meta.root}.`]
@@ -184,10 +214,11 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
       input: jsonSchema({
         checkFreshness: { type: "boolean", description: "Scan the workspace to compute file freshness (slower)." },
       }),
-      async execute(input) {
+      async execute(input, context) {
         const settings = await deps.getSettings()
         const qdrant = createSettingsQdrant(settings)
-        const status = await getStatus({ qdrant, kv: deps.kv, root: deps.root, settings }, { checkFreshness: input.checkFreshness !== false })
+        const root = toolRoot(deps, context)
+        const status = await getStatus({ qdrant, kv: deps.kv, root, settings }, { checkFreshness: input.checkFreshness !== false })
         const lines: string[] = [
           `Workspace: ${status.root}`,
           `Qdrant: ${status.qdrant.url} (${status.qdrant.reachable ? "reachable" : "UNREACHABLE"})`,
@@ -224,11 +255,12 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const maxFiles = typeof input.maxFiles === "number" && input.maxFiles > 0 ? Math.floor(input.maxFiles) : undefined
         const report = await runIndex(
           {
             kv: deps.kv,
-            root: deps.root,
+            root,
             settings,
             qdrant,
             onProgress: makeProgress(context),
@@ -236,7 +268,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
           { mode: "refresh", maxFiles },
         )
         const summary = formatReport("refresh", report)
-        const warning = scopeWarning(deps.root)
+        const warning = scopeWarning(root)
         return {
           output: warning ? `${warning}\n${summary}` : summary,
           metadata: report as unknown as Record<string, unknown>,
@@ -254,10 +286,11 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const report = await runIndex(
           {
             kv: deps.kv,
-            root: deps.root,
+            root,
             settings,
             qdrant,
             onProgress: makeProgress(context),
@@ -265,7 +298,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
           { mode: "build", rebuild: input.rebuild === true, skipImport: input.skipImport === true },
         )
         const summary = formatReport("build", report)
-        const warning = scopeWarning(deps.root)
+        const warning = scopeWarning(root)
         return {
           output: warning ? `${warning}\n${summary}` : summary,
           metadata: report as unknown as Record<string, unknown>,
@@ -283,7 +316,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
-        const root = deps.root
+        const root = toolRoot(deps, context)
         const store = createOwnStore(settings, root)
         const profile = { provider: settings.provider, modelId: settings.modelId, dimension: settings.dimension }
 
@@ -304,8 +337,15 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         }
         await store.ensure(dimension, targetProfile)
 
-        const sources = await discoverKiloSources(root, { qdrant, targetProfile })
-        if (sources.length === 0) throw new Error("No Kilo Code index found for this workspace (neither Qdrant collection nor local LanceDB)")
+        const problems: string[] = []
+        const sources = await discoverKiloSources(root, { qdrant, targetProfile, onProblem: (m) => problems.push(m) })
+        if (sources.length === 0) {
+          throw new Error(
+            problems.length > 0
+              ? `No Kilo Code index found for ${root}. ${problems.join(" · ")}`
+              : "No Kilo Code index found for this workspace (neither Qdrant collection nor local LanceDB)",
+          )
+        }
         const wanted = typeof input.source === "string" && input.source.trim() !== "" ? input.source.trim() : undefined
         const source = wanted ? sources.find((item) => item.name === wanted) : (sources.find((item) => item.compatible) ?? sources[0])
         if (!source) throw new Error(`Source not found: ${wanted}. Available: ${sources.map((s) => s.name).join(", ")}`)
@@ -362,12 +402,17 @@ function assertIndexingEnabled(settings: { enabled?: boolean }): void {
 /** Max changed files that trigger an inline refresh on search. */
 const AUTO_REFRESH_MAX_FILES = 200
 
-async function maybeAutoRefresh(deps: ToolDeps, settings: IndexingSettings, qdrant: Qdrant): Promise<void> {
+async function maybeAutoRefresh(
+  root: string,
+  deps: ToolDeps,
+  settings: IndexingSettings,
+  qdrant: Qdrant,
+): Promise<void> {
   // Cheap pre-check: diff the manifest against a bounded workspace scan.
   const { loadManifest, diffFiles } = await import("./manifest.ts")
   const { scanWorkspace } = await import("./scanner.ts")
-  const manifest = await loadManifest(deps.kv, deps.root)
-  const scan = await scanWorkspace(deps.root, {
+  const manifest = await loadManifest(deps.kv, root)
+  const scan = await scanWorkspace(root, {
     extensions: settings.fileExtensions,
     maxFileSizeBytes: settings.maxFileSizeBytes,
     maxFiles: AUTO_REFRESH_MAX_FILES + 1,
@@ -376,7 +421,7 @@ async function maybeAutoRefresh(deps: ToolDeps, settings: IndexingSettings, qdra
   const delta = diff.added.length + diff.maybeStale.length + diff.deleted.length
   if (delta === 0 || delta > AUTO_REFRESH_MAX_FILES) return
   await runIndex(
-    { kv: deps.kv, root: deps.root, settings, qdrant },
+    { kv: deps.kv, root, settings, qdrant },
     { mode: "refresh", maxFiles: AUTO_REFRESH_MAX_FILES },
   )
 }

package/src/types.ts

@@ -22,6 +22,38 @@ export interface ModelProfile {
   dimension: number
   scoreThreshold?: number
   queryPrefix?: string
+  /**
+   * Largest input the model accepts, in tokens.
+   *
+   * Not the same for every model, and the spread is wide: `mxbai-embed-large`
+   * takes 512 while `voyage-code-4` takes 32,000. Sizing every request by one
+   * global constant silently truncates every chunk past the smallest model's
+   * limit, and that truncated vector is stored as if it covered the whole
+   * function.
+   */
+  maxInputTokens?: number
+  /** Documented ceiling on items in one request, where the provider publishes one. */
+  maxBatchItems?: number
+  /** Documented ceiling on tokens in one request, where the provider publishes one. */
+  maxBatchTokens?: number
+  /**
+   * Whether the provider documents its output as already L2-normalised.
+   *
+   * The provider's claim, not a measurement we rely on. Mistral documents its
+   * embeddings as "norm 1" and a live call measured 0.9913, which is why every
+   * comparison here uses cosine regardless: it is correct either way, and this
+   * field exists only so a future fast path knows whether a bare dot product
+   * would be equivalent.
+   */
+  normalized?: boolean
+  /**
+   * Marks a model we know about that Kilo's registry does not.
+   *
+   * The catalog is a mirror, so that query embeddings stay interchangeable with
+   * a Kilo index. An entry with no Kilo counterpart is still useful, but it can
+   * never be import-compatible, and the status report has to be able to say so.
+   */
+  kiloMirror?: boolean
 }
 
 export interface ProviderCredentials {

package/tui/settings-page-data.ts

@@ -24,8 +24,8 @@ export 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
 }
 
@@ -43,15 +43,23 @@ export interface StatusView {
   recommendation: string
 }
 
+/**
+ * The RPC slice this page needs.
+ *
+ * Every workspace-scoped method takes an optional `directory`. Callers normally
+ * never pass one: `bindWorkspace` injects it into the client the TUI hands this
+ * page, so the call sites below cannot forget it. The field stays on the types
+ * because the bound client is what actually sends it.
+ */
 export interface SettingsPageRpc {
   "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: KiloSourceView[] }>
-  "status.get": (input: { checkFreshness?: boolean }) => Promise<StatusView>
-  "index.build": (input: { rebuild?: boolean; skipImport?: boolean }) => Promise<{ summary: string; error?: string }>
-  "index.refresh": (input: { maxFiles?: number }) => Promise<{ summary: string; error?: string }>
-  "index.import": (input: { source?: string; rebuild?: boolean }) => Promise<{ summary: string; error?: string }>
+  "settings.test": (input: { target: "qdrant" | "lancedb" | "provider" | "kilo"; directory?: string }) => Promise<{ ok: boolean; message: string }>
+  "kilo.discover": (input?: { directory?: string }) => Promise<{ sources: KiloSourceView[]; problems?: string[] }>
+  "status.get": (input: { checkFreshness?: boolean; directory?: string }) => Promise<StatusView>
+  "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 }>
+  "index.import": (input: { source?: string; rebuild?: boolean; directory?: string }) => Promise<{ summary: string; error?: string }>
   "workspaces.list": (input: Record<string, never>) => Promise<{ workspaces: WorkspaceRow[] }>
   "workspace.forget": (input: { store: string }) => Promise<{ ok: boolean; reason?: "refused" | "failed"; summary: string; pointsDeleted: number | null }>
 }
@@ -78,6 +86,14 @@ export interface SettingsPageProps {
 export interface SettingsPageData {
   settings: SettingsView
   sources: KiloSourceView[]
+  /**
+   * Sources that exist but could not be read.
+   *
+   * Kept apart from `sources` on purpose: an empty list with problems is a
+   * different answer from an empty list without them, and the page has to be
+   * able to tell the user which one they are looking at.
+   */
+  problems: string[]
   status: StatusView
   /** Indexed workspaces, so the page can show what exists on disk. */
   workspaces: WorkspacesView
@@ -101,8 +117,7 @@ export const UNKNOWN_SETTINGS: SettingsView = {
   enabled: false,
   autoRefresh: false,
   searchMaxResults: 0,
-  hasMistralKey: false,
-  hasOpenAiKey: false,
+  configuredProviders: [],
   settingsFile: "(unavailable)",
 }
 
@@ -117,7 +132,7 @@ export const UNKNOWN_SETTINGS: SettingsView = {
 export async function loadSettingsPageData(rpc: SettingsPageRpc): Promise<SettingsPageData> {
   const [settingsResponse, sourcesResponse, status, workspaces] = await Promise.all([
     rpc["settings.get"]({}).catch(() => ({ settings: UNKNOWN_SETTINGS })),
-    rpc["kilo.discover"]().catch(() => ({ sources: [] as KiloSourceView[] })),
+    rpc["kilo.discover"]({}).catch(() => ({ sources: [] as KiloSourceView[], problems: [] as string[] })),
     rpc["status.get"]({ checkFreshness: false }).catch(() => ({ summary: "(status unavailable)", recommendation: "" })),
     // loadWorkspaces already degrades to an empty view, so it cannot reject.
     loadWorkspaces(rpc),
@@ -125,6 +140,7 @@ export async function loadSettingsPageData(rpc: SettingsPageRpc): Promise<Settin
   return {
     settings: settingsResponse.settings,
     sources: sourcesResponse.sources,
+    problems: sourcesResponse.problems ?? [],
     status,
     workspaces,
   }
@@ -149,10 +165,10 @@ export function configRows(settings: SettingsView): ConfigRow[] {
     { label: "Max results", value: String(settings.searchMaxResults) },
     { label: "Settings file", value: settings.settingsFile },
   ]
-  const keys: string[] = []
-  if (settings.hasMistralKey) keys.push("mistral")
-  if (settings.hasOpenAiKey) keys.push("openai")
-  rows.push({ label: "API keys", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
+  // Derived from the server's list rather than a pair of booleans, so a
+  // provider added anywhere else shows up here without a change to this file.
+  const keys = settings.configuredProviders
+  rows.push({ label: "Credentials", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
   return rows
 }
 

package/tui/settings-page.tsx

@@ -75,7 +75,13 @@ export function SettingsPage(props: SettingsPageProps): JSX.Element {
     const action = PAGE_ACTIONS.find((entry) => entry.id === id)
     if (!action) return
     if (action.kind === "source" && (data()?.sources ?? []).length === 0) {
-      props.toast("No Kilo index found for this workspace", "info")
+      // Report the reason when there is one: an index that exists but cannot be
+      // read is fixed by installing something, not by building one.
+      const problems = data()?.problems ?? []
+      props.toast(
+        problems.length > 0 ? `No importable Kilo index: ${problems.join(" · ")}` : "No Kilo index found for this workspace",
+        problems.length > 0 ? "error" : "info",
+      )
       return
     }
     // No source passed: the server picks the first compatible one. Use the

package/tui/workspace-rpc.ts

@@ -0,0 +1,98 @@
+/**
+ * Binds the caller's workspace directory to every workspace-scoped RPC.
+ *
+ * The server plugin is instantiated for the directory the service runs in, not
+ * the one the user has open, so a call that omits `directory` silently acts on
+ * the wrong workspace. Every method below takes one for that reason — and every
+ * one that takes one has to be passed it, which is a per-call-site obligation
+ * that was already forgotten once (the palette and the settings page read and
+ * wrote the service's index while the footer, using the same client, correctly
+ * reported the user's).
+ *
+ * Injecting the directory here rather than at each call site makes that class
+ * of bug impossible to reintroduce: there is one place that knows which methods
+ * are workspace-scoped, and adding a method to that list is the only edit a new
+ * workspace-scoped RPC needs.
+ */
+
+/** RPC methods that act on one workspace and therefore need a directory. */
+export const WORKSPACE_SCOPED_METHODS = [
+  "settings.test",
+  "kilo.discover",
+  "status.get",
+  "index.build",
+  "index.refresh",
+  "index.import",
+] as const
+
+/**
+ * The workspace-agnostic methods are deliberately absent: they span every
+ * workspace, so naming one would misreport what they act on. In this client
+ * that is `settings.get` and `settings.set`; the wider client adds
+ * `workspaces.list` and `workspace.forget`, which are global for the same
+ * reason.
+ */
+function isWorkspaceScoped(method: string): boolean {
+  return (WORKSPACE_SCOPED_METHODS as readonly string[]).includes(method)
+}
+
+/**
+ * Wrap `client` so the listed methods carry `directory` unless the caller set
+ * one explicitly.
+ *
+ * An explicit `directory` always wins: the footer reads reactively and a test
+ * (or a future caller) may legitimately want to ask about a different workspace
+ * than the one the user is sitting in.
+ *
+ * The real client methods take a second `options` argument (cancellation
+ * signals and headers), so the wrapper forwards everything it is given rather
+ * than modelling one signature and silently dropping the rest.
+ *
+ * Reads `Object.keys` on the client, which is what the host produces: its RPC
+ * client is built with `Object.fromEntries`, so every method is an own
+ * enumerable key. A client whose methods were reachable only through a proxy
+ * would yield an empty wrapper, and every call would fail loudly rather than
+ * quietly acting on the wrong workspace.
+ */
+export function bindWorkspace<T extends Record<string, unknown>>(client: T, workspace: () => string | undefined): T {
+  const bound: Record<string, unknown> = {}
+
+  for (const key of Object.keys(client)) {
+    const method = client[key]
+    if (typeof method !== "function" || !isWorkspaceScoped(key)) {
+      bound[key] = method
+      continue
+    }
+
+    bound[key] = (...args: unknown[]) => {
+      const input = args[0]
+      // An explicit directory wins, so it is checked before the workspace is
+      // resolved: a caller that already knows which workspace it means must not
+      // depend on the accessors answering, or on them answering at all.
+      const explicit =
+        input && typeof input === "object" && !Array.isArray(input)
+          ? (input as { directory?: unknown }).directory
+          : undefined
+      if (typeof explicit === "string" && explicit.trim() !== "") {
+        return (method as (...args: unknown[]) => unknown)(...args)
+      }
+
+      const directory = workspace()
+      if (typeof directory !== "string" || directory.trim() === "") {
+        // No workspace to name: the server falls back to its own directory,
+        // which is the only thing it can do.
+        return (method as (...args: unknown[]) => unknown)(...args)
+      }
+
+      return (method as (...args: unknown[]) => unknown)(
+        {
+          ...(input && typeof input === "object" && !Array.isArray(input) ? input : {}),
+          directory,
+        },
+        ...args.slice(1),
+      )
+    }
+  }
+
+  return bound as T
+}