saeeol 1.3.0 → 1.4.0

package/test/tool/glob.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import fs from "fs/promises"
+import os from "os"
+import { Cause, Effect, Exit, Layer } from "effect"
+import { GlobTool } from "../../src/tool/glob"
+import { SessionID, MessageID } from "../../src/session/schema"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { Ripgrep } from "../../src/file/ripgrep"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { Truncate } from "@/tool/truncate"
+import { Agent } from "../../src/agent/agent"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(
+  Layer.mergeAll(
+    CrossSpawnSpawner.defaultLayer,
+    AppFileSystem.defaultLayer,
+    Ripgrep.defaultLayer,
+    Truncate.defaultLayer,
+    Agent.defaultLayer,
+  ),
+)
+
+const ctx = {
+  sessionID: SessionID.make("ses_test"),
+  messageID: MessageID.make(""),
+  callID: "",
+  agent: "build",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+  ask: () => Effect.void,
+}
+const unix = process.platform !== "win32" ? it.live : it.live.skip
+
+describe("tool.glob", () => {
+  unix("matches files from a directory path", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "a.ts"), "export const a = 1\n"))
+        yield* Effect.promise(() => Bun.write(path.join(dir, "b.txt"), "hello\n"))
+        const info = yield* GlobTool
+        const glob = yield* info.init()
+        const result = yield* glob.execute(
+          {
+            pattern: "*.ts",
+            path: dir,
+          },
+          ctx,
+        )
+        expect(result.metadata.count).toBe(1)
+        expect(result.output).toContain(path.join(dir, "a.ts"))
+        expect(result.output).not.toContain(path.join(dir, "b.txt"))
+      }),
+    ),
+  )
+
+  it.live("rejects exact file paths", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const file = path.join(dir, "a.ts")
+        yield* Effect.promise(() => Bun.write(file, "export const a = 1\n"))
+        const info = yield* GlobTool
+        const glob = yield* info.init()
+        const exit = yield* glob
+          .execute(
+            {
+              pattern: "*.ts",
+              path: file,
+            },
+            ctx,
+          )
+          .pipe(Effect.exit)
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          const err = Cause.squash(exit.cause)
+          expect(err instanceof Error ? err.message : String(err)).toContain("glob path must be a directory")
+        }
+      }),
+    ),
+  )
+  unix("supports absolute glob patterns outside the project", () =>
+    provideTmpdirInstance(
+      (_dir) =>
+        Effect.gen(function* () {
+          const outer = yield* Effect.promise(() => fs.mkdtemp(path.join(os.tmpdir(), "glob-outer-")))
+          yield* Effect.promise(() => Bun.write(path.join(outer, "one.md"), "one"))
+          yield* Effect.promise(() => Bun.write(path.join(outer, "two.md"), "two"))
+          yield* Effect.promise(() => Bun.write(path.join(outer, "three.txt"), "three"))
+          const info = yield* GlobTool
+          const glob = yield* info.init()
+          const result = yield* glob.execute(
+            {
+              pattern: path.join(outer, "*.md"),
+            },
+            ctx,
+          )
+          expect(result.output).toContain(path.join(outer, "one.md"))
+          expect(result.output).toContain(path.join(outer, "two.md"))
+          expect(result.output).not.toContain(path.join(outer, "three.txt"))
+        }),
+      { git: true },
+    ),
+  )
+})

