sailfork / t3code-github / apps/ server/ src/ workspace/ WorkspaceEntries.test.ts

// @effect-diagnostics nodeBuiltinImport:off
import * as NodeFSP from "node:fs/promises";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { FileFinder } from "@ff-labs/fff-node";
import { it, afterEach, describe, expect } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
import { vi } from "vite-plus/test";

import * as ServerConfig from "../config.ts";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as VcsProcess from "../vcs/VcsProcess.ts";
import * as WorkspaceEntries from "./WorkspaceEntries.ts";
import * as WorkspacePaths from "./WorkspacePaths.ts";

vi.mock("node:fs/promises", async (importOriginal) => {
  const actual = await importOriginal<typeof import("node:fs/promises")>();
  return { ...actual, readdir: vi.fn(actual.readdir) };
});

const layerTest = Layer.empty.pipe(
  Layer.provideMerge(WorkspaceEntries.layer.pipe(Layer.provide(WorkspacePaths.layer))),
  Layer.provideMerge(WorkspacePaths.layer),
  Layer.provideMerge(VcsProcess.layer),
  Layer.provide(
    ServerConfig.ServerConfig.layerTest(process.cwd(), {
      prefix: "t3-workspace-entries-test-",
    }),
  ),
  Layer.provideMerge(NodeServices.layer),
);

const makeTempDir = Effect.fn(function* (opts?: { prefix?: string; git?: boolean }) {
  const fileSystem = yield* FileSystem.FileSystem;
  const dir = yield* fileSystem.makeTempDirectoryScoped({
    prefix: opts?.prefix ?? "t3code-workspace-entries-",
  });
  if (opts?.git) {
    yield* git(dir, ["init"]);
  }
  return dir;
});

function writeTextFile(
  cwd: string,
  relativePath: string,
  contents = "",
): Effect.Effect<void, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> {
  return Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const absolutePath = path.join(cwd, relativePath);
    yield* fileSystem.makeDirectory(path.dirname(absolutePath), { recursive: true });
    yield* fileSystem.writeFileString(absolutePath, contents);
  });
}

const git = (cwd: string, args: ReadonlyArray<string>, env?: NodeJS.ProcessEnv) =>
  Effect.gen(function* () {
    const process = yield* VcsProcess.VcsProcess;
    const result = yield* process.run({
      operation: "WorkspaceEntries.test.git",
      command: "git",
      cwd,
      args,
      ...(env ? { env } : {}),
      timeoutMs: 10_000,
    });
    return result.stdout.trim();
  });

const searchWorkspaceEntries = (input: {
  cwd: string;
  query: string;
  limit: number;
  kind?: "file" | "directory";
}) =>
  Effect.gen(function* () {
    const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
    return yield* workspaceEntries.search(input);
  });

const appendSeparator = (input: string) =>
  Effect.map(HostProcess.Platform, (platform) =>
    input.endsWith("/") || input.endsWith("\\")
      ? input
      : `${input}${platform === "win32" ? "\\" : "/"}`,
  );

