saeeol 1.2.5 → 1.2.8

package/test/tool/truncation.test.ts

@@ -1,260 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { NodeFileSystem } from "@effect/platform-node"
-import { Effect, FileSystem, Layer } from "effect"
-import { Truncate } from "@/tool/truncate"
-import { Config } from "@/config/config"
-import { Identifier } from "../../src/id/id"
-import { Process } from "@/util/process"
-import { Filesystem } from "@/util/filesystem"
-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))
-
-const configuredLayer = (cfg: Config.Info) =>
-  Layer.mergeAll(
-    Truncate.defaultLayer,
-    NodeFileSystem.layer,
-    Layer.mock(Config.Service)({ get: () => Effect.succeed(cfg) }),
-  )
-const configuredIt = (cfg: Config.Info) => testEffect(configuredLayer(cfg))
-
-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("limits() falls back to MAX_LINES/MAX_BYTES when Config is not provided", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const resolved = yield* svc.limits()
-        expect(resolved.maxLines).toBe(Truncate.MAX_LINES)
-        expect(resolved.maxBytes).toBe(Truncate.MAX_BYTES)
-      }),
-    )
-
-    describe("with tool_output config", () => {
-      const limitsIt = configuredIt({ tool_output: { max_lines: 123, max_bytes: 456 } })
-      limitsIt.live("limits() reflects config overrides", () =>
-        Effect.gen(function* () {
-          const resolved = yield* (yield* Truncate.Service).limits()
-          expect(resolved.maxLines).toBe(123)
-          expect(resolved.maxBytes).toBe(456)
-        }),
-      )
-
-      // Huge byte budget isolates line truncation. 100 lines against max_lines: 10
-      // proves the configured line limit is what `output()` enforces.
-      const lineIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 1024 * 1024 } })
-      lineIt.live("output() truncates to configured max_lines", () =>
-        Effect.gen(function* () {
-          const content = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-          const result = yield* (yield* Truncate.Service).output(content)
-          expect(result.truncated).toBe(true)
-          expect(result.content).toContain("...90 lines truncated...")
-        }),
-      )
-
-      // Huge line budget isolates byte truncation.
-      const byteIt = configuredIt({ tool_output: { max_lines: 1_000_000, max_bytes: 100 } })
-      byteIt.live("output() truncates to configured max_bytes", () =>
-        Effect.gen(function* () {
-          const content = "a".repeat(1000)
-          const result = yield* (yield* Truncate.Service).output(content)
-          expect(result.truncated).toBe(true)
-          expect(result.content).toContain("bytes truncated...")
-        }),
-      )
-
-      const overrideIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 100 } })
-      overrideIt.live("per-call options still override config", () =>
-        Effect.gen(function* () {
-          const content = Array.from({ length: 50 }, (_, i) => `line${i}`).join("\n")
-          const result = yield* (yield* Truncate.Service).output(content, {
-            maxLines: 1000,
-            maxBytes: 1024 * 1024,
-          })
-          expect(result.truncated).toBe(false)
-        }),
-      )
-    })
-
-    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 Task tool when agent has task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", 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("Task tool")
-      }),
-    )
-
-    it.live("omits Task tool hint when agent lacks task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", 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("Task 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)
-  })
-
-  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)
-      }),
-    )
-  })
-})

package/test/tool/webfetch.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "@/tool/truncate"
-import { Instance } from "../../src/project/instance"
-import { WebFetchTool } from "../../src/tool/webfetch"
-import { SessionID, MessageID } from "../../src/session/schema"
-
-const projectRoot = path.join(import.meta.dir, "../..")
-
-const ctx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make("message"),
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-async function withFetch(fetch: (req: Request) => Response | Promise<Response>, fn: (url: URL) => Promise<void>) {
-  using server = Bun.serve({ port: 0, fetch })
-  await fn(server.url)
-}
-
-function exec(args: { url: string; format: "text" | "markdown" | "html" }) {
-  return WebFetchTool.pipe(
-    Effect.flatMap((info) => info.init()),
-    Effect.flatMap((tool) => tool.execute(args, ctx)),
-    Effect.provide(Layer.mergeAll(FetchHttpClient.layer, Truncate.defaultLayer, Agent.defaultLayer)),
-    Effect.runPromise,
-  )
-}
-
-describe("tool.webfetch", () => {
-  test("returns image responses as file attachments", async () => {
-    const bytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
-    await withFetch(
-      () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }),
-      async (url) => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const result = await exec({ url: new URL("/image.png", url).toString(), format: "markdown" })
-            expect(result.output).toBe("Image fetched successfully")
-            expect(result.attachments).toBeDefined()
-            expect(result.attachments?.length).toBe(1)
-            expect(result.attachments?.[0].type).toBe("file")
-            expect(result.attachments?.[0].mime).toBe("image/png")
-            expect(result.attachments?.[0].url.startsWith("data:image/png;base64,")).toBe(true)
-            expect(result.attachments?.[0]).not.toHaveProperty("id")
-            expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
-            expect(result.attachments?.[0]).not.toHaveProperty("messageID")
-          },
-        })
-      },
-    )
-  })
-
-  test("keeps svg as text output", async () => {
-    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><text>hello</text></svg>'
-    await withFetch(
-      () =>
-        new Response(svg, {
-          status: 200,
-          headers: { "content-type": "image/svg+xml; charset=UTF-8" },
-        }),
-      async (url) => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const result = await exec({ url: new URL("/image.svg", url).toString(), format: "html" })
-            expect(result.output).toContain("<svg")
-            expect(result.attachments).toBeUndefined()
-          },
-        })
-      },
-    )
-  })
-
-  test("keeps text responses as text output", async () => {
-    await withFetch(
-      () =>
-        new Response("hello from webfetch", {
-          status: 200,
-          headers: { "content-type": "text/plain; charset=utf-8" },
-        }),
-      async (url) => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const result = await exec({ url: new URL("/file.txt", url).toString(), format: "text" })
-            expect(result.output).toBe("hello from webfetch")
-            expect(result.attachments).toBeUndefined()
-          },
-        })
-      },
-    )
-  })
-})