package/test/tool/grep.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import { Effect, Layer } from "effect"
+import { GrepTool } from "../../src/tool/grep"
+import { provideInstance, provideTmpdirInstance } from "../fixture/fixture"
+import { SessionID, MessageID } from "../../src/session/schema"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { Truncate } from "@/tool/truncate"
+import { Agent } from "../../src/agent/agent"
+import { Ripgrep } from "../../src/file/ripgrep"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(
+  Layer.mergeAll(
+    CrossSpawnSpawner.defaultLayer,
+    AppFileSystem.defaultLayer,
+    Ripgrep.defaultLayer,
+    Truncate.defaultLayer,
+    Agent.defaultLayer,
+  ),
+)
+
+const ctx = {
+  sessionID: SessionID.make("ses_test"),
+  messageID: MessageID.make(""),
+  callID: "",
+  agent: "code", 
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+  ask: () => Effect.void,
+}
+
+const root = path.join(__dirname, "../..")
+
+describe("tool.grep", () => {
+  it.live("basic search", () =>
+    Effect.gen(function* () {
+      const info = yield* GrepTool
+      const grep = yield* info.init()
+      const result = yield* provideInstance(root)(
+        grep.execute(
+          {
+            pattern: "export",
+            path: path.join(root, "src/tool"),
+            include: "*.ts",
+          },
+          ctx,
+        ),
+      )
+      expect(result.metadata.matches).toBeGreaterThan(0)
+      expect(result.output).toContain("Found")
+    }),
+  )
+
+  it.live("no matches returns correct output", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "test.txt"), "hello world"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "xyznonexistentpatternxyz123",
+            path: dir,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBe(0)
+        expect(result.output).toBe("No files found")
+      }),
+    ),
+  )
+
+  it.live("finds matches in tmp instance", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => Bun.write(path.join(dir, "test.txt"), "line1\nline2\nline3"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "line",
+            path: dir,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBeGreaterThan(0)
+      }),
+    ),
+  )
+
+  it.live("supports exact file paths", () =>
+    provideTmpdirInstance((dir) =>
+      Effect.gen(function* () {
+        const file = path.join(dir, "test.txt")
+        yield* Effect.promise(() => Bun.write(file, "line1\nline2\nline3"))
+        const info = yield* GrepTool
+        const grep = yield* info.init()
+        const result = yield* grep.execute(
+          {
+            pattern: "line2",
+            path: file,
+          },
+          ctx,
+        )
+        expect(result.metadata.matches).toBe(1)
+        expect(result.output).toContain(file)
+        expect(result.output).toContain("Line 2: line2")
+      }),
+    ),
+  )
+})

package/test/tool/lsp.test.ts

@@ -0,0 +1,187 @@
+import { afterEach, describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import path from "path"
+import { Agent } from "../../src/agent/agent"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { LSP } from "@/lsp/lsp"
+import { Permission } from "../../src/permission"
+import { Instance } from "../../src/project/instance"
+import { MessageID, SessionID } from "../../src/session/schema"
+import { Tool } from "@/tool/tool"
+import { Truncate } from "@/tool/truncate"
+import { LspTool } from "../../src/tool/lsp"
+import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+const ctx = {
+  sessionID: SessionID.make("ses_test"),
+  messageID: MessageID.make(""),
+  callID: "",
+  agent: "build",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+  ask: () => Effect.void,
+}
+
+const workspaceSymbolQueries: string[] = []
+
+const lsp = Layer.succeed(
+  LSP.Service,
+  LSP.Service.of({
+    init: () => Effect.void,
+    status: () => Effect.succeed([]),
+    hasClients: () => Effect.succeed(true),
+    touchFile: () => Effect.void,
+    diagnostics: () => Effect.succeed({}),
+    hover: () => Effect.succeed([]),
+    definition: () => Effect.succeed([]),
+    references: () => Effect.succeed([]),
+    implementation: () => Effect.succeed([]),
+    documentSymbol: () => Effect.succeed([]),
+    workspaceSymbol: (query) =>
+      Effect.sync(() => {
+        workspaceSymbolQueries.push(query)
+        return []
+      }),
+    prepareCallHierarchy: () => Effect.succeed([]),
+    incomingCalls: () => Effect.succeed([]),
+    outgoingCalls: () => Effect.succeed([]),
+  }),
+)
+
+const it = testEffect(
+  Layer.mergeAll(
+    Agent.defaultLayer,
+    AppFileSystem.defaultLayer,
+    CrossSpawnSpawner.defaultLayer,
+    Truncate.defaultLayer,
+    lsp,
+  ),
+)
+
+const init = Effect.fn("LspToolTest.init")(function* () {
+  const info = yield* LspTool
+  return yield* info.init()
+})
+
+const run = Effect.fn("LspToolTest.run")(function* (
+  args: Tool.InferParameters<typeof LspTool>,
+  next: Tool.Context = ctx,
+) {
+  const tool = yield* init()
+  return yield* tool.execute(args, next)
+})
+
+const put = Effect.fn("LspToolTest.put")(function* (file: string) {
+  const fs = yield* AppFileSystem.Service
+  yield* fs.writeWithDirs(file, "export const x = 1\n")
+})
+
+const asks = () => {
+  const items: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
+  return {
+    items,
+    next: {
+      ...ctx,
+      ask: (req: Omit<Permission.Request, "id" | "sessionID" | "tool">) =>
+        Effect.sync(() => {
+          items.push(req)
+        }),
+    },
+  }
+}
+
+describe("tool.lsp", () => {
+  describe("permission metadata", () => {
+    it.live("keeps cursor details for position-based operations", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            const file = path.join(dir, "test.ts")
+            yield* put(file)
+
+            const { items, next } = asks()
+            const result = yield* run({ operation: "goToDefinition", filePath: file, line: 3, character: 7 }, next)
+            const req = items.find((item) => item.permission === "lsp")
+
+            expect(req).toBeDefined()
+            expect(req!.metadata).toEqual({
+              operation: "goToDefinition",
+              filePath: file,
+              line: 3,
+              character: 7,
+            })
+            expect(result.title).toBe("goToDefinition test.ts:3:7")
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("omits cursor details for documentSymbol", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            const file = path.join(dir, "test.ts")
+            yield* put(file)
+
+            const { items, next } = asks()
+            const result = yield* run({ operation: "documentSymbol", filePath: file, line: 3, character: 7 }, next)
+            const req = items.find((item) => item.permission === "lsp")
+
+            expect(req).toBeDefined()
+            expect(req!.metadata).toEqual({
+              operation: "documentSymbol",
+              filePath: file,
+            })
+            expect(result.title).toBe("documentSymbol test.ts")
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("omits file and cursor details for workspaceSymbol", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            workspaceSymbolQueries.length = 0
+            const file = path.join(dir, "test.ts")
+            yield* put(file)
+
+            const { items, next } = asks()
+            const result = yield* run({ operation: "workspaceSymbol", filePath: file, line: 3, character: 7 }, next)
+            const req = items.find((item) => item.permission === "lsp")
+
+            expect(req).toBeDefined()
+            expect(req!.metadata).toEqual({
+              operation: "workspaceSymbol",
+            })
+            expect(result.title).toBe("workspaceSymbol")
+          }),
+        { git: true },
+      ),
+    )
+
+    it.live("passes workspaceSymbol query to LSP", () =>
+      provideTmpdirInstance(
+        (dir) =>
+          Effect.gen(function* () {
+            workspaceSymbolQueries.length = 0
+            const file = path.join(dir, "test.ts")
+            yield* put(file)
+
+            yield* run({ operation: "workspaceSymbol", filePath: file, line: 3, character: 7, query: "TestSymbol" })
+            yield* run({ operation: "workspaceSymbol", filePath: file, line: 3, character: 7 })
+
+            expect(workspaceSymbolQueries).toEqual(["TestSymbol", ""])
+          }),
+        { git: true },
+      ),
+    )
+  })
+})

