saeeol 1.3.0 → 1.4.0

package/test/saeeol/tool-registry-indexing.test.ts

@@ -0,0 +1,236 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test"
+import { Effect, Layer, Schema } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import { Agent } from "../../src/agent/agent"
+import { SaeeolIndexing } from "../../src/overlay/indexing"
+import { SaeeolBootstrap } from "../../src/overlay/bootstrap"
+import { SaeeolSessions } from "../../src/sessions/sessions"
+import { SaeeolToolRegistry } from "../../src/overlay/tool/registry"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { ToolRegistry } from "../../src/tool/registry"
+import type * as Tool from "../../src/tool/tool"
+import { Instance } from "../../src/project/instance"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
+import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
+import { testEffect } from "../lib/effect"
+
+const node = CrossSpawnSpawner.defaultLayer
+const it = testEffect(Layer.mergeAll(Agent.defaultLayer, ToolRegistry.defaultLayer, node))
+const ref = {
+  providerID: ProviderID.make("test"),
+  modelID: ModelID.make("test-model"),
+}
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+describe("saeeol tool registry indexing", () => {
+  const logger = Log.create({ service: "saeeol-tool-registry" })
+
+  it.live("omits semantic_search without waiting for slow indexing startup", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const avail = spyOn(SaeeolIndexing, "available").mockImplementation(() => new Promise<boolean>(() => {}))
+
+          try {
+            const registry = yield* ToolRegistry.Service
+            const ids = yield* registry.ids()
+
+            expect(ids).not.toContain("semantic_search")
+            expect(ids).toContain("question")
+            expect(ids).toContain("read")
+            expect(ids).toContain("suggest")
+            expect(avail).not.toHaveBeenCalled()
+          } finally {
+            avail.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("keeps non-indexing tools when indexing readiness throws", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const err = new Error("ready failed")
+          const ready = spyOn(SaeeolIndexing, "ready").mockImplementation(() => {
+            throw err
+          })
+          const warn = spyOn(logger, "warn").mockImplementation(() => {})
+
+          try {
+            const registry = yield* ToolRegistry.Service
+            const ids = yield* registry.ids()
+
+            expect(ids).not.toContain("semantic_search")
+            expect(ids).toContain("question")
+            expect(ids).toContain("read")
+            expect(ids).toContain("suggest")
+            expect(warn.mock.calls[0]?.[0]).toBe("semantic search unavailable")
+            expect(warn.mock.calls[0]?.[1]?.err).toBeDefined()
+          } finally {
+            ready.mockRestore()
+            warn.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("keeps non-indexing tools when indexing readiness rejects", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const err = new Error("ready rejected")
+          const ready = spyOn(SaeeolIndexing, "ready").mockImplementation(() => Promise.reject(err) as unknown as boolean)
+          const warn = spyOn(logger, "warn").mockImplementation(() => {})
+
+          try {
+            const registry = yield* ToolRegistry.Service
+            const ids = yield* registry.ids()
+
+            expect(ids).not.toContain("semantic_search")
+            expect(ids).toContain("question")
+            expect(ids).toContain("read")
+            expect(ids).toContain("suggest")
+            expect(warn.mock.calls[0]?.[0]).toBe("semantic search unavailable")
+            expect(warn.mock.calls[0]?.[1]?.err).toBeDefined()
+          } finally {
+            ready.mockRestore()
+            warn.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("registers semantic_search when indexing is ready", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const ready = spyOn(SaeeolIndexing, "ready").mockReturnValue(true)
+
+          try {
+            const registry = yield* ToolRegistry.Service
+            const ids = yield* registry.ids()
+
+            expect(ids).toContain("semantic_search")
+          } finally {
+            ready.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("omits semantic_search hint from glob and grep descriptions when indexing is not ready", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const ready = spyOn(SaeeolIndexing, "ready").mockReturnValue(false)
+
+          try {
+            const agent = yield* Agent.Service
+            const build = yield* agent.get("build")
+            const registry = yield* ToolRegistry.Service
+            const tools = yield* registry.tools({ ...ref, agent: build })
+            const glob = tools.find((tool) => tool.id === "glob")?.description ?? ""
+            const grep = tools.find((tool) => tool.id === "grep")?.description ?? ""
+
+            expect(glob).not.toContain("semantic_search")
+            expect(grep).not.toContain("semantic_search")
+          } finally {
+            ready.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("includes semantic_search hint in glob and grep descriptions when indexing is ready", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const ready = spyOn(SaeeolIndexing, "ready").mockReturnValue(true)
+
+          try {
+            const agent = yield* Agent.Service
+            const build = yield* agent.get("build")
+            const registry = yield* ToolRegistry.Service
+            const tools = yield* registry.tools({ ...ref, agent: build })
+            const ids = tools.map((tool) => tool.id)
+            const glob = tools.find((tool) => tool.id === "glob")?.description ?? ""
+            const grep = tools.find((tool) => tool.id === "grep")?.description ?? ""
+
+            expect(ids).toContain("semantic_search")
+            expect(glob).toContain("semantic_search")
+            expect(grep).toContain("semantic_search")
+          } finally {
+            ready.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+
+  test("conditionally includes Saeeol registry extras", () => {
+    const prev = process.env["SAEEOL_CLIENT"]
+    const def = (id: string): Tool.Def => ({
+      id,
+      description: id,
+      parameters: Schema.String,
+      execute: () => Effect.succeed({ title: id, output: id, metadata: {} }),
+    })
+    const tools = {
+      codebase: def("codebase_search"),
+      semantic: def("semantic_search"),
+      recall: def("recall"),
+      manager: def("agent_manager"),
+    }
+
+    try {
+      process.env["SAEEOL_CLIENT"] = "cli"
+      expect(SaeeolToolRegistry.extra(tools, {}).map((tool) => tool.id)).toEqual(["semantic_search", "recall"])
+      expect(
+        SaeeolToolRegistry.extra(tools, { experimental: { codebase_search: true, agent_manager_tool: true } }).map(
+          (tool) => tool.id,
+        ),
+      ).toEqual(["codebase_search", "semantic_search", "recall"])
+
+      process.env["SAEEOL_CLIENT"] = "vscode"
+      expect(
+        SaeeolToolRegistry.extra(tools, { experimental: { codebase_search: true, agent_manager_tool: true } }).map(
+          (tool) => tool.id,
+        ),
+      ).toEqual(["codebase_search", "semantic_search", "recall", "agent_manager"])
+      expect(SaeeolToolRegistry.extra({ ...tools, semantic: undefined }, {}).map((tool) => tool.id)).toEqual(["recall"])
+    } finally {
+      if (prev === undefined) delete process.env["SAEEOL_CLIENT"]
+      if (prev !== undefined) process.env["SAEEOL_CLIENT"] = prev
+    }
+  })
+
+  test("logs indexing bootstrap failures without blocking session bootstrap", async () => {
+    const logger = Log.create({ service: "saeeol-bootstrap" })
+    const err = new Error("indexing init failed")
+    const sessions = spyOn(SaeeolSessions, "init").mockResolvedValue(undefined)
+    const indexing = spyOn(SaeeolIndexing, "init").mockRejectedValue(err)
+    const warn = spyOn(logger, "warn").mockImplementation(() => {})
+
+    try {
+      await SaeeolBootstrap.init()
+      await new Promise((resolve) => setTimeout(resolve, 0))
+
+      expect(sessions).toHaveBeenCalledTimes(1)
+      expect(indexing).toHaveBeenCalledTimes(1)
+      expect(warn).toHaveBeenCalledWith("indexing bootstrap failed", { err })
+    } finally {
+      sessions.mockRestore()
+      indexing.mockRestore()
+      warn.mockRestore()
+    }
+  })
+})

package/test/saeeol/tool-registry-semantic-import-failure.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, mock, spyOn } from "bun:test"
+import { Effect, Layer } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import { Instance } from "../../src/project/instance"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
+import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
+import { testEffect } from "../lib/effect"
+
+const err = new Error("semantic tool import failed")
+
+mock.module("@/saeeol/indexing", () => ({
+  SaeeolIndexing: {
+    ready: () => true,
+  },
+}))
+
+mock.module("@/saeeol/tool/semantic-search", () => {
+  throw err
+})
+
+const { ToolRegistry } = await import("../../src/tool/registry")
+
+const node = CrossSpawnSpawner.defaultLayer
+const it = testEffect(Layer.mergeAll(ToolRegistry.defaultLayer, node))
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+describe("saeeol tool registry semantic tool import failure", () => {
+  it.live("keeps non-indexing tools when the semantic search tool cannot load", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const logger = Log.create({ service: "saeeol-tool-registry" })
+          const warn = spyOn(logger, "warn").mockImplementation(() => {})
+
+          try {
+            const registry = yield* ToolRegistry.Service
+            const ids = yield* registry.ids()
+
+            expect(ids).not.toContain("semantic_search")
+            expect(ids).toContain("question")
+            expect(ids).toContain("read")
+            expect(ids).toContain("suggest")
+            expect(warn.mock.calls[0]?.[0]).toBe("semantic search tool unavailable")
+            expect(warn.mock.calls[0]?.[1]?.err).toBeDefined()
+          } finally {
+            warn.mockRestore()
+          }
+        }),
+      { git: true },
+    ),
+  )
+})

package/test/saeeol/tool-task-model.test.ts

@@ -0,0 +1,352 @@
+import { afterEach, beforeAll, describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import fs from "fs/promises"
+import path from "path"
+import { Agent } from "../../src/agent/agent"
+import { Config } from "../../src/config/config"
+import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
+import { Global } from "@saeeol/core/global"
+import { Instance } from "../../src/project/instance"
+import { Session } from "../../src/session/session"
+import { MessageV2 } from "../../src/session/message-v2"
+import type { SessionPrompt } from "../../src/session/prompt"
+import { MessageID, PartID } from "../../src/session/schema"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { TaskTool, type TaskPromptOps } from "../../src/tool/task"
+import { Truncate } from "../../src/tool/truncate"
+import { ToolRegistry } from "../../src/tool/registry"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const state = path.join(Global.Path.state, "model.json")
+
+afterEach(async () => {
+  process.env.SAEEOL_CLIENT = "cli"
+  await fs.rm(state, { force: true }).catch(() => undefined)
+  await disposeAllInstances()
+})
+
+beforeAll(async () => {
+  process.env.SAEEOL_CLIENT = "cli"
+  await fs.rm(state, { force: true }).catch(() => undefined)
+})
+
+const parent = {
+  providerID: ProviderID.make("parent-provider"),
+  modelID: ModelID.make("parent-model"),
+}
+
+const saved = {
+  providerID: ProviderID.make("saved-provider"),
+  modelID: ModelID.make("saved-model"),
+}
+
+const cfg = {
+  providerID: ProviderID.make("config-provider"),
+  modelID: ModelID.make("config-model"),
+}
+
+const savedVariant = "fast"
+const cfgVariant = "balanced"
+
+const it = testEffect(
+  Layer.mergeAll(
+    Agent.defaultLayer,
+    Config.defaultLayer,
+    CrossSpawnSpawner.defaultLayer,
+    Session.defaultLayer,
+    Truncate.defaultLayer,
+    ToolRegistry.defaultLayer,
+  ),
+)
+
+const seed = Effect.fn("TaskToolModelTest.seed")(function* (title = "Parent") {
+  const session = yield* Session.Service
+  const chat = yield* session.create({ title })
+  const user = yield* session.updateMessage({
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID: chat.id,
+    agent: "build",
+    model: parent,
+    time: { created: Date.now() },
+  })
+  const assistant: MessageV2.Assistant = {
+    id: MessageID.ascending(),
+    role: "assistant",
+    parentID: user.id,
+    sessionID: chat.id,
+    mode: "build",
+    agent: "build",
+    cost: 0,
+    path: { cwd: "/tmp", root: "/tmp" },
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID: parent.modelID,
+    providerID: parent.providerID,
+    time: { created: Date.now() },
+  }
+  yield* session.updateMessage(assistant)
+  return { chat, assistant }
+})
+
+function stubOps(opts?: { onPrompt?: (input: SessionPrompt.PromptInput) => void; text?: string }): TaskPromptOps {
+  return {
+    cancel() {},
+    resolvePromptParts: (template) => Effect.succeed([{ type: "text" as const, text: template }]),
+    prompt: (input) =>
+      Effect.sync(() => {
+        opts?.onPrompt?.(input)
+        return reply(input, opts?.text ?? "done")
+      }),
+  }
+}
+
+function reply(input: SessionPrompt.PromptInput, text: string): MessageV2.WithParts {
+  const id = MessageID.ascending()
+  return {
+    info: {
+      id,
+      role: "assistant",
+      parentID: input.messageID ?? MessageID.ascending(),
+      sessionID: input.sessionID,
+      mode: input.agent ?? "general",
+      agent: input.agent ?? "general",
+      cost: 0,
+      path: { cwd: "/tmp", root: "/tmp" },
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      modelID: input.model?.modelID ?? parent.modelID,
+      providerID: input.model?.providerID ?? parent.providerID,
+      time: { created: Date.now() },
+      finish: "stop",
+    },
+    parts: [
+      {
+        id: PartID.ascending(),
+        messageID: id,
+        sessionID: input.sessionID,
+        type: "text",
+        text,
+      },
+    ],
+  }
+}
+
+function writeState(input: unknown) {
+  return Effect.promise(async () => {
+    await fs.mkdir(Global.Path.state, { recursive: true })
+    await fs.writeFile(state, JSON.stringify(input))
+  })
+}
+
+function run(input: { agent: "pinned" | "worker"; state?: unknown; client?: string }) {
+  return provideTmpdirInstance(
+    () =>
+      Effect.gen(function* () {
+        process.env.SAEEOL_CLIENT = input.client ?? "cli"
+        if (input.state) yield* writeState(input.state)
+
+        const { chat, assistant } = yield* seed(input.agent)
+        const tool = yield* TaskTool
+        const def = yield* tool.init()
+        let seen: SessionPrompt.PromptInput | undefined
+        const promptOps = stubOps({ onPrompt: (value) => (seen = value) })
+
+        const result = yield* def.execute(
+          {
+            description: `run ${input.agent}`,
+            prompt: "inspect resolution",
+            subagent_type: input.agent,
+          },
+          {
+            sessionID: chat.id,
+            messageID: assistant.id,
+            agent: "build",
+            abort: new AbortController().signal,
+            extra: { promptOps, bypassAgentCheck: true },
+            messages: [],
+            metadata: () => Effect.void,
+            ask: () => Effect.void,
+          },
+        )
+
+        return {
+          prompt: seen?.model,
+          variant: seen?.variant,
+          model: result.metadata.model,
+          metadataVariant: result.metadata.variant,
+        }
+      }),
+    {
+      config: {
+        agent: {
+          worker: { mode: "subagent" },
+          pinned: { mode: "subagent", model: "config-provider/config-model", variant: cfgVariant },
+        },
+      },
+    },
+  )
+}
+
+describe("tool.task model resolution", () => {
+  it.live("saved model beats agent config for pinned", () =>
+    run({
+      agent: "pinned",
+      state: { model: { pinned: saved }, variant: { "saved-provider/saved-model": savedVariant } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(saved)
+          expect(result.variant).toEqual(savedVariant)
+          expect(result.model).toMatchObject({ ...saved, variant: savedVariant })
+          expect(result.metadataVariant).toEqual(savedVariant)
+        }),
+      ),
+    ),
+  )
+
+  it.live("saved model beats parent for worker", () =>
+    run({
+      agent: "worker",
+      state: { model: { worker: saved }, variant: { "saved-provider/saved-model": savedVariant } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(saved)
+          expect(result.variant).toEqual(savedVariant)
+          expect(result.model).toMatchObject({ ...saved, variant: savedVariant })
+          expect(result.metadataVariant).toEqual(savedVariant)
+        }),
+      ),
+    ),
+  )
+
+  it.live("saved model without variant leaves variant undefined", () =>
+    run({
+      agent: "worker",
+      state: { model: { worker: saved } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(saved)
+          expect(result.variant).toBeUndefined()
+          expect(result.model).toEqual(saved)
+          expect(result.metadataVariant).toBeUndefined()
+        }),
+      ),
+    ),
+  )
+
+  it.live("unrelated saved variant key ignored", () =>
+    run({
+      agent: "worker",
+      state: { model: { worker: saved }, variant: { "other-provider/other-model": savedVariant } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(saved)
+          expect(result.variant).toBeUndefined()
+          expect(result.model).toEqual(saved)
+          expect(result.metadataVariant).toBeUndefined()
+        }),
+      ),
+    ),
+  )
+
+  it.live("missing saved entry falls back to agent config for pinned", () =>
+    run({
+      agent: "pinned",
+      state: { model: { worker: saved } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(cfg)
+          expect(result.variant).toEqual(cfgVariant)
+          expect(result.model).toEqual(cfg)
+          expect(result.metadataVariant).toEqual(cfgVariant)
+        }),
+      ),
+    ),
+  )
+
+  it.live("no file and no agent config falls back to parent for worker", () =>
+    run({
+      agent: "worker",
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(parent)
+          expect(result.variant).toBeUndefined()
+          expect(result.model).toEqual(parent)
+          expect(result.metadataVariant).toBeUndefined()
+        }),
+      ),
+    ),
+  )
+
+  it.live("malformed file ignored and falls back to agent config for pinned", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          process.env.SAEEOL_CLIENT = "cli"
+          yield* Effect.promise(async () => {
+            await fs.mkdir(Global.Path.state, { recursive: true })
+            await fs.writeFile(state, "{bad json")
+          })
+
+          const { chat, assistant } = yield* seed("pinned")
+          const tool = yield* TaskTool
+          const def = yield* tool.init()
+          let seen: SessionPrompt.PromptInput | undefined
+          const promptOps = stubOps({ onPrompt: (value) => (seen = value) })
+
+          const result = yield* def.execute(
+            {
+              description: "run pinned",
+              prompt: "inspect resolution",
+              subagent_type: "pinned",
+            },
+            {
+              sessionID: chat.id,
+              messageID: assistant.id,
+              agent: "build",
+              abort: new AbortController().signal,
+              extra: { promptOps, bypassAgentCheck: true },
+              messages: [],
+              metadata: () => Effect.void,
+              ask: () => Effect.void,
+            },
+          )
+
+          expect(seen?.model).toEqual(cfg)
+          expect(seen?.variant).toEqual(cfgVariant)
+          expect(result.metadata.model).toEqual(cfg)
+          expect(result.metadata.variant).toEqual(cfgVariant)
+        }),
+      {
+        config: {
+          agent: {
+            worker: { mode: "subagent" },
+            pinned: { mode: "subagent", model: "config-provider/config-model", variant: cfgVariant },
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("non-CLI client gate ignores saved worker model and uses parent", () =>
+    run({
+      agent: "worker",
+      client: "vscode",
+      state: { model: { worker: saved }, variant: { "saved-provider/saved-model": savedVariant } },
+    }).pipe(
+      Effect.tap((result) =>
+        Effect.sync(() => {
+          expect(result.prompt).toEqual(parent)
+          expect(result.variant).toBeUndefined()
+          expect(result.model).toEqual(parent)
+          expect(result.metadataVariant).toBeUndefined()
+        }),
+      ),
+    ),
+  )
+})