saeeol 1.3.0 → 1.3.1

package/test/saeeol/indexing-auth.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+import {
+  hasSaeeolIndexingAuth,
+  resolveSaeeolIndexingAuth,
+  shouldDefaultIndexingToSaeeol,
+} from "../../src/overlay/indexing-auth"
+
+describe("Saeeol indexing auth resolution", () => {
+  test("detects auth from explicit indexing Saeeol config", () => {
+    const auth = resolveSaeeolIndexingAuth({
+      config: { indexing: { saeeol: { apiKey: "idx-token", baseUrl: "https://idx.test", organizationId: "org_idx" } } },
+    })
+
+    expect(auth).toEqual({ apiKey: "idx-token", baseUrl: "https://idx.test", organizationId: "org_idx" })
+    expect(hasSaeeolIndexingAuth({ config: { indexing: { saeeol: { apiKey: "idx-token" } } } })).toBe(true)
+  })
+
+  test("detects auth from provider config, provider state, auth storage, and env", () => {
+    expect(
+      resolveSaeeolIndexingAuth({ config: { provider: { saeeol: { options: { apiKey: "cfg-token" } } } } }).apiKey,
+    ).toBe("cfg-token")
+    expect(resolveSaeeolIndexingAuth({ provider: { options: { saeeolToken: "provider-token" } } }).apiKey).toBe(
+      "provider-token",
+    )
+    expect(resolveSaeeolIndexingAuth({ auth: { type: "oauth", access: "oauth-token", accountId: "org_oauth" } })).toEqual(
+      {
+        apiKey: "oauth-token",
+        organizationId: "org_oauth",
+      },
+    )
+    expect(resolveSaeeolIndexingAuth({ env: { SAEEOL_API_KEY: "env-token", SAEEOL_ORG_ID: "org_env" } })).toEqual({
+      apiKey: "env-token",
+      organizationId: "org_env",
+    })
+  })
+
+  test("defaults to Saeeol only when no provider or other embedder config is present", () => {
+    const auth = { apiKey: "saeeol-token" }
+
+    expect(shouldDefaultIndexingToSaeeol({}, auth)).toBe(true)
+    expect(shouldDefaultIndexingToSaeeol({ provider: "openai" }, auth)).toBe(false)
+    expect(shouldDefaultIndexingToSaeeol({ openai: { apiKey: "openai-key" } }, auth)).toBe(false)
+    expect(shouldDefaultIndexingToSaeeol({ ollama: { baseUrl: "http://localhost:11434" } }, auth)).toBe(false)
+  })
+})

package/test/saeeol/indexing-feature.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test"
+import {
+  ensureIndexingPlugin,
+  indexingEnabled,
+  INDEXING_PLUGIN,
+  resolveIndexingPlugin,
+} from "../../src/overlay/indexing-feature"
+
+describe("indexing plugin helpers", () => {
+  test("detects plugin-enabled configs", () => {
+    expect(indexingEnabled({ plugin: ["global-plugin"] })).toBe(false)
+    expect(indexingEnabled({ plugin: [INDEXING_PLUGIN] })).toBe(false)
+    expect(indexingEnabled({ plugin: [INDEXING_PLUGIN], experimental: { semantic_indexing: false } })).toBe(false)
+    expect(indexingEnabled({ plugin: [INDEXING_PLUGIN], experimental: { semantic_indexing: true } })).toBe(true)
+    expect(
+      indexingEnabled({ plugin: ["@saeeol/indexing@1.0.0"], experimental: { semantic_indexing: true } }),
+    ).toBe(true)
+  })
+
+  test("adds indexing plugin when present but missing from config", () => {
+    const list = ensureIndexingPlugin(["global-plugin"], INDEXING_PLUGIN)
+    expect(list).toContain("global-plugin")
+    expect(list).toContain(INDEXING_PLUGIN)
+  })
+
+  test("does not add duplicate indexing plugin", () => {
+    const list = ensureIndexingPlugin(["@saeeol/indexing@1.0.0"], INDEXING_PLUGIN)
+    expect(list).toEqual(["@saeeol/indexing@1.0.0"])
+  })
+
+  test("skips hard-enable when plugin package is unavailable", () => {
+    const list = ensureIndexingPlugin(["global-plugin"], undefined)
+    expect(list).toEqual(["global-plugin"])
+  })
+
+  test("falls back to package marker when resolver fails", () => {
+    const plugin = resolveIndexingPlugin({
+      resolve() {
+        throw new Error("missing")
+      },
+    })
+    expect(plugin).toBe(INDEXING_PLUGIN)
+  })
+})

