woozlit 2.3.0 → 2.3.2

package/test/tool/task.test.ts

@@ -1,296 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { Bus } from "../../src/bus"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { TaskRegistry } from "../../src/task/registry"
-import { Truncate } from "../../src/tool"
-import { TaskTool } from "../../src/tool/task"
-import { shellWrap } from "../../src/tool/shell-wrap"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const it = testEffect(
-  Layer.mergeAll(
-    Bus.defaultLayer,
-    CrossSpawnSpawner.defaultLayer,
-    Session.defaultLayer,
-    TaskRegistry.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
-)
-
-const ctx = (sessionID: string) => ({
-  sessionID: SessionID.make(sessionID),
-  messageID: MessageID.ascending(),
-  agent: "build",
-  abort: new AbortController().signal,
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-})
-
-describe("task tool", () => {
-  it.live("create with summary returns new task id", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const result = yield* tool.execute({ operation: { action: "create", summary: "Implement auth" } }, ctx(sess.id))
-        expect(result.output).toContain("T1")
-        expect(result.metadata.id).toBe("T1")
-      }),
-    ),
-  )
-
-  it.live("list returns tasks for current session", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        yield* reg.create({ session_id: sess.id, summary: "a" })
-        yield* reg.create({ session_id: sess.id, summary: "b" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const result = yield* tool.execute({ operation: { action: "list" } }, ctx(sess.id))
-        expect(result.metadata.count).toBe(2)
-      }),
-    ),
-  )
-
-  it.live("set_status=done transitions task", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "a" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        yield* tool.execute({ operation: { action: "done", id: t.id } }, ctx(sess.id))
-        const after = yield* reg.get({ session_id: sess.id, id: t.id })
-        expect(after?.status).toBe("done")
-      }),
-    ),
-  )
-
-  it.live("rename with summary renames the task", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "old name" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        yield* tool.execute({ operation: { action: "rename", id: t.id, summary: "new name" } }, ctx(sess.id))
-        const after = yield* reg.get({ session_id: sess.id, id: t.id })
-        expect(after?.summary).toBe("new name")
-      }),
-    ),
-  )
-
-  it.live("rejects old flat JSON shape", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ action: "create", summary: "Implement auth" } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rejects create without summary", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(tool.execute({ operation: { action: "create" } } as any, ctx(sess.id)))
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rejects progress without event_summary", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "a" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "progress", id: t.id } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-})
-
-describe("task tool: deprecated verbs are rejected", () => {
-  it.live("set_status operation itself is rejected (replaced by independent verbs)", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "set_status", id: "T1", status: "blocked" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("progress operation is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "progress", id: "T1", event_summary: "x" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("approve operation is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "approve", id: "T1" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rename with spec_ref is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "rename", id: "T1", spec_ref: "x" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-})
-
-describe("task tool: independent lifecycle verbs", () => {
-  it.live("block operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "block", id: "T1", event_summary: "waiting" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("unblock operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "unblock", id: "T1" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("done operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "done", id: "T1", event_summary: "complete" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("abandon operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "abandon", id: "T1" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("block with invalid status field is rejected (strict)", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "block", id: "T1", status: "in_progress" } })
-        expect(result.success).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("shell-wrapped task create does not crash and renders operation=create", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const wrapped = shellWrap({ ...def, id: info.id })
-        const result = yield* wrapped.execute({ script: 'task create "x"' }, ctx(sess.id) as any)
-        // Regression: nested discriminator { operation: { action } } used to crash
-        // shell-wrap with "H.replace is not a function". The XML attribute must
-        // reflect the action verb, not "[object Object]".
-        expect(result.output).toContain('operation="create"')
-        expect(result.output).not.toContain("[object Object]")
-        expect(result.metadata.success).toBe(1)
-      }),
-    ),
-  )
-})

package/test/tool/tool-def-shell-shape.test.ts