it.layer(layerTest, { excludeTestServices: true })("WorkspaceEntries", (it) => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe("list", () => {
    it.effect("lists immediate children including ignored and empty directories", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ git: true });
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        yield* writeTextFile(cwd, "tracked.txt");
        yield* git(cwd, ["add", "tracked.txt"]);
        yield* writeTextFile(cwd, ".gitignore", "node_modules/\n.env\ntracked.txt\n");
        yield* writeTextFile(cwd, ".env", "secret=value");
        yield* writeTextFile(cwd, "node_modules/pkg/index.js");
        yield* writeTextFile(cwd, "src/index.ts");
        yield* fileSystem.makeDirectory(path.join(cwd, "empty"));
        yield* git(cwd, ["init", "sub"]);
        yield* writeTextFile(cwd, "sub/.gitignore", "dist/\n");
        yield* writeTextFile(cwd, "sub/dist/out.js");
        const gitlink = yield* git(cwd, ["hash-object", "tracked.txt"]);
        yield* git(cwd, ["update-index", "--add", "--cacheinfo", `160000,${gitlink},sub`]);
        // A nested clone that isn't a submodule keeps the outer repository's ignore rules.
        yield* git(cwd, ["init", "node_modules/pkg"]);
        yield* git(cwd, ["init", "sub/dist"]);

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const root = yield* workspaceEntries.list({ cwd, directoryPath: "" });
        expect(root.entries).toEqual(
          expect.arrayContaining([
            { path: ".env", kind: "file", ignored: true },
            { path: "node_modules", kind: "directory", ignored: true },
            { path: "src", kind: "directory" },
            { path: "empty", kind: "directory" },
            { path: "tracked.txt", kind: "file" },
          ]),
        );
        expect(root.entries.some((entry) => entry.path.includes("/"))).toBe(false);
        expect(root.entries.some((entry) => entry.path === ".git")).toBe(false);
        expect(root.truncated).toBe(false);
        expect(yield* workspaceEntries.list({ cwd, directoryPath: "node_modules/pkg" })).toEqual({
          entries: [{ path: "node_modules/pkg/index.js", kind: "file", ignored: true }],
          truncated: false,
        });
        // Git refuses pathspecs inside a submodule from the outer repository.
        expect((yield* workspaceEntries.list({ cwd, directoryPath: "sub" })).entries).toEqual(
          expect.arrayContaining([
            { path: "sub/.gitignore", kind: "file" },
            { path: "sub/dist", kind: "directory", ignored: true },
          ]),
        );
        expect(yield* workspaceEntries.list({ cwd, directoryPath: "sub/dist" })).toEqual({
          entries: [{ path: "sub/dist/out.js", kind: "file", ignored: true }],
          truncated: false,
        });
        expect(yield* workspaceEntries.list({ cwd, directoryPath: "empty" })).toEqual({
          entries: [],
          truncated: false,
        });
      }),
    );

    it.effect("lists symlinks as what they point to, hiding ones that cannot be opened", () =>
      Effect.gen(function* () {
        const platform = yield* HostProcess.Platform;
        if (platform === "win32") return;
        const cwd = yield* makeTempDir({ git: true });
        const outside = yield* makeTempDir();
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        yield* writeTextFile(cwd, "real.txt");
        yield* writeTextFile(cwd, "realdir/nested.txt");
        yield* writeTextFile(outside, "outside.txt");
        yield* fileSystem.symlink("real.txt", path.join(cwd, "link.txt"));
        yield* fileSystem.symlink("realdir", path.join(cwd, "linkdir"));
        yield* fileSystem.symlink(outside, path.join(cwd, "outside-link"));
        yield* fileSystem.symlink(".git", path.join(cwd, "git-link"));
        yield* fileSystem.symlink("missing", path.join(cwd, "dangling"));

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const root = yield* workspaceEntries.list({ cwd, directoryPath: "" });
        expect(root.entries.toSorted((a, b) => a.path.localeCompare(b.path))).toEqual([
          { path: "link.txt", kind: "file" },
          { path: "linkdir", kind: "directory" },
          { path: "real.txt", kind: "file" },
          { path: "realdir", kind: "directory" },
        ]);
        expect(yield* workspaceEntries.list({ cwd, directoryPath: "linkdir" })).toEqual({
          entries: [{ path: "linkdir/nested.txt", kind: "file" }],
          truncated: false,
        });
      }),
    );

    it.effect("hides folder links that lead back to a folder on the listed path", () =>
      // "Expand all folders" loads every folder it expands, so a link that loops would
      // keep nesting the same entries without end.
      Effect.gen(function* () {
        const platform = yield* HostProcess.Platform;
        if (platform === "win32") return;
        const cwd = yield* makeTempDir();
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        yield* writeTextFile(cwd, "a/file.txt");
        yield* writeTextFile(cwd, "b/file.txt");
        yield* fileSystem.symlink(".", path.join(cwd, "self"));
        yield* fileSystem.symlink("..", path.join(cwd, "a/up"));
        yield* fileSystem.symlink("../b", path.join(cwd, "a/to-b"));
        yield* fileSystem.symlink("../a", path.join(cwd, "b/to-a"));

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const paths = (directoryPath: string) =>
          workspaceEntries
            .list({ cwd, directoryPath })
            .pipe(Effect.map(({ entries }) => entries.map((entry) => entry.path).toSorted()));
        expect(yield* paths("")).toEqual(["a", "b"]);
        // A link into a sibling folder is fine on its own...
        expect(yield* paths("a")).toEqual(["a/file.txt", "a/to-b"]);
        // ...but once followed, the sibling's link back is hidden.
        expect(yield* paths("a/to-b")).toEqual(["a/to-b/file.txt"]);
      }),
    );

    it.effect("resolves a folder of many symlinks in bounded batches", () =>
      Effect.gen(function* () {
        const platform = yield* HostProcess.Platform;
        if (platform === "win32") return;
        const cwd = yield* makeTempDir();
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        // Shaped like a pnpm `node_modules`: one link per package into `.pnpm`.
        const directoryPath = [...Array.from({ length: 80 }, () => "nested"), "node_modules"].join(
          "/",
        );
        const packages = Array.from({ length: 200 }, (_, index) => `pkg-${index}`);
        yield* Effect.forEach(
          packages,
          (name) =>
            Effect.gen(function* () {
              yield* writeTextFile(cwd, `${directoryPath}/.pnpm/${name}/index.js`);
              yield* fileSystem.symlink(`.pnpm/${name}`, path.join(cwd, directoryPath, name));
            }),
          { concurrency: 32, discard: true },
        );
        const realpath = NodeFSP.realpath;
        let inFlight = 0;
        let maxInFlight = 0;
        vi.spyOn(NodeFSP, "realpath").mockImplementation((async (target: string) => {
          maxInFlight = Math.max(maxInFlight, ++inFlight);
          try {
            return await realpath(target);
          } finally {
            inFlight--;
          }
        }) as typeof NodeFSP.realpath);

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const { entries } = yield* workspaceEntries.list({ cwd, directoryPath });
        expect(entries.map((entry) => entry.path).toSorted()).toEqual(
          [
            `${directoryPath}/.pnpm`,
            ...packages.map((name) => `${directoryPath}/${name}`),
          ].toSorted(),
        );
        expect(entries.every((entry) => entry.kind === "directory")).toBe(true);
        expect(maxInFlight).toBeLessThanOrEqual(64);
      }),
    );

    it.effect("labels the children of wide folders exactly as git does for each child", () =>
      Effect.gen(function* () {
        // Above 1,000 children, listing first asks whether the whole folder is ignored.
        const cwd = yield* makeTempDir({ git: true });
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const platform = yield* HostProcess.Platform;
        yield* writeTextFile(
          cwd,
          ".gitignore",
          "node_modules/\ndist/\n\\[id\\]/\n*.map\nfoo\n!foo/\n",
        );
        yield* Effect.forEach(
          [
            "node_modules",
            "dist",
            "[id]",
            "src",
            ...(platform !== "win32" ? [":foo"] : []),
          ].flatMap((directory) =>
            Array.from({ length: 1001 }, (_, index) => `${directory}/pkg-${index}.js`),
          ),
          (relativePath) => writeTextFile(cwd, relativePath),
          { concurrency: 32, discard: true },
        );
        for (const relativePath of [
          "dist/kept.js",
          "dist/vendored/index.js",
          "i/page.tsx",
          "[id]/page.tsx",
          "src/bundle.map",
        ]) {
          yield* writeTextFile(cwd, relativePath);
        }
        yield* git(cwd, ["add", "-f", "dist/kept.js", "dist/vendored/index.js", "i/page.tsx"]);
        if (platform !== "win32") {
          yield* fileSystem.symlink(path.join(cwd, "src"), path.join(cwd, "node_modules/link"));
        }

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        for (const { directoryPath, ignored, except } of [
          { directoryPath: "node_modules", ignored: true, except: [] },
          { directoryPath: "dist", ignored: true, except: ["dist/kept.js", "dist/vendored"] },
          // git reads `[id]/page.tsx` as a pathspec, which matches the tracked `i/page.tsx`.
          { directoryPath: "[id]", ignored: true, except: ["[id]/page.tsx"] },
          { directoryPath: "src", ignored: false, except: ["src/bundle.map"] },
          ...(platform !== "win32"
            ? [
                // git refuses to classify paths beyond a symlink, so nothing there is labelled.
                { directoryPath: "node_modules/link", ignored: false, except: [] },
                // Leading : is pathspec magic; Git sees foo/pkg-0.js, unignored by !foo/.
                { directoryPath: ":foo", ignored: false, except: [] },
              ]
            : []),
        ]) {
          const { entries } = yield* workspaceEntries.list({ cwd, directoryPath });
          expect(entries.length, directoryPath).toBeGreaterThan(1000);
          expect(
            entries
              .filter((entry) => (entry.ignored === true) !== ignored)
              .map((entry) => entry.path)
              .toSorted(),
            directoryPath,
          ).toEqual(except);
        }
      }),
    );

    it.effect("lists a host folder and its parent, each from its own root", () =>
      Effect.gen(function* () {
        const parent = yield* makeTempDir();
        const path = yield* Path.Path;
        yield* writeTextFile(parent, "linked/notes.md");
        yield* writeTextFile(parent, "sibling/readme.md");
        const linked = path.join(parent, "linked");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        expect(yield* workspaceEntries.list({ cwd: linked, directoryPath: "" })).toEqual({
          entries: [{ path: "notes.md", kind: "file" }],
          truncated: false,
        });
        const up = yield* workspaceEntries.list({ cwd: parent, directoryPath: "" });
        expect(up.entries.map((entry) => entry.path).toSorted()).toEqual(["linked", "sibling"]);
        const escape = yield* workspaceEntries
          .list({ cwd: linked, directoryPath: "../sibling" })
          .pipe(Effect.flip);
        expect(escape._tag).toBe("WorkspaceEntriesReadDirectoryError");
      }),
    );

    it.effect(
      "rejects directory traversal, git internals, and symlinks outside the workspace",
      () =>
        Effect.gen(function* () {
          const cwd = yield* makeTempDir();
          const outside = yield* makeTempDir();
          const fileSystem = yield* FileSystem.FileSystem;
          const path = yield* Path.Path;
          yield* writeTextFile(cwd, ".git/HEAD");
          const platform = yield* HostProcess.Platform;
          if (platform !== "win32") yield* fileSystem.symlink(outside, path.join(cwd, "external"));
          const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
          for (const directoryPath of [
            "../",
            outside,
            ".git",
            "missing",
            ...(platform !== "win32" ? ["external"] : []),
          ]) {
            const error = yield* workspaceEntries.list({ cwd, directoryPath }).pipe(Effect.flip);
            expect(error._tag).toBe("WorkspaceEntriesReadDirectoryError");
          }
        }),
    );

    it.effect("includes images and other binary files in non-git workspace indexes", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir();
        const imagePaths = ["photo.png", "photo.jpg", "photo.jpeg"];
        const binaryPaths = [...imagePaths, "document.pdf", "archive.zip", "data.bin"];
        for (const filePath of binaryPaths) {
          yield* writeTextFile(cwd, filePath, "\0binary contents\n");
        }
        yield* writeTextFile(cwd, "notes.txt", "plain text\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const expectedPaths = [...binaryPaths, "notes.txt"].toSorted();
        const listed = yield* workspaceEntries.list({ cwd });
        expect(listed.entries.map((entry) => entry.path).toSorted()).toEqual(expectedPaths);
        expect(listed.truncated).toBe(false);

        const searched = yield* workspaceEntries.search({
          cwd,
          query: "",
          limit: 100,
          kind: "file",
        });
        expect(searched.entries.map((entry) => entry.path).toSorted()).toEqual(expectedPaths);
        expect(searched.truncated).toBe(false);

        const images = yield* workspaceEntries.search({
          cwd,
          query: "",
          limit: 100,
          imageOnly: true,
        });
        expect(images.entries.map((entry) => entry.path).toSorted()).toEqual(imagePaths.toSorted());
        expect(images.truncated).toBe(false);
      }),
    );
  });

  describe("listIgnoredFiles", () => {
    it.effect("lists ignored files with sizes and skips wholly ignored folders", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ git: true });
        yield* writeTextFile(cwd, ".gitignore", "node_modules/\n.env*\n");
        yield* writeTextFile(cwd, ".env", "A=1");
        yield* writeTextFile(cwd, "apps/web/index.ts", "y");
        yield* git(cwd, ["add", "apps/web/index.ts"]);
        yield* writeTextFile(cwd, "apps/web/.env.local", "B=22");
        yield* writeTextFile(cwd, "node_modules/pkg/index.js", "x");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        expect(yield* workspaceEntries.listIgnoredFiles({ cwd })).toEqual({
          files: [
            { path: ".env", byteLength: 3 },
            { path: "apps/web/.env.local", byteLength: 4 },
          ],
          truncated: false,
        });
      }),
    );
  });

  describe("search", () => {
    it.effect("applies the file filter before limiting search results", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-file-limit-" });
        yield* writeTextFile(cwd, "src/index.ts");
        yield* writeTextFile(cwd, "src/internal.ts");

        const result = yield* searchWorkspaceEntries({
          cwd,
          query: "src",
          limit: 1,
          kind: "file",
        });

        // Native ranking can put either matching file first.
        expect(result.entries).toHaveLength(1);
        expect(result.entries[0]?.kind).toBe("file");
        expect(["src/index.ts", "src/internal.ts"]).toContain(result.entries[0]?.path);
        expect(result.truncated).toBe(true);
      }),
    );

    it.effect("excludes gitignored paths for git repositories", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-gitignore-", git: true });
        yield* writeTextFile(cwd, ".gitignore", ".convex/\nconvex/\nignored.txt\n");
        yield* writeTextFile(cwd, "src/keep.ts", "export {};");
        yield* writeTextFile(cwd, "ignored.txt", "ignore me");
        yield* writeTextFile(cwd, ".convex/local-storage/data.json", "{}");
        yield* writeTextFile(cwd, "convex/UOoS-l/convex_local_storage/modules/data.json", "{}");

        const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
        const paths = result.entries.map((entry) => entry.path);

        expect(paths).toContain("src");
        expect(paths).toContain("src/keep.ts");
        expect(paths).not.toContain("ignored.txt");
        expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
        expect(paths.some((entryPath) => entryPath.startsWith("convex/"))).toBe(false);
      }),
    );

    it.effect("excludes tracked paths that match ignore rules", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({
          prefix: "t3code-workspace-tracked-gitignore-",
          git: true,
        });
        yield* writeTextFile(cwd, ".convex/local-storage/data.json", "{}");
        yield* writeTextFile(cwd, "src/keep.ts", "export {};");
        yield* git(cwd, ["add", ".convex/local-storage/data.json", "src/keep.ts"]);
        yield* writeTextFile(cwd, ".gitignore", ".convex/\n");

        const result = yield* searchWorkspaceEntries({ cwd, query: "", limit: 100 });
        const paths = result.entries.map((entry) => entry.path);

        expect(paths).toContain("src");
        expect(paths).toContain("src/keep.ts");
        expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
      }),
    );
  });

  describe("searchContents", () => {
    it.effect("returns content matches with file paths, line numbers, and ranges", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-search-" });
        yield* writeTextFile(
          cwd,
          "src/shapes.ts",
          "export const square = 4;\nexport const Square = 16;\nexport const squareSize = 8;\n",
        );
        yield* writeTextFile(cwd, "src/other.ts", "const circle = true;\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "Square",
          limit: 100,
          caseSensitive: false,
          wholeWord: true,
          useRegex: false,
        });

        expect(result.matches.map((match) => [match.path, match.lineNumber])).toEqual([
          ["src/shapes.ts", 1],
          ["src/shapes.ts", 2],
        ]);
        expect(result.matches[0]?.matchRanges).toEqual([{ start: 13, end: 19 }]);
        expect(result.truncated).toBe(false);
      }),
    );

    it.effect("honors case sensitivity and gitignore rules", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-ignore-", git: true });
        yield* writeTextFile(cwd, ".gitignore", "ignored.txt\n");
        yield* writeTextFile(cwd, "src/keep.ts", "square\nSquare\n");
        yield* writeTextFile(cwd, "ignored.txt", "Square\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "Square",
          limit: 100,
          caseSensitive: true,
          wholeWord: false,
          useRegex: false,
        });

        expect(result.matches).toHaveLength(1);
        expect(result.matches[0]).toMatchObject({ path: "src/keep.ts", lineNumber: 2 });
      }),
    );

    it.effect("finds later whole-word matches in a file after rejected raw matches", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-late-whole-word-" });
        yield* writeTextFile(cwd, "src/words.ts", `${"afoo\n".repeat(10)}foo\n`);

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "foo",
          limit: 1,
          caseSensitive: true,
          wholeWord: true,
          useRegex: false,
        });

        expect(result.matches).toEqual([
          expect.objectContaining({
            path: "src/words.ts",
            lineNumber: 11,
            matchRanges: [{ start: 0, end: 3 }],
          }),
        ]);
      }),
    );

    it.effect("treats astral-plane letters as whole word characters", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-astral-word-" });
        yield* writeTextFile(cwd, "src/words.ts", "𐐀foo foo foo𐐀\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "foo",
          limit: 100,
          caseSensitive: true,
          wholeWord: true,
          useRegex: false,
        });

        expect(result.matches).toEqual([
          expect.objectContaining({
            path: "src/words.ts",
            lineNumber: 1,
            matchRanges: [{ start: 6, end: 9 }],
          }),
        ]);
      }),
    );

    it.effect("matches punctuation-edged whole-word queries including adjacent occurrences", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-punctuation-" });
        yield* writeTextFile(cwd, "src/words.ts", "-foo- -foo- -foo-\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "-foo-",
          limit: 100,
          caseSensitive: true,
          wholeWord: true,
          useRegex: false,
        });

        expect(result.matches).toHaveLength(1);
        expect(result.matches[0]).toMatchObject({
          path: "src/words.ts",
          lineNumber: 1,
          matchRanges: [
            { start: 0, end: 5 },
            { start: 6, end: 11 },
            { start: 12, end: 17 },
          ],
        });
      }),
    );

    it.effect("caps matches per file so one dense file cannot fill the page", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-per-file-cap-" });
        yield* writeTextFile(cwd, "src/dense.ts", "needle\n".repeat(300));
        yield* writeTextFile(cwd, "src/other.ts", "needle\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "needle",
          limit: 500,
          caseSensitive: true,
          wholeWord: false,
          useRegex: false,
        });

        const byPath = new Map<string, number>();
        for (const match of result.matches) {
          byPath.set(match.path, (byPath.get(match.path) ?? 0) + 1);
        }
        expect(byPath.get("src/dense.ts")).toBe(100);
        expect(byPath.get("src/other.ts")).toBe(1);
      }),
    );

    it.effect("preserves regex escapes during case-insensitive searches", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-regex-" });
        yield* writeTextFile(cwd, "src/shapes.ts", "Square\nsquare\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "\\SQUARE",
          limit: 100,
          caseSensitive: false,
          wholeWord: false,
          useRegex: true,
        });

        expect(result.matches.map((match) => match.lineNumber)).toEqual([1, 2]);
      }),
    );

    it.effect("searches an invalid regex literally without matching case", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-invalid-regex-" });
        yield* writeTextFile(cwd, "src/calls.ts", "call(Foo(bar));\n");

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "foo(",
          limit: 100,
          caseSensitive: false,
          wholeWord: false,
          useRegex: true,
        });

        expect(result.regexFallbackError).toBeDefined();
        expect(result.matches).toEqual([
          expect.objectContaining({
            path: "src/calls.ts",
            lineNumber: 1,
            matchRanges: [{ start: 5, end: 9 }],
          }),
        ]);
      }),
    );

    it.effect("maps multi-byte lines to string-indexed ranges", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-multibyte-" });
        yield* writeTextFile(cwd, "src/notes.ts", 'const label = "héllo wörld";\n');

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const result = yield* workspaceEntries.searchContents({
          cwd,
          query: "wörld",
          limit: 100,
          caseSensitive: true,
          wholeWord: false,
          useRegex: false,
        });

        expect(result.matches).toHaveLength(1);
        const match = result.matches[0]!;
        const range = match.matchRanges[0]!;
        expect(match.lineContent.slice(range.start, range.end)).toBe("wörld");
      }),
    );

    it.effect("keeps matches past the truncated part of a long line", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-long-line-" });
        yield* writeTextFile(cwd, "dist/app.min.js", `${"x".repeat(600)} needleSuffix\n`);

        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const search = (wholeWord: boolean) =>
          workspaceEntries.searchContents({
            cwd,
            query: "needle",
            limit: 100,
            caseSensitive: true,
            wholeWord,
            useRegex: false,
          });

        expect((yield* search(false)).matches).toEqual([
          expect.objectContaining({ path: "dist/app.min.js", lineNumber: 1 }),
        ]);
        expect((yield* search(true)).matches).toEqual([]);
      }),
    );

    it.effect("keeps answering from the live index when a refresh outlasts the scan wait", () =>
      Effect.gen(function* () {
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-content-refresh-" });
        yield* writeTextFile(cwd, "src/notes.ts", "const needle = 1;\n");
        let scansOutlastWait = false;
        let finders = 0;
        let rescans = 0;
        const createFinder = FileFinder.create.bind(FileFinder);
        vi.spyOn(FileFinder, "create").mockImplementation((options) => {
          const created = createFinder(options);
          if (created.ok) {
            const finder = created.value;
            finders += 1;
            const scanFiles = finder.scanFiles.bind(finder);
            finder.scanFiles = () => {
              rescans += 1;
              return scanFiles();
            };
            const waitForIndexReady = finder.waitForIndexReady.bind(finder);
            finder.waitForIndexReady = (timeoutMs) =>
              scansOutlastWait
                ? Promise.resolve({ ok: true, value: false })
                : waitForIndexReady(timeoutMs);
          }
          return created;
        });
        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const searchNeedle = workspaceEntries.searchContents({
          cwd,
          query: "needle",
          limit: 100,
          caseSensitive: true,
          wholeWord: false,
          useRegex: false,
        });
        yield* searchNeedle;

        scansOutlastWait = true;
        yield* workspaceEntries.refresh(cwd);
        const result = yield* searchNeedle;

        expect(result.matches.map((match) => match.path)).toEqual(["src/notes.ts"]);
        // The second search ran on the rescanned live finder, not a rebuild.
        expect({ finders, rescans }).toEqual({ finders: 1, rescans: 1 });
      }),
    );
  });

  describe("browse", () => {
    it.effect("shows dot directories in directory mode and hidden-prefix mode", () =>
      Effect.gen(function* () {
        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const path = yield* Path.Path;
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-browse-hidden-" });
        yield* writeTextFile(cwd, ".config/settings.json", "{}");
        yield* writeTextFile(cwd, "config/settings.json", "{}");
        const cwdWithSeparator = yield* appendSeparator(cwd);

        const directoryResult = yield* workspaceEntries.browse({
          partialPath: cwdWithSeparator,
        });
        const hiddenPrefixResult = yield* workspaceEntries.browse({
          partialPath: `${cwdWithSeparator}.c`,
        });

        expect(directoryResult.entries.map((entry) => entry.name)).toEqual([".config", "config"]);
        expect(hiddenPrefixResult).toEqual({
          parentPath: cwd,
          entries: [{ name: ".config", fullPath: path.join(cwd, ".config") }],
        });
      }),
    );

    it.effect("marks only a missing directory as missing when browsing fails", () =>
      Effect.gen(function* () {
        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
        const path = yield* Path.Path;
        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-browse-missing-" });
        yield* writeTextFile(cwd, "file.txt", "");

        const missing = yield* workspaceEntries
          .browse({ partialPath: `${path.join(cwd, "absent", "nested")}${path.sep}` })
          .pipe(Effect.flip);
        const underFile = yield* workspaceEntries
          .browse({ partialPath: `${path.join(cwd, "file.txt")}${path.sep}` })
          .pipe(Effect.flip);

        expect(missing).toMatchObject({
          _tag: "WorkspaceEntriesReadDirectoryError",
          pathMissing: true,
        });
        expect(underFile).toMatchObject({
          _tag: "WorkspaceEntriesReadDirectoryError",
          pathMissing: false,
        });
      }),
    );
  });
});