add gitIgnore module tests

Author: ponbac

apps/server/src/gitIgnore.test.ts

@@ -0,0 +1,80 @@
+import { assert, beforeEach, describe, it, vi } from "vitest";
+
+import type { ProcessRunOptions, ProcessRunResult } from "./processRunner";
+
+const { runProcessMock } = vi.hoisted(() => ({
+  runProcessMock:
+    vi.fn<
+      (
+        command: string,
+        args: readonly string[],
+        options?: ProcessRunOptions,
+      ) => Promise<ProcessRunResult>
+    >(),
+}));
+
+vi.mock("./processRunner", () => ({
+  runProcess: runProcessMock,
+}));
+
+function processResult(
+  overrides: Partial<ProcessRunResult> & Pick<ProcessRunResult, "stdout" | "code">,
+): ProcessRunResult {
+  return {
+    stdout: overrides.stdout,
+    code: overrides.code,
+    stderr: overrides.stderr ?? "",
+    signal: overrides.signal ?? null,
+    timedOut: overrides.timedOut ?? false,
+    stdoutTruncated: overrides.stdoutTruncated ?? false,
+    stderrTruncated: overrides.stderrTruncated ?? false,
+  };
+}
+
+describe("gitIgnore", () => {
+  beforeEach(() => {
+    runProcessMock.mockReset();
+    vi.resetModules();
+  });
+
+  it("chunks large git check-ignore requests and filters ignored matches", async () => {
+    const ignoredPaths = Array.from(
+      { length: 320 },
+      (_, index) => `ignored/${index.toString().padStart(4, "0")}/${"x".repeat(1024)}.ts`,
+    );
+    const keptPaths = ["src/keep.ts", "docs/readme.md"];
+    const relativePaths = [...ignoredPaths, ...keptPaths];
+    let checkIgnoreCalls = 0;
+
+    runProcessMock.mockImplementation(async (_command, args, options) => {
+      if (args[0] === "check-ignore") {
+        checkIgnoreCalls += 1;
+        const chunkPaths = (options?.stdin ?? "").split("\0").filter((value) => value.length > 0);
+        const chunkIgnored = chunkPaths.filter((value) => value.startsWith("ignored/"));
+        return processResult({
+          code: chunkIgnored.length > 0 ? 0 : 1,
+          stdout: chunkIgnored.length > 0 ? `${chunkIgnored.join("\0")}\0` : "",
+        });
+      }
+
+      throw new Error(`Unexpected command: git ${args.join(" ")}`);
+    });
+
+    const { filterGitIgnoredPaths } = await import("./gitIgnore");
+    const result = await filterGitIgnoredPaths("/virtual/workspace", relativePaths);
+
+    assert.isAbove(checkIgnoreCalls, 1);
+    assert.deepEqual(result, keptPaths);
+  });
+
+  it("fails open when git check-ignore cannot complete", async () => {
+    const relativePaths = ["src/keep.ts", "ignored.txt"];
+
+    runProcessMock.mockRejectedValueOnce(new Error("spawn failed"));
+
+    const { filterGitIgnoredPaths } = await import("./gitIgnore");
+    const result = await filterGitIgnoredPaths("/virtual/workspace", relativePaths);
+
+    assert.deepEqual(result, relativePaths);
+  });
+});

apps/server/src/gitIgnore.ts

@@ -2,15 +2,29 @@ import { runProcess } from "./processRunner";
 
 const GIT_CHECK_IGNORE_MAX_STDIN_BYTES = 256 * 1024;
 
+/**
+ * Shared git-ignore helpers for server-side workspace scans.
+ *
+ * Both callers use these helpers as an optimization and a consistency layer, not
+ * as a hard dependency. If git is unavailable, slow, or returns an unexpected
+ * result, we intentionally fail open so the UI keeps working and avoids hiding
+ * files unpredictably.
+ */
+
 function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
   const parts = input.split("\0");
-  if (parts.length === 0) return [];
   if (truncated && parts[parts.length - 1]?.length) {
     parts.pop();
   }
   return parts.filter((value) => value.length > 0);
 }
 
+/**
+ * Returns whether `cwd` is inside a git work tree.
+ *
+ * This is a cheap capability probe used to decide whether later git-aware
+ * filtering is worth attempting.
+ */
 export async function isInsideGitWorkTree(cwd: string): Promise<boolean> {
   const insideWorkTree = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], {
     cwd,
@@ -24,6 +38,14 @@ export async function isInsideGitWorkTree(cwd: string): Promise<boolean> {
   );
 }
 
+/**
+ * Filters repo-relative paths that match git ignore rules for `cwd`.
+ *
+ * We use `git check-ignore --no-index` so both tracked and untracked candidates
+ * respect the current ignore rules. Input is chunked to keep stdin bounded, and
+ * unexpected git failures return the original paths unchanged so callers fail
+ * open instead of dropping potentially valid files.
+ */
 export async function filterGitIgnoredPaths(
   cwd: string,
   relativePaths: readonly string[],