opencode/packages/opencode/test/file/index.test.ts

import { afterEach, describe, expect } from "bun:test"
import { AppFileSystem } from "@opencode-ai/core/filesystem"
import { $ } from "bun"
import { Cause, Effect, Exit, Layer } from "effect"
import path from "path"
import fs from "fs/promises"
import { File } from "../../src/file"
import { Filesystem } from "@/util/filesystem"
import { disposeAllInstances, TestInstance, withTmpdirInstance } from "../fixture/fixture"
import { testEffect } from "../lib/effect"

afterEach(async () => {
  await disposeAllInstances()
})

const it = testEffect(Layer.mergeAll(File.defaultLayer, AppFileSystem.defaultLayer))

const init = Effect.fn("FileTest.init")(function* () {
  const file = yield* File.Service
  return yield* file.init()
})

const status = Effect.fn("FileTest.status")(function* () {
  const file = yield* File.Service
  return yield* file.status()
})

const read = Effect.fn("FileTest.read")(function* (input: string) {
  const file = yield* File.Service
  return yield* file.read(input)
})

const list = Effect.fn("FileTest.list")(function* (dir?: string) {
  const file = yield* File.Service
  return yield* file.list(dir)
})

const search = Effect.fn("FileTest.search")(function* (input: {
  query: string
  limit?: number
  dirs?: boolean
  type?: "file" | "directory"
}) {
  const file = yield* File.Service
  return yield* file.search(input)
})

const gitAddAll = (directory: string) => Effect.promise(() => $`git add .`.cwd(directory).quiet())
const gitCommit = (directory: string, message: string) =>
  Effect.promise(() => $`git commit -m ${message}`.cwd(directory).quiet())

const failureMessage = <A, E, R>(self: Effect.Effect<A, E, R>) =>
  Effect.gen(function* () {
    const exit = yield* self.pipe(Effect.exit)
    if (Exit.isFailure(exit)) {
      const error = Cause.squash(exit.cause)
      return error instanceof Error ? error.message : String(error)
    }
    throw new Error("expected effect to fail")
  })

const setupSearchableRepo = Effect.fn("FileTest.setupSearchableRepo")(function* (directory: string) {
  const fsys = yield* AppFileSystem.Service
  yield* fsys.writeWithDirs(path.join(directory, "index.ts"), "code")
  yield* fsys.writeWithDirs(path.join(directory, "utils.ts"), "utils")
  yield* fsys.writeWithDirs(path.join(directory, "readme.md"), "readme")
  yield* fsys.writeWithDirs(path.join(directory, "src", "main.ts"), "main")
  yield* fsys.writeWithDirs(path.join(directory, ".hidden", "secret.ts"), "secret")
})