package/test/saeeol/indexing-label.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test"
+import { formatIndexingLabel } from "../../src/overlay/indexing-label"
+
+describe("indexing label", () => {
+  test("formats in-progress status with counts", () => {
+    expect(
+      formatIndexingLabel({
+        state: "In Progress",
+        message: "",
+        processedFiles: 21,
+        totalFiles: 50,
+        percent: 42,
+      }),
+    ).toBe("IDX 42% 21/50")
+  })
+
+  test("formats indeterminate in-progress status without 0/0 counts", () => {
+    expect(
+      formatIndexingLabel({
+        state: "In Progress",
+        message: "",
+        processedFiles: 0,
+        totalFiles: 0,
+        percent: 0,
+      }),
+    ).toBe("IDX In Progress")
+  })
+
+  test("formats error status with backend message", () => {
+    expect(
+      formatIndexingLabel({
+        state: "Error",
+        message: "Indexing failed.",
+        processedFiles: 0,
+        totalFiles: 0,
+        percent: 0,
+      }),
+    ).toBe("IDX Indexing failed.")
+  })
+
+  test("formats stable states", () => {
+    expect(
+      formatIndexingLabel({
+        state: "Complete",
+        message: "",
+        processedFiles: 1,
+        totalFiles: 1,
+        percent: 100,
+      }),
+    ).toBe("IDX Complete")
+    expect(
+      formatIndexingLabel({
+        state: "Disabled",
+        message: "Indexing disabled.",
+        processedFiles: 0,
+        totalFiles: 0,
+        percent: 0,
+      }),
+    ).toBe("IDX Disabled")
+    expect(
+      formatIndexingLabel({
+        state: "Standby",
+        message: "Ready.",
+        processedFiles: 0,
+        totalFiles: 0,
+        percent: 0,
+      }),
+    ).toBe("IDX Standby")
+  })
+})

package/test/saeeol/indexing-startup.test.ts