@@ -1,23 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect } from "effect"
-import z from "zod"
-import type { Tool } from "../../src/tool"
-
-describe("Tool.Def shell field shape", () => {
-  test("Def accepts a shell field whose parse returns Effect of args[]", () => {
-    const params = z.object({ action: z.string(), id: z.string().optional() })
-    const def: Tool.Def<typeof params> = {
-      id: "synthetic",
-      description: "json",
-      parameters: params,
-      execute: () => Effect.succeed({ title: "", output: "", metadata: {} }),
-      shell: {
-        description: "shell",
-        parse: (_script) =>
-          Effect.succeed([{ action: "noop" } as z.infer<typeof params>]),
-      },
-    }
-    expect(def.shell?.description).toBe("shell")
-    expect(typeof def.shell?.parse).toBe("function")
-  })
-})

package/test/tool/tool-define.test.ts

@@ -1,59 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import z from "zod"
-import { Agent } from "../../src/agent/agent"
-import { Tool } from "../../src/tool"
-import { Truncate } from "../../src/tool"
-
-const runtime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
-
-const params = z.object({ input: z.string() })
-
-function makeTool(id: string, executeFn?: () => void) {
-  return {
-    description: "test tool",
-    parameters: params,
-    execute() {
-      executeFn?.()
-      return Effect.succeed({ title: "test", output: "ok", metadata: {} })
-    },
-  }
-}
-
-describe("Tool.define", () => {
-  test("object-defined tool does not mutate the original init object", async () => {
-    const original = makeTool("test")
-    const originalExecute = original.execute
-
-    const info = await runtime.runPromise(Tool.define("test-tool", Effect.succeed(original)))
-
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
-
-    expect(original.execute).toBe(originalExecute)
-  })
-
-  test("effect-defined tool returns fresh objects and is unaffected", async () => {
-    const info = await runtime.runPromise(
-      Tool.define(
-        "test-fn-tool",
-        Effect.succeed(() => Effect.succeed(makeTool("test"))),
-      ),
-    )
-
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
-
-    expect(first).not.toBe(second)
-  })
-
-  test("object-defined tool returns distinct objects per init() call", async () => {
-    const info = await runtime.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
-
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
-
-    expect(first).not.toBe(second)
-  })
-})

package/test/tool/truncation.test.ts