describe("file/index Filesystem patterns", () => {
  describe("read() - text content", () => {
    it.instance("reads text file via Filesystem.readText()", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.txt"), "Hello World", "utf-8"))

        const result = yield* read("test.txt")
        expect(result.type).toBe("text")
        expect(result.content).toBe("Hello World")
      }),
    )

    it.instance("reads with Filesystem.exists() check", () =>
      Effect.gen(function* () {
        const result = yield* read("nonexistent.txt")
        expect(result.type).toBe("text")
        expect(result.content).toBe("")
      }),
    )

    it.instance("trims whitespace from text content", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() =>
          fs.writeFile(path.join(test.directory, "test.txt"), "  content with spaces  \n\n", "utf-8"),
        )

        const result = yield* read("test.txt")
        expect(result.content).toBe("content with spaces")
      }),
    )

    it.instance("handles empty text file", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "empty.txt"), "", "utf-8"))

        const result = yield* read("empty.txt")
        expect(result.type).toBe("text")
        expect(result.content).toBe("")
      }),
    )

    it.instance("handles multi-line text files", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "multiline.txt"), "line1\nline2\nline3", "utf-8"))

        const result = yield* read("multiline.txt")
        expect(result.content).toBe("line1\nline2\nline3")
      }),
    )
  })

  describe("read() - binary content", () => {
    it.instance("reads binary file via Filesystem.readArrayBuffer()", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        const binaryContent = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "image.png"), binaryContent))

        const result = yield* read("image.png")
        expect(result.type).toBe("text")
        expect(result.encoding).toBe("base64")
        expect(result.mimeType).toBe("image/png")
        expect(result.content).toBe(binaryContent.toString("base64"))
      }),
    )

    it.instance("returns empty for binary non-image files", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "binary.so"), Buffer.from([0x7f, 0x45, 0x4c, 0x46])))

        const result = yield* read("binary.so")
        expect(result.type).toBe("binary")
        expect(result.content).toBe("")
      }),
    )
  })

  describe("read() - Filesystem.mimeType()", () => {
    it.instance("detects MIME type via Filesystem.mimeType()", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        const filepath = path.join(test.directory, "test.json")
        yield* Effect.promise(() => fs.writeFile(filepath, '{"key": "value"}', "utf-8"))

        expect(yield* Effect.promise(() => Filesystem.mimeType(filepath))).toContain("application/json")

        const result = yield* read("test.json")
        expect(result.type).toBe("text")
      }),
    )

    it.instance("handles various image MIME types", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        const testCases = [
          { ext: "jpg", mime: "image/jpeg" },
          { ext: "png", mime: "image/png" },
          { ext: "gif", mime: "image/gif" },
          { ext: "webp", mime: "image/webp" },
        ]

        for (const testCase of testCases) {
          const filepath = path.join(test.directory, `test.${testCase.ext}`)
          yield* Effect.promise(() => fs.writeFile(filepath, Buffer.from([0x00, 0x00, 0x00, 0x00])))
          expect(yield* Effect.promise(() => Filesystem.mimeType(filepath))).toContain(testCase.mime)
        }
      }),
    )
  })

  describe("list() - Filesystem.exists() and readText()", () => {
    it.instance(
      "reads .gitignore via Filesystem.exists() and readText()",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const gitignorePath = path.join(test.directory, ".gitignore")
          yield* Effect.promise(() => fs.writeFile(gitignorePath, "node_modules\ndist\n", "utf-8"))

          expect(yield* Effect.promise(() => Filesystem.exists(gitignorePath))).toBe(true)
          expect(yield* Effect.promise(() => Filesystem.readText(gitignorePath))).toContain("node_modules")
        }),
      { git: true },
    )

    it.instance(
      "reads .ignore file similarly",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const ignorePath = path.join(test.directory, ".ignore")
          yield* Effect.promise(() => fs.writeFile(ignorePath, "*.log\n.env\n", "utf-8"))

          expect(yield* Effect.promise(() => Filesystem.exists(ignorePath))).toBe(true)
          expect(yield* Effect.promise(() => Filesystem.readText(ignorePath))).toContain("*.log")
        }),
      { git: true },
    )

    it.instance(
      "handles missing .gitignore gracefully",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const gitignorePath = path.join(test.directory, ".gitignore")
          expect(yield* Effect.promise(() => Filesystem.exists(gitignorePath))).toBe(false)

          const nodes = yield* list()
          expect(Array.isArray(nodes)).toBe(true)
        }),
      { git: true },
    )
  })

  describe("File.changed() - Filesystem.readText() for untracked files", () => {
    it.instance(
      "reads untracked files via Filesystem.readText()",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const untrackedPath = path.join(test.directory, "untracked.txt")
          yield* Effect.promise(() => fs.writeFile(untrackedPath, "new content\nwith multiple lines", "utf-8"))

          const content = yield* Effect.promise(() => Filesystem.readText(untrackedPath))
          expect(content.split("\n").length).toBe(2)
        }),
      { git: true },
    )
  })

  describe("Error handling", () => {
    it.instance("handles errors gracefully in Filesystem.readText()", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "readonly.txt"), "content", "utf-8"))

        const nonExistentPath = path.join(test.directory, "does-not-exist.txt")
        expect(Exit.isFailure(yield* Effect.promise(() => Filesystem.readText(nonExistentPath)).pipe(Effect.exit))).toBe(true)

        const result = yield* read("does-not-exist.txt")
        expect(result.content).toBe("")
      }),
    )

    it.instance("handles errors in Filesystem.readArrayBuffer()", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        const nonExistentPath = path.join(test.directory, "does-not-exist.bin")
        const buffer = yield* Effect.promise(() => Filesystem.readArrayBuffer(nonExistentPath).catch(() => new ArrayBuffer(0)))
        expect(buffer.byteLength).toBe(0)
      }),
    )

    it.instance("returns empty array buffer on error for images", () =>
      Effect.gen(function* () {
        const result = yield* read("broken.png")
        expect(result.type).toBe("text")
        expect(result.content).toBe("")
      }),
    )
  })

  describe("shouldEncode() logic", () => {
    it.instance("treats .ts files as text", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.ts"), "export const value = 1", "utf-8"))

        const result = yield* read("test.ts")
        expect(result.type).toBe("text")
        expect(result.content).toBe("export const value = 1")
      }),
    )

    it.instance("treats .mts files as text", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.mts"), "export const value = 1", "utf-8"))

        const result = yield* read("test.mts")
        expect(result.type).toBe("text")
        expect(result.content).toBe("export const value = 1")
      }),
    )

    it.instance("treats .sh files as text", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.sh"), "#!/usr/bin/env bash\necho hello", "utf-8"))

        const result = yield* read("test.sh")
        expect(result.type).toBe("text")
        expect(result.content).toBe("#!/usr/bin/env bash\necho hello")
      }),
    )

    it.instance("treats Dockerfile as text", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "Dockerfile"), "FROM alpine:3.20", "utf-8"))

        const result = yield* read("Dockerfile")
        expect(result.type).toBe("text")
        expect(result.content).toBe("FROM alpine:3.20")
      }),
    )

    it.instance("returns encoding info for text files", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.txt"), "simple text", "utf-8"))

        const result = yield* read("test.txt")
        expect(result.encoding).toBeUndefined()
        expect(result.type).toBe("text")
      }),
    )

    it.instance("returns base64 encoding for images", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "test.jpg"), Buffer.from([0xff, 0xd8, 0xff, 0xe0])))

        const result = yield* read("test.jpg")
        expect(result.encoding).toBe("base64")
        expect(result.mimeType).toBe("image/jpeg")
      }),
    )
  })

  describe("Path security", () => {
    it.instance("throws for paths outside project directory", () =>
      Effect.gen(function* () {
        expect(yield* failureMessage(read("../outside.txt"))).toContain("Access denied")
      }),
    )

    it.instance("throws for paths outside project directory", () =>
      Effect.gen(function* () {
        expect(yield* failureMessage(read("../outside.txt"))).toContain("Access denied")
      }),
    )
  })

  describe("status()", () => {
    it.instance(
      "detects modified file",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "file.txt")
          yield* Effect.promise(() => fs.writeFile(filepath, "original\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add file")
          yield* Effect.promise(() => fs.writeFile(filepath, "modified\nextra line\n", "utf-8"))

          const result = yield* status()
          const entry = result.find((file) => file.path === "file.txt")
          expect(entry).toBeDefined()
          expect(entry!.status).toBe("modified")
          expect(entry!.added).toBeGreaterThan(0)
          expect(entry!.removed).toBeGreaterThan(0)
        }),
      { git: true },
    )

    it.instance(
      "detects untracked file as added",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "new.txt"), "line1\nline2\nline3\n", "utf-8"))

          const result = yield* status()
          const entry = result.find((file) => file.path === "new.txt")
          expect(entry).toBeDefined()
          expect(entry!.status).toBe("added")
          expect(entry!.added).toBe(4)
          expect(entry!.removed).toBe(0)
        }),
      { git: true },
    )

    it.instance(
      "detects deleted file",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "gone.txt")
          yield* Effect.promise(() => fs.writeFile(filepath, "content\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add file")
          yield* Effect.promise(() => fs.rm(filepath))

          const result = yield* status()
          const entries = result.filter((file) => file.path === "gone.txt")
          expect(entries.some((entry) => entry.status === "deleted")).toBe(true)
        }),
      { git: true },
    )

    it.instance(
      "detects mixed changes",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "keep.txt"), "keep\n", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "remove.txt"), "remove\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "initial")

          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "keep.txt"), "changed\n", "utf-8"))
          yield* Effect.promise(() => fs.rm(path.join(test.directory, "remove.txt")))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "brand-new.txt"), "hello\n", "utf-8"))

          const result = yield* status()
          expect(result.some((file) => file.path === "keep.txt" && file.status === "modified")).toBe(true)
          expect(result.some((file) => file.path === "remove.txt" && file.status === "deleted")).toBe(true)
          expect(result.some((file) => file.path === "brand-new.txt" && file.status === "added")).toBe(true)
        }),
      { git: true },
    )

    it.instance("returns empty for non-git project", () =>
      Effect.gen(function* () {
        expect(yield* status()).toEqual([])
      }),
    )

    it.instance(
      "returns empty for clean repo",
      () =>
        Effect.gen(function* () {
          expect(yield* status()).toEqual([])
        }),
      { git: true },
    )

    it.instance(
      "parses binary numstat as 0",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "data.bin")
          yield* Effect.promise(() => fs.writeFile(filepath, Buffer.from(Array.from({ length: 256 }, (_, index) => index))))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add binary")
          yield* Effect.promise(() => fs.writeFile(filepath, Buffer.from(Array.from({ length: 512 }, (_, index) => index % 256))))

          const result = yield* status()
          const entry = result.find((file) => file.path === "data.bin")
          expect(entry).toBeDefined()
          expect(entry!.status).toBe("modified")
          expect(entry!.added).toBe(0)
          expect(entry!.removed).toBe(0)
        }),
      { git: true },
    )
  })

  describe("list()", () => {
    it.instance(
      "returns files and directories with correct shape",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.mkdir(path.join(test.directory, "subdir")))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "file.txt"), "content", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "subdir", "nested.txt"), "nested", "utf-8"))

          const nodes = yield* list()
          expect(nodes.length).toBeGreaterThanOrEqual(2)
          for (const node of nodes) {
            expect(node).toHaveProperty("name")
            expect(node).toHaveProperty("path")
            expect(node).toHaveProperty("absolute")
            expect(node).toHaveProperty("type")
            expect(node).toHaveProperty("ignored")
            expect(["file", "directory"]).toContain(node.type)
          }
        }),
      { git: true },
    )

    it.instance(
      "sorts directories before files, alphabetical within each",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.mkdir(path.join(test.directory, "beta")))
          yield* Effect.promise(() => fs.mkdir(path.join(test.directory, "alpha")))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "zz.txt"), "", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "aa.txt"), "", "utf-8"))

          const nodes = yield* list()
          const dirs = nodes.filter((node) => node.type === "directory")
          const files = nodes.filter((node) => node.type === "file")
          const firstFile = nodes.findIndex((node) => node.type === "file")
          const lastDir = nodes.findLastIndex((node) => node.type === "directory")
          if (lastDir >= 0 && firstFile >= 0) {
            expect(lastDir).toBeLessThan(firstFile)
          }
          expect(dirs.map((dir) => dir.name)).toEqual(dirs.map((dir) => dir.name).toSorted())
          expect(files.map((file) => file.name)).toEqual(files.map((file) => file.name).toSorted())
        }),
      { git: true },
    )

    it.instance(
      "excludes .git and .DS_Store",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, ".DS_Store"), "", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "visible.txt"), "", "utf-8"))

          const names = (yield* list()).map((node) => node.name)
          expect(names).not.toContain(".git")
          expect(names).not.toContain(".DS_Store")
          expect(names).toContain("visible.txt")
        }),
      { git: true },
    )

    it.instance(
      "marks gitignored files as ignored",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, ".gitignore"), "*.log\nbuild/\n", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "app.log"), "log data", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "main.ts"), "code", "utf-8"))
          yield* Effect.promise(() => fs.mkdir(path.join(test.directory, "build")))

          const nodes = yield* list()
          expect(nodes.find((node) => node.name === "app.log")?.ignored).toBe(true)
          expect(nodes.find((node) => node.name === "main.ts")?.ignored).toBe(false)
          expect(nodes.find((node) => node.name === "build")?.ignored).toBe(true)
        }),
      { git: true },
    )

    it.instance(
      "lists subdirectory contents",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.mkdir(path.join(test.directory, "sub")))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "sub", "a.txt"), "", "utf-8"))
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "sub", "b.txt"), "", "utf-8"))

          const nodes = yield* list("sub")
          expect(nodes.length).toBe(2)
          expect(nodes.map((node) => node.name).sort()).toEqual(["a.txt", "b.txt"])
          expect(nodes[0].path.replaceAll("\\", "/").startsWith("sub/")).toBe(true)
        }),
      { git: true },
    )

    it.instance(
      "throws for paths outside project directory",
      () =>
        Effect.gen(function* () {
          expect(yield* failureMessage(list("../outside"))).toContain("Access denied")
        }),
      { git: true },
    )

    it.instance("works without git", () =>
      Effect.gen(function* () {
        const test = yield* TestInstance
        yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "file.txt"), "hi", "utf-8"))

        const nodes = yield* list()
        expect(nodes.length).toBeGreaterThanOrEqual(1)
        for (const node of nodes) {
          expect(node.ignored).toBe(false)
        }
      }),
    )
  })

  describe("search()", () => {
    it.instance(
      "empty query returns files",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "", type: "file" })
          expect(result.length).toBeGreaterThan(0)
        }),
      { git: true },
    )

    it.instance(
      "search works before explicit init",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)

          const result = yield* search({ query: "main", type: "file" })
          expect(result.some((file) => file.includes("main"))).toBe(true)
        }),
      { git: true },
    )

    it.instance(
      "empty query returns dirs sorted with hidden last",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "", type: "directory" })
          expect(result.length).toBeGreaterThan(0)
          const firstHidden = result.findIndex((dir) => dir.split("/").some((part) => part.startsWith(".") && part.length > 1))
          const lastVisible = result.findLastIndex((dir) => !dir.split("/").some((part) => part.startsWith(".") && part.length > 1))
          if (firstHidden >= 0 && lastVisible >= 0) {
            expect(firstHidden).toBeGreaterThan(lastVisible)
          }
        }),
      { git: true },
    )

    it.instance(
      "fuzzy matches file names",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "main", type: "file" })
          expect(result.some((file) => file.includes("main"))).toBe(true)
        }),
      { git: true },
    )

    it.instance(
      "type filter returns only files",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "", type: "file" })
          for (const file of result) {
            expect(file.endsWith("/")).toBe(false)
          }
        }),
      { git: true },
    )

    it.instance(
      "type filter returns only directories",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "", type: "directory" })
          for (const dir of result) {
            expect(dir.endsWith("/")).toBe(true)
          }
        }),
      { git: true },
    )

    it.instance(
      "respects limit",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: "", type: "file", limit: 2 })
          expect(result.length).toBeLessThanOrEqual(2)
        }),
      { git: true },
    )

    it.instance(
      "query starting with dot prefers hidden files",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()

          const result = yield* search({ query: ".hidden", type: "directory" })
          expect(result.length).toBeGreaterThan(0)
          expect(result[0]).toContain(".hidden")
        }),
      { git: true },
    )

    it.instance(
      "search refreshes after init when files change",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* setupSearchableRepo(test.directory)
          yield* init()
          expect(yield* search({ query: "fresh", type: "file" })).toEqual([])

          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "fresh.ts"), "fresh", "utf-8"))

          expect(yield* search({ query: "fresh", type: "file" })).toContain("fresh.ts")
        }),
      { git: true },
    )
  })

  describe("read() - diff/patch", () => {
    it.instance(
      "returns diff and patch for modified tracked file",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "file.txt")
          yield* Effect.promise(() => fs.writeFile(filepath, "original content\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add file")
          yield* Effect.promise(() => fs.writeFile(filepath, "modified content\n", "utf-8"))

          const result = yield* read("file.txt")
          expect(result.type).toBe("text")
          expect(result.content).toBe("modified content")
          expect(result.diff).toBeDefined()
          expect(result.diff).toContain("original content")
          expect(result.diff).toContain("modified content")
          expect(result.patch).toBeDefined()
          expect(result.patch!.hunks.length).toBeGreaterThan(0)
        }),
      { git: true },
    )

    it.instance(
      "returns diff for staged changes",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "staged.txt")
          yield* Effect.promise(() => fs.writeFile(filepath, "before\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add file")
          yield* Effect.promise(() => fs.writeFile(filepath, "after\n", "utf-8"))
          yield* gitAddAll(test.directory)

          const result = yield* read("staged.txt")
          expect(result.diff).toBeDefined()
          expect(result.patch).toBeDefined()
        }),
      { git: true },
    )

    it.instance(
      "returns no diff for unmodified file",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          const filepath = path.join(test.directory, "clean.txt")
          yield* Effect.promise(() => fs.writeFile(filepath, "unchanged\n", "utf-8"))
          yield* gitAddAll(test.directory)
          yield* gitCommit(test.directory, "add file")

          const result = yield* read("clean.txt")
          expect(result.type).toBe("text")
          expect(result.content).toBe("unchanged")
          expect(result.diff).toBeUndefined()
          expect(result.patch).toBeUndefined()
        }),
      { git: true },
    )
  })

  describe("InstanceState isolation", () => {
    it.instance(
      "two directories get independent file caches",
      () =>
        Effect.gen(function* () {
          const one = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(one.directory, "a.ts"), "one", "utf-8"))
          yield* init()
          expect(yield* search({ query: "a.ts", type: "file" })).toContain("a.ts")
          expect(yield* search({ query: "b.ts", type: "file" })).not.toContain("b.ts")

          yield* Effect.gen(function* () {
            const two = yield* TestInstance
            yield* Effect.promise(() => fs.writeFile(path.join(two.directory, "b.ts"), "two", "utf-8"))
            yield* init()
            expect(yield* search({ query: "b.ts", type: "file" })).toContain("b.ts")
            expect(yield* search({ query: "a.ts", type: "file" })).not.toContain("a.ts")
          }).pipe(withTmpdirInstance({ git: true }))
        }),
      { git: true },
    )

    it.instance(
      "disposal gives fresh state on next access",
      () =>
        Effect.gen(function* () {
          const test = yield* TestInstance
          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "before.ts"), "before", "utf-8"))
          yield* init()
          expect(yield* search({ query: "before", type: "file" })).toContain("before.ts")

          yield* Effect.promise(() => disposeAllInstances())

          yield* Effect.promise(() => fs.writeFile(path.join(test.directory, "after.ts"), "after", "utf-8"))
          yield* Effect.promise(() => fs.rm(path.join(test.directory, "before.ts")))

          yield* init()
          expect(yield* search({ query: "after", type: "file" })).toContain("after.ts")
          expect(yield* search({ query: "before", type: "file" })).not.toContain("before.ts")
        }),
      { git: true },
    )
  })
})