package/test/tool/write.test.ts

@@ -1,291 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import path from "path"
-import fs from "fs/promises"
-import { WriteTool } from "../../src/tool/write"
-import { Instance } from "../../src/project/instance"
-import { LSP } from "@/lsp/lsp"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Bus } from "../../src/bus"
-import { Format } from "../../src/format"
-import { Truncate } from "@/tool/truncate"
-import { Tool } from "@/tool/tool"
-import { Agent } from "../../src/agent/agent"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const ctx = {
-  sessionID: SessionID.make("ses_test-write-session"),
-  messageID: MessageID.make(""),
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const it = testEffect(
-  Layer.mergeAll(
-    LSP.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Bus.layer,
-    Format.defaultLayer,
-    CrossSpawnSpawner.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
-)
-
-const init = Effect.fn("WriteToolTest.init")(function* () {
-  const info = yield* WriteTool
-  return yield* info.init()
-})
-
-const run = Effect.fn("WriteToolTest.run")(function* (
-  args: Tool.InferParameters<typeof WriteTool>,
-  next: Tool.Context = ctx,
-) {
-  const tool = yield* init()
-  return yield* tool.execute(args, next)
-})
-
-describe("tool.write", () => {
-  describe("new file creation", () => {
-    it.live("writes content to new file", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "newfile.txt")
-          const result = yield* run({ filePath: filepath, content: "Hello, World!" })
-
-          expect(result.output).toContain("Wrote file successfully")
-          expect(result.metadata.exists).toBe(false)
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content).toBe("Hello, World!")
-        }),
-      ),
-    )
-
-    it.live("creates parent directories if needed", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "nested", "deep", "file.txt")
-          yield* run({ filePath: filepath, content: "nested content" })
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content).toBe("nested content")
-        }),
-      ),
-    )
-
-    it.live("handles relative paths by resolving to instance directory", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          yield* run({ filePath: "relative.txt", content: "relative content" })
-
-          const content = yield* Effect.promise(() => fs.readFile(path.join(dir, "relative.txt"), "utf-8"))
-          expect(content).toBe("relative content")
-        }),
-      ),
-    )
-  })
-
-  describe("existing file overwrite", () => {
-    it.live("overwrites existing file content", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "existing.txt")
-          yield* Effect.promise(() => fs.writeFile(filepath, "old content", "utf-8"))
-          const result = yield* run({ filePath: filepath, content: "new content" })
-
-          expect(result.output).toContain("Wrote file successfully")
-          expect(result.metadata.exists).toBe(true)
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content).toBe("new content")
-        }),
-      ),
-    )
-
-    it.live("preserves BOM when overwriting existing files", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "existing.cs")
-          const bom = String.fromCharCode(0xfeff)
-          yield* Effect.promise(() => fs.writeFile(filepath, `${bom}using System;\n`, "utf-8"))
-
-          yield* run({ filePath: filepath, content: "using Up;\n" })
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content.charCodeAt(0)).toBe(0xfeff)
-          expect(content.slice(1)).toBe("using Up;\n")
-        }),
-      ),
-    )
-
-    it.live("restores BOM after formatter strips it", () =>
-      provideTmpdirInstance(
-        (dir) =>
-          Effect.gen(function* () {
-            const filepath = path.join(dir, "formatted.cs")
-            const bom = String.fromCharCode(0xfeff)
-            yield* Effect.promise(() => fs.writeFile(filepath, `${bom}using System;\n`, "utf-8"))
-
-            yield* run({ filePath: filepath, content: "using Up;\n" })
-
-            const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-            expect(content.charCodeAt(0)).toBe(0xfeff)
-            expect(content.slice(1)).toBe("using Up;\n")
-          }),
-        {
-          config: {
-            formatter: {
-              stripbom: {
-                extensions: [".cs"],
-                command: [
-                  "node",
-                  "-e",
-                  "const fs = require('fs'); const file = process.argv[1]; let text = fs.readFileSync(file, 'utf8'); if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); fs.writeFileSync(file, text, 'utf8')",
-                  "$FILE",
-                ],
-              },
-            },
-          },
-        },
-      ),
-    )
-
-    it.live("returns diff in metadata for existing files", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "file.txt")
-          yield* Effect.promise(() => fs.writeFile(filepath, "old", "utf-8"))
-          const result = yield* run({ filePath: filepath, content: "new" })
-
-          expect(result.metadata).toHaveProperty("filepath", filepath)
-          expect(result.metadata).toHaveProperty("exists", true)
-        }),
-      ),
-    )
-  })
-
-  describe("file permissions", () => {
-    it.live("sets file permissions when writing sensitive data", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "sensitive.json")
-          yield* run({ filePath: filepath, content: JSON.stringify({ secret: "data" }) })
-
-          if (process.platform !== "win32") {
-            const stats = yield* Effect.promise(() => fs.stat(filepath))
-            expect(stats.mode & 0o777).toBe(0o644)
-          }
-        }),
-      ),
-    )
-  })
-
-  describe("content types", () => {
-    it.live("writes JSON content", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "data.json")
-          const data = { key: "value", nested: { array: [1, 2, 3] } }
-          yield* run({ filePath: filepath, content: JSON.stringify(data, null, 2) })
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(JSON.parse(content)).toEqual(data)
-        }),
-      ),
-    )
-
-    it.live("writes binary-safe content", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "binary.bin")
-          const content = "Hello\x00World\x01\x02\x03"
-          yield* run({ filePath: filepath, content })
-
-          const buf = yield* Effect.promise(() => fs.readFile(filepath))
-          expect(buf.toString()).toBe(content)
-        }),
-      ),
-    )
-
-    it.live("writes empty content", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "empty.txt")
-          yield* run({ filePath: filepath, content: "" })
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content).toBe("")
-
-          const stats = yield* Effect.promise(() => fs.stat(filepath))
-          expect(stats.size).toBe(0)
-        }),
-      ),
-    )
-
-    it.live("writes multi-line content", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "multiline.txt")
-          const lines = ["Line 1", "Line 2", "Line 3", ""].join("\n")
-          yield* run({ filePath: filepath, content: lines })
-
-          const content = yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))
-          expect(content).toBe(lines)
-        }),
-      ),
-    )
-
-    it.live("handles different line endings", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "crlf.txt")
-          const content = "Line 1\r\nLine 2\r\nLine 3"
-          yield* run({ filePath: filepath, content })
-
-          const buf = yield* Effect.promise(() => fs.readFile(filepath))
-          expect(buf.toString()).toBe(content)
-        }),
-      ),
-    )
-  })
-
-  describe("error handling", () => {
-    it.live("throws error when OS denies write access", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const readonlyPath = path.join(dir, "readonly.txt")
-          yield* Effect.promise(() => fs.writeFile(readonlyPath, "test", "utf-8"))
-          yield* Effect.promise(() => fs.chmod(readonlyPath, 0o444))
-          const exit = yield* run({ filePath: readonlyPath, content: "new content" }).pipe(Effect.exit)
-          expect(exit._tag).toBe("Failure")
-        }),
-      ),
-    )
-  })
-
-  describe("title generation", () => {
-    it.live("returns relative path as title", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const filepath = path.join(dir, "src", "components", "Button.tsx")
-          yield* Effect.promise(() => fs.mkdir(path.dirname(filepath), { recursive: true }))
-
-          const result = yield* run({ filePath: filepath, content: "export const Button = () => {}" })
-          expect(result.title).toEndWith(path.join("src", "components", "Button.tsx"))
-        }),
-      ),
-    )
-  })
-})

package/test/util/data-url.test.ts

@@ -1,14 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { decodeDataUrl } from "../../src/util/data-url"
-
-describe("decodeDataUrl", () => {
-  test("decodes base64 data URLs", () => {
-    const body = '{\n  "ok": true\n}\n'
-    const url = `data:text/plain;base64,${Buffer.from(body).toString("base64")}`
-    expect(decodeDataUrl(url)).toBe(body)
-  })
-
-  test("decodes plain data URLs", () => {
-    expect(decodeDataUrl("data:text/plain,hello%20world")).toBe("hello world")
-  })
-})