@@ -0,0 +1,381 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test"
+import { CodeIndexManager } from "@saeeol/indexing/engine"
+import type { Config } from "../../src/config/config"
+import { GlobalBus } from "../../src/bus/global"
+import { getBootstrapRunEffect } from "../../src/effect/app-runtime"
+import { SaeeolIndexing } from "../../src/overlay/indexing"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import * as Log from "@saeeol/core/util/log"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+const fetch = global.fetch
+
+const cfg: Partial<Config.Info> = {
+  plugin: ["@saeeol/indexing"],
+  experimental: {
+    semantic_indexing: true,
+  },
+  indexing: {
+    enabled: true,
+    provider: "ollama",
+    vectorStore: "qdrant",
+    ollama: {
+      baseUrl: "http://127.0.0.1:1",
+    },
+  },
+}
+
+const off: Partial<Config.Info> = {
+  plugin: ["@saeeol/indexing"],
+  experimental: {
+    semantic_indexing: false,
+  },
+  indexing: {
+    enabled: true,
+    provider: "ollama",
+    vectorStore: "qdrant",
+    ollama: {
+      baseUrl: "http://127.0.0.1:1",
+    },
+  },
+}
+const saeeol: Partial<Config.Info> = {
+  plugin: ["@saeeol/indexing"],
+  experimental: {
+    semantic_indexing: true,
+  },
+  indexing: {
+    enabled: true,
+    vectorStore: "qdrant",
+  },
+}
+const implicitOpenAi: Partial<Config.Info> = {
+  plugin: ["@saeeol/indexing"],
+  experimental: {
+    semantic_indexing: true,
+  },
+  indexing: {
+    enabled: true,
+    vectorStore: "qdrant",
+    openai: {
+      apiKey: "openai-token",
+    },
+  },
+}
+const configDir = process.env["SAEEOL_CONFIG_DIR"]
+const disabled = process.env["SAEEOL_DISABLE_CODEBASE_INDEXING"]
+const error = new Error("test indexing initialization failed")
+
+async function wait(read: () => Promise<SaeeolIndexing.Status>, state: SaeeolIndexing.Status["state"]) {
+  for (const _ of Array.from({ length: 100 })) {
+    const status = await read()
+    if (status.state === state) return status
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  throw new Error(`indexing did not reach ${state}`)
+}
+
+async function called(init: ReturnType<typeof spyOn<CodeIndexManager, "initialize">>) {
+  for (const _ of Array.from({ length: 100 })) {
+    if (init.mock.calls.length > 0) return
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  throw new Error("indexing initialization did not start")
+}
+
+afterEach(async () => {
+  if (configDir === undefined) delete process.env["SAEEOL_CONFIG_DIR"]
+  else process.env["SAEEOL_CONFIG_DIR"] = configDir
+  if (disabled === undefined) delete process.env["SAEEOL_DISABLE_CODEBASE_INDEXING"]
+  else process.env["SAEEOL_DISABLE_CODEBASE_INDEXING"] = disabled
+  global.fetch = fetch
+  await disposeAllInstances()
+})
+
+describe("indexing startup degradation", () => {
+  test("keeps server routes alive when indexing initialization fails", async () => {
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockRejectedValue(error)
+
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+
+    try {
+      const app = Server.Default().app
+
+      const config = await app.request("/config", {
+        headers: {
+          "x-saeeol-directory": tmp.path,
+        },
+      })
+      expect(config.status).toBe(200)
+
+      const body = await wait(async () => {
+        const status = await app.request("/indexing/status", {
+          headers: {
+            "x-saeeol-directory": tmp.path,
+          },
+        })
+        expect(status.status).toBe(200)
+        return status.json()
+      }, "Error")
+
+      expect(body).toMatchObject({
+        state: "Error",
+      })
+      expect(body.message).toContain("Failed to initialize: test indexing initialization failed")
+    } finally {
+      init.mockRestore()
+    }
+  })
+
+  test("reports routes as in progress while initialization is in flight", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const gate = Promise.withResolvers<{ requiresRestart: boolean }>()
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockImplementation(() => gate.promise)
+
+    try {
+      const app = Server.Default().app
+
+      const config = await app.request("/config", {
+        headers: {
+          "x-saeeol-directory": tmp.path,
+        },
+      })
+      expect(config.status).toBe(200)
+      await called(init)
+
+      const status = await app.request("/indexing/status", {
+        headers: {
+          "x-saeeol-directory": tmp.path,
+        },
+      })
+      expect(status.status).toBe(200)
+
+      const body = await status.json()
+      expect(body).toMatchObject({
+        state: "In Progress",
+        message: "Indexing is initializing.",
+      })
+    } finally {
+      gate.resolve({ requiresRestart: false })
+      init.mockRestore()
+    }
+  })
+
+  test("does not publish initialized status after in-flight startup is disposed", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const gate = Promise.withResolvers<{ requiresRestart: boolean }>()
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockImplementation(() => gate.promise)
+    const events: SaeeolIndexing.Status[] = []
+    const on = (data: {
+      directory?: string
+      payload?: { type?: string; properties?: { status?: SaeeolIndexing.Status } }
+    }) => {
+      if (data.directory !== tmp.path) return
+      if (data.payload?.type !== SaeeolIndexing.Event.type) return
+      if (data.payload.properties?.status) events.push(data.payload.properties.status)
+    }
+    GlobalBus.on("event", on)
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          await called(init)
+          expect((await SaeeolIndexing.current()).state).toBe("In Progress")
+        },
+      })
+
+      await disposeAllInstances()
+      gate.resolve({ requiresRestart: false })
+      await new Promise((resolve) => setTimeout(resolve, 0))
+
+      expect(events.some((status) => status.state === "Complete" || status.state === "Standby")).toBe(false)
+    } finally {
+      GlobalBus.off("event", on)
+      gate.resolve({ requiresRestart: false })
+      init.mockRestore()
+    }
+  })
+
+  test("keeps degraded indexing queryable but unavailable", async () => {
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockRejectedValue(error)
+
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          const status = await wait(() => SaeeolIndexing.current(), "Error")
+
+          expect(status.state).toBe("Error")
+          expect(status.message).toContain("Failed to initialize: test indexing initialization failed")
+          expect(await SaeeolIndexing.available()).toBe(false)
+          expect(SaeeolIndexing.ready()).toBe(false)
+          expect(await SaeeolIndexing.search("boot failure")).toEqual([])
+        },
+      })
+    } finally {
+      init.mockRestore()
+    }
+  })
+
+  test("reports not ready while initialization is in flight", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const gate = Promise.withResolvers<{ requiresRestart: boolean }>()
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockImplementation(() => gate.promise)
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          await called(init)
+
+          expect(init).toHaveBeenCalled()
+          expect(SaeeolIndexing.ready()).toBe(false)
+          expect(await SaeeolIndexing.available()).toBe(false)
+          expect(await SaeeolIndexing.search("boot failure")).toEqual([])
+        },
+      })
+    } finally {
+      gate.resolve({ requiresRestart: false })
+      init.mockRestore()
+    }
+  })
+
+  test("stays disabled when semantic indexing flag is off", async () => {
+    await using tmp = await tmpdir({ git: true, config: off })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const init = spyOn(CodeIndexManager.prototype, "initialize")
+
+    await Instance.provide({
+      directory: tmp.path,
+      init: await getBootstrapRunEffect(),
+      fn: async () => {
+        const status = await SaeeolIndexing.current()
+
+        expect(status).toMatchObject({
+          state: "Disabled",
+          message: "Semantic indexing is disabled. Enable it in the Experimental settings.",
+        })
+        expect(await SaeeolIndexing.available()).toBe(false)
+        expect(SaeeolIndexing.ready()).toBe(false)
+        expect(await SaeeolIndexing.search("flag off")).toEqual([])
+        expect(init).not.toHaveBeenCalled()
+      },
+    })
+  })
+
+  test("enriches Saeeol provider config from env auth", async () => {
+    global.fetch = (() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            defaultModel: "mistralai/mistral-embed-2312",
+            models: [
+              { id: "mistralai/mistral-embed-2312", name: "Mistral Embed 2312", dimension: 1024, scoreThreshold: 0.35 },
+            ],
+            aliases: {},
+          }),
+        ),
+      )) as unknown as typeof global.fetch
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockResolvedValue({ requiresRestart: false })
+    const key = process.env.SAEEOL_API_KEY
+    const org = process.env.SAEEOL_ORG_ID
+
+    await using tmp = await tmpdir({ git: true, config: saeeol })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    process.env.SAEEOL_API_KEY = "saeeol-token"
+    process.env.SAEEOL_ORG_ID = "org_123"
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          await called(init)
+          expect(init.mock.calls[0]?.[0]).toMatchObject({
+            embedderProvider: "saeeol",
+            saeeolApiKey: "saeeol-token",
+            saeeolOrganizationId: "org_123",
+            modelId: "mistralai/mistral-embed-2312",
+            modelDimension: 1024,
+            searchMinScore: 0.35,
+          })
+        },
+      })
+    } finally {
+      if (key === undefined) delete process.env.SAEEOL_API_KEY
+      else process.env.SAEEOL_API_KEY = key
+      if (org === undefined) delete process.env.SAEEOL_ORG_ID
+      else process.env.SAEEOL_ORG_ID = org
+      init.mockRestore()
+    }
+  })
+
+  test("does not default to Saeeol when an existing provider config is present", async () => {
+    const init = spyOn(CodeIndexManager.prototype, "initialize").mockResolvedValue({ requiresRestart: false })
+    const key = process.env.SAEEOL_API_KEY
+
+    await using tmp = await tmpdir({ git: true, config: implicitOpenAi })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    process.env.SAEEOL_API_KEY = "saeeol-token"
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          await called(init)
+          expect(init.mock.calls[0]?.[0]).toMatchObject({
+            embedderProvider: "openai",
+            openAiKey: "openai-token",
+          })
+        },
+      })
+    } finally {
+      if (key === undefined) delete process.env.SAEEOL_API_KEY
+      else process.env.SAEEOL_API_KEY = key
+      init.mockRestore()
+    }
+  })
+
+  test("stays disabled when VS Code starts without a workspace folder", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    process.env["SAEEOL_DISABLE_CODEBASE_INDEXING"] = "vscode-no-workspace"
+    const init = spyOn(CodeIndexManager.prototype, "initialize")
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        init: await getBootstrapRunEffect(),
+        fn: async () => {
+          const status = await SaeeolIndexing.current()
+
+          expect(status).toMatchObject({
+            state: "Disabled",
+            message: "Codebase indexing is disabled because no workspace folder is open in VS Code.",
+          })
+          expect(await SaeeolIndexing.available()).toBe(false)
+          expect(SaeeolIndexing.ready()).toBe(false)
+          expect(await SaeeolIndexing.search("no workspace")).toEqual([])
+          expect(init).not.toHaveBeenCalled()
+        },
+      })
+    } finally {
+      init.mockRestore()
+    }
+  })
+})