@@ -1,253 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { NodeFileSystem } from "@effect/platform-node"
-import { Effect, FileSystem, Layer } from "effect"
-import { Truncate } from "../../src/tool"
-import { Identifier } from "../../src/id/id"
-import { Process } from "../../src/util"
-import { Filesystem } from "../../src/util"
-import path from "path"
-import { testEffect } from "../lib/effect"
-import { writeFileStringScoped } from "../lib/filesystem"
-
-const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
-const ROOT = path.resolve(import.meta.dir, "..", "..")
-
-const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, NodeFileSystem.layer))
-
-describe("Truncate", () => {
-  describe("output", () => {
-    it.live("truncates large json file by bytes", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-        if (result.truncated) expect(result.outputPath).toBeDefined()
-      }),
-    )
-
-    it.live("returns content unchanged when under limits", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "line1\nline2\nline3"
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(false)
-        expect(result.content).toBe(content)
-      }),
-    )
-
-    it.live("truncates by line count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("...90 lines truncated...")
-      }),
-    )
-
-    it.live("truncates by byte count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "a".repeat(1000)
-        const result = yield* svc.output(content, { maxBytes: 100 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-      }),
-    )
-
-    it.live("truncates from head by default", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line0")
-        expect(result.content).toContain("line1")
-        expect(result.content).toContain("line2")
-        expect(result.content).not.toContain("line9")
-      }),
-    )
-
-    it.live("truncates from tail when direction is tail", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3, direction: "tail" })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line7")
-        expect(result.content).toContain("line8")
-        expect(result.content).toContain("line9")
-        expect(result.content).not.toContain("line0")
-      }),
-    )
-
-    test("uses default MAX_LINES and MAX_BYTES", () => {
-      expect(Truncate.MAX_LINES).toBe(2000)
-      expect(Truncate.MAX_BYTES).toBe(50 * 1024)
-    })
-
-    it.live("large single-line file truncates with byte message", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("bytes truncated...")
-        expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
-      }),
-    )
-
-    it.live("writes full output to file when truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("The tool call succeeded but the output was truncated")
-        expect(result.content).toContain("Grep")
-        if (!result.truncated) throw new Error("expected truncated")
-        expect(result.outputPath).toBeDefined()
-        expect(result.outputPath).toContain("tool_")
-
-        const written = yield* Effect.promise(() => Filesystem.readText(result.outputPath!))
-        expect(written).toBe(lines)
-      }),
-    )
-
-    it.live("suggests actor tool when agent has actor permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "actor", pattern: "*", action: "allow" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).toContain("actor tool")
-      }),
-    )
-
-    it.live("omits actor tool hint when agent lacks actor permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "actor", pattern: "*", action: "deny" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
-
-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).not.toContain("actor tool")
-      }),
-    )
-
-    it.live("does not write file when not truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "short content"
-        const result = yield* svc.output(content)
-
-        expect(result.truncated).toBe(false)
-        if (result.truncated) throw new Error("expected not truncated")
-        expect("outputPath" in result).toBe(false)
-      }),
-    )
-
-    test("loads truncate effect in a fresh process", async () => {
-      const out = await Process.run([process.execPath, "run", path.join(ROOT, "src", "tool", "truncate.ts")], {
-        cwd: ROOT,
-      })
-
-      expect(out.code).toBe(0)
-    }, 20000)
-
-    it.live("head+tail with errors in tail shows head and tail sections", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        // Build a large output: many normal lines + error lines at the end
-        const normalLines = Array.from({ length: 100 }, (_, i) => `normal line ${i}`)
-        const errorLines = ["Error: something went wrong", "exit code 1"]
-        const allLines = [...normalLines, ...errorLines]
-        const text = allLines.join("\n")
-
-        const result = yield* svc.output(text, { maxLines: 10, direction: "head+tail" })
-
-        expect(result.truncated).toBe(true)
-        // Should contain head content
-        expect(result.content).toContain("normal line 0")
-        // Should contain tail error content
-        expect(result.content).toContain("Error: something went wrong")
-        expect(result.content).toContain("exit code 1")
-        // Should contain omission marker
-        expect(result.content).toContain("lines omitted — showing head and tail")
-      }),
-    )
-
-    it.live("head+tail without errors in tail degrades to head mode", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        // Build output with no error keywords at the end
-        const lines = Array.from({ length: 100 }, (_, i) => `normal line ${i}`)
-        const text = lines.join("\n")
-
-        const result = yield* svc.output(text, { maxLines: 10, direction: "head+tail" })
-
-        expect(result.truncated).toBe(true)
-        // Should behave like head: contains first lines
-        expect(result.content).toContain("normal line 0")
-        // Should NOT contain head+tail omission marker (degraded to head)
-        expect(result.content).not.toContain("lines omitted — showing head and tail")
-        // Should contain normal truncation marker
-        expect(result.content).toContain("truncated...")
-      }),
-    )
-
-    it.live("pressureCaps halves maxLines before size check", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        // With maxLines=20 and pressureCaps=true, effective limit becomes 10
-        const lines = Array.from({ length: 15 }, (_, i) => `line${i}`).join("\n")
-
-        // Without pressureCaps: 15 lines fits within maxLines=20, so not truncated
-        const resultNoPressure = yield* svc.output(lines, { maxLines: 20 })
-        expect(resultNoPressure.truncated).toBe(false)
-
-        // With pressureCaps: effective maxLines=10, so 15 lines gets truncated
-        const resultWithPressure = yield* svc.output(lines, { maxLines: 20, pressureCaps: true })
-        expect(resultWithPressure.truncated).toBe(true)
-      }),
-    )
-  })
-
-  describe("cleanup", () => {
-    const DAY_MS = 24 * 60 * 60 * 1000
-
-    it.live("deletes files older than 7 days and preserves recent files", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const fs = yield* FileSystem.FileSystem
-
-        yield* fs.makeDirectory(Truncate.DIR, { recursive: true })
-
-        const old = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 10 * DAY_MS))
-        const recent = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 3 * DAY_MS))
-
-        yield* writeFileStringScoped(old, "old content")
-        yield* writeFileStringScoped(recent, "recent content")
-        yield* svc.cleanup()
-
-        expect(yield* fs.exists(old)).toBe(false)
-        expect(yield* fs.exists(recent)).toBe(true)
-      }),
-    )
-  })
-})