package/test/tool/parameters.test.ts

@@ -0,0 +1,243 @@
+import { describe, expect, test } from "bun:test"
+import { Result, Schema } from "effect"
+import { toJsonSchema } from "../../src/util/effect-zod"
+
+// Each tool exports its parameters schema at module scope so this test can
+// import them without running the tool's Effect-based init. The JSON Schema
+// snapshot captures what the LLM sees; the parse assertions pin down the
+// accepts/rejects contract. `toJsonSchema` is the same helper `session/
+// prompt.ts` uses to emit tool schemas to the LLM, so the snapshots stay
+// byte-identical regardless of whether a tool has migrated from zod to Schema.
+
+import { Parameters as ApplyPatch } from "../../src/tool/apply_patch"
+import { Parameters as Bash } from "../../src/tool/bash"
+import { Parameters as Edit } from "../../src/tool/edit"
+import { Parameters as Glob } from "../../src/tool/glob"
+import { Parameters as Grep } from "../../src/tool/grep"
+import { Parameters as Invalid } from "../../src/tool/invalid"
+import { Parameters as Lsp } from "../../src/tool/lsp"
+import { Parameters as Plan } from "../../src/tool/plan"
+import { Parameters as Question } from "../../src/tool/question"
+import { Parameters as Read } from "../../src/tool/read"
+import { Parameters as Skill } from "../../src/tool/skill"
+import { Parameters as Task } from "../../src/tool/task"
+import { Parameters as Todo } from "../../src/tool/todo"
+import { Parameters as WebFetch } from "../../src/tool/webfetch"
+import { Parameters as WebSearch } from "../../src/tool/websearch"
+import { Parameters as Write } from "../../src/tool/write"
+
+const parse = <S extends Schema.Decoder<unknown>>(schema: S, input: unknown): S["Type"] =>
+  Schema.decodeUnknownSync(schema)(input)
+
+const accepts = (schema: Schema.Decoder<unknown>, input: unknown): boolean =>
+  Result.isSuccess(Schema.decodeUnknownResult(schema)(input))
+
+describe("tool parameters", () => {
+  describe("JSON Schema (wire shape)", () => {
+    test("apply_patch", () => expect(toJsonSchema(ApplyPatch)).toMatchSnapshot())
+    test("bash", () => expect(toJsonSchema(Bash)).toMatchSnapshot())
+    test("edit", () => expect(toJsonSchema(Edit)).toMatchSnapshot())
+    test("glob", () => expect(toJsonSchema(Glob)).toMatchSnapshot())
+    test("grep", () => expect(toJsonSchema(Grep)).toMatchSnapshot())
+    test("invalid", () => expect(toJsonSchema(Invalid)).toMatchSnapshot())
+    test("lsp", () => expect(toJsonSchema(Lsp)).toMatchSnapshot())
+    test("plan", () => expect(toJsonSchema(Plan)).toMatchSnapshot())
+    test("question", () => expect(toJsonSchema(Question)).toMatchSnapshot())
+    test("read", () => expect(toJsonSchema(Read)).toMatchSnapshot())
+    test("skill", () => expect(toJsonSchema(Skill)).toMatchSnapshot())
+    test("task", () => expect(toJsonSchema(Task)).toMatchSnapshot())
+    test("todo", () => expect(toJsonSchema(Todo)).toMatchSnapshot())
+    test("webfetch", () => expect(toJsonSchema(WebFetch)).toMatchSnapshot())
+    test("websearch", () => expect(toJsonSchema(WebSearch)).toMatchSnapshot())
+    test("write", () => expect(toJsonSchema(Write)).toMatchSnapshot())
+  })
+
+  describe("apply_patch", () => {
+    test("accepts patchText", () => {
+      expect(parse(ApplyPatch, { patchText: "*** Begin Patch\n*** End Patch" })).toEqual({
+        patchText: "*** Begin Patch\n*** End Patch",
+      })
+    })
+    test("rejects missing patchText", () => {
+      expect(accepts(ApplyPatch, {})).toBe(false)
+    })
+    test("rejects non-string patchText", () => {
+      expect(accepts(ApplyPatch, { patchText: 123 })).toBe(false)
+    })
+  })
+
+  describe("bash", () => {
+    test("accepts minimum: command + description", () => {
+      expect(parse(Bash, { command: "ls", description: "list" })).toEqual({ command: "ls", description: "list" })
+    })
+    test("accepts optional timeout + workdir", () => {
+      const parsed = parse(Bash, { command: "ls", description: "list", timeout: 5000, workdir: "/tmp" })
+      expect(parsed.timeout).toBe(5000)
+      expect(parsed.workdir).toBe("/tmp")
+    })
+    test("accepts missing description (optional in saeeol)", () => {
+      expect(accepts(Bash, { command: "ls" })).toBe(true)
+    })
+    test("rejects missing command", () => {
+      expect(accepts(Bash, { description: "list" })).toBe(false)
+    })
+  })
+
+  describe("edit", () => {
+    test("accepts all four fields", () => {
+      expect(parse(Edit, { filePath: "/a", oldString: "x", newString: "y", replaceAll: true })).toEqual({
+        filePath: "/a",
+        oldString: "x",
+        newString: "y",
+        replaceAll: true,
+      })
+    })
+    test("replaceAll is optional", () => {
+      const parsed = parse(Edit, { filePath: "/a", oldString: "x", newString: "y" })
+      expect(parsed.replaceAll).toBeUndefined()
+    })
+    test("rejects missing filePath", () => {
+      expect(accepts(Edit, { oldString: "x", newString: "y" })).toBe(false)
+    })
+  })
+
+  describe("glob", () => {
+    test("accepts pattern-only", () => {
+      expect(parse(Glob, { pattern: "**/*.ts" })).toEqual({ pattern: "**/*.ts" })
+    })
+    test("accepts optional path", () => {
+      expect(parse(Glob, { pattern: "**/*.ts", path: "/tmp" }).path).toBe("/tmp")
+    })
+    test("rejects missing pattern", () => {
+      expect(accepts(Glob, {})).toBe(false)
+    })
+  })
+
+  describe("grep", () => {
+    test("accepts pattern-only", () => {
+      expect(parse(Grep, { pattern: "TODO" })).toEqual({ pattern: "TODO" })
+    })
+    test("accepts optional path + include", () => {
+      const parsed = parse(Grep, { pattern: "TODO", path: "/tmp", include: "*.ts" })
+      expect(parsed.path).toBe("/tmp")
+      expect(parsed.include).toBe("*.ts")
+    })
+    test("rejects missing pattern", () => {
+      expect(accepts(Grep, {})).toBe(false)
+    })
+  })
+
+  describe("invalid", () => {
+    test("accepts tool + error", () => {
+      expect(parse(Invalid, { tool: "foo", error: "bar" })).toEqual({ tool: "foo", error: "bar" })
+    })
+    test("rejects missing fields", () => {
+      expect(accepts(Invalid, { tool: "foo" })).toBe(false)
+      expect(accepts(Invalid, { error: "bar" })).toBe(false)
+    })
+  })
+
+  describe("lsp", () => {
+    test("accepts all fields", () => {
+      const parsed = parse(Lsp, { operation: "hover", filePath: "/a.ts", line: 1, character: 1 })
+      expect(parsed.operation).toBe("hover")
+    })
+    test("rejects line < 1", () => {
+      expect(accepts(Lsp, { operation: "hover", filePath: "/a.ts", line: 0, character: 1 })).toBe(false)
+    })
+    test("rejects character < 1", () => {
+      expect(accepts(Lsp, { operation: "hover", filePath: "/a.ts", line: 1, character: 0 })).toBe(false)
+    })
+    test("rejects unknown operation", () => {
+      expect(accepts(Lsp, { operation: "bogus", filePath: "/a.ts", line: 1, character: 1 })).toBe(false)
+    })
+  })
+
+  describe("plan", () => {
+    test("accepts empty object", () => {
+      expect(parse(Plan, {})).toEqual({})
+    })
+  })
+
+  describe("question", () => {
+    test("accepts questions array", () => {
+      const parsed = parse(Question, {
+        questions: [
+          {
+            question: "pick one",
+            header: "Header",
+            custom: false,
+            options: [{ label: "a", description: "desc" }],
+          },
+        ],
+      })
+      expect(parsed.questions.length).toBe(1)
+    })
+    test("rejects missing questions", () => {
+      expect(accepts(Question, {})).toBe(false)
+    })
+  })
+
+  describe("read", () => {
+    test("accepts filePath-only", () => {
+      expect(parse(Read, { filePath: "/a" }).filePath).toBe("/a")
+    })
+    test("accepts optional offset + limit", () => {
+      const parsed = parse(Read, { filePath: "/a", offset: 10, limit: 100 })
+      expect(parsed.offset).toBe(10)
+      expect(parsed.limit).toBe(100)
+    })
+  })
+
+  describe("skill", () => {
+    test("accepts name", () => {
+      expect(parse(Skill, { name: "foo" }).name).toBe("foo")
+    })
+    test("rejects missing name", () => {
+      expect(accepts(Skill, {})).toBe(false)
+    })
+  })
+
+  describe("task", () => {
+    test("accepts description + prompt + subagent_type", () => {
+      const parsed = parse(Task, { description: "d", prompt: "p", subagent_type: "general" })
+      expect(parsed.subagent_type).toBe("general")
+    })
+    test("rejects missing prompt", () => {
+      expect(accepts(Task, { description: "d", subagent_type: "general" })).toBe(false)
+    })
+  })
+
+  describe("todo", () => {
+    test("accepts todos array", () => {
+      const parsed = parse(Todo, {
+        todos: [{ id: "t1", content: "do x", status: "pending", priority: "medium" }],
+      })
+      expect(parsed.todos.length).toBe(1)
+    })
+    test("rejects missing todos", () => {
+      expect(accepts(Todo, {})).toBe(false)
+    })
+  })
+
+  describe("webfetch", () => {
+    test("accepts url-only", () => {
+      expect(parse(WebFetch, { url: "https://example.com" }).url).toBe("https://example.com")
+    })
+  })
+
+  describe("websearch", () => {
+    test("accepts query", () => {
+      expect(parse(WebSearch, { query: "saeeol" }).query).toBe("saeeol")
+    })
+  })
+
+  describe("write", () => {
+    test("accepts content + filePath", () => {
+      expect(parse(Write, { content: "hi", filePath: "/a" })).toEqual({ content: "hi", filePath: "/a" })
+    })
+    test("rejects missing filePath", () => {
+      expect(accepts(Write, { content: "hi" })).toBe(false)
+    })
+  })
+})