package/test/saeeol/indexing-worktree.test.ts

@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import type { Config } from "../../src/config/config"
+import { getBootstrapRunEffect } from "../../src/effect/app-runtime"
+import { SaeeolIndexing } from "../../src/overlay/indexing"
+import { Instance } from "../../src/project/instance"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+const cfg: Partial<Config.Info> = {
+  plugin: ["@saeeol/indexing"],
+  experimental: {
+    semantic_indexing: true,
+  },
+  indexing: {
+    enabled: true,
+    provider: "ollama",
+    vectorStore: "qdrant",
+    ollama: {
+      baseUrl: "http://127.0.0.1:1",
+    },
+  },
+}
+
+const configDir = process.env["SAEEOL_CONFIG_DIR"]
+
+afterEach(async () => {
+  if (configDir === undefined) delete process.env["SAEEOL_CONFIG_DIR"]
+  else process.env["SAEEOL_CONFIG_DIR"] = configDir
+  await disposeAllInstances()
+})
+
+describe("indexing worktree disable", () => {
+  test("returns disabled status in .saeeol/worktrees paths", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const dir = `${tmp.path}/.saeeol/worktrees/feature`
+    await mkdir(dir, { recursive: true })
+
+    await Instance.provide({
+      directory: dir,
+      init: await getBootstrapRunEffect(),
+      fn: async () => {
+        const status = await SaeeolIndexing.current()
+
+        expect(status.state).toBe("Disabled")
+        expect(status.message).toBe("Indexing is disabled in worktree sessions. Use the main workspace for indexing.")
+        expect(await SaeeolIndexing.available()).toBe(false)
+        expect(SaeeolIndexing.ready()).toBe(false)
+        expect(await SaeeolIndexing.search("worktree")).toEqual([])
+      },
+    })
+  })
+
+  test("returns disabled status in legacy .saeeol/worktrees paths", async () => {
+    await using tmp = await tmpdir({ git: true, config: cfg })
+    process.env["SAEEOL_CONFIG_DIR"] = tmp.path
+    const dir = `${tmp.path}/.saeeol/worktrees/feature`
+    await mkdir(dir, { recursive: true })
+
+    await Instance.provide({
+      directory: dir,
+      init: await getBootstrapRunEffect(),
+      fn: async () => {
+        const status = await SaeeolIndexing.current()
+
+        expect(status.state).toBe("Disabled")
+        expect(status.message).toBe("Indexing is disabled in worktree sessions. Use the main workspace for indexing.")
+        expect(await SaeeolIndexing.available()).toBe(false)
+        expect(SaeeolIndexing.ready()).toBe(false)
+      },
+    })
+  })
+})