saeeol 1.2.5 → 1.2.7

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

@@ -1,45 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,381 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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)
-      },
-    })
-  })
-})