fix(git): avoid failing on untracked directory symlinks (#169)

Author: benvinegar

src/core/git.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import { join } from "node:path";
 import { HunkUserError } from "./errors";
 import type { GitCommandInput, ShowCommandInput, StashShowCommandInput } from "./types";
 
@@ -306,10 +308,45 @@ function parseUntrackedFilePaths(statusText: string) {
     .flatMap((entry) => (entry.startsWith("?? ") ? [entry.slice(3)] : []));
 }
 
+/** Return whether one untracked path can be synthesized into a file diff. */
+function isReviewableUntrackedPath(repoRoot: string, filePath: string) {
+  const absolutePath = join(repoRoot, filePath);
+
+  let pathInfo: fs.Stats;
+  try {
+    pathInfo = fs.lstatSync(absolutePath);
+  } catch {
+    // If the path disappeared after `git status`, let the downstream Git diff
+    // surface the same error path users would have seen before this filter.
+    return true;
+  }
+
+  if (pathInfo.isDirectory()) {
+    return false;
+  }
+
+  if (!pathInfo.isSymbolicLink()) {
+    return true;
+  }
+
+  try {
+    // Git reports directory symlinks as untracked paths, but `git diff --no-index`
+    // cannot synthesize a parseable file patch for them.
+    return !fs.statSync(absolutePath).isDirectory();
+  } catch {
+    // Broken symlinks still diff as reviewable path entries, so keep them.
+    return true;
+  }
+}
+
 /** Return the repo-root-relative untracked files for a working-tree review input. */
 export function listGitUntrackedFiles(
   input: GitCommandInput,
-  { cwd = process.cwd(), gitExecutable = "git" }: Omit<RunGitTextOptions, "input" | "args"> = {},
+  {
+    cwd = process.cwd(),
+    repoRoot,
+    gitExecutable = "git",
+  }: Omit<RunGitTextOptions, "input" | "args"> & { repoRoot?: string } = {},
 ) {
   if (!shouldIncludeUntrackedFiles(input)) {
     return [];
@@ -322,7 +359,15 @@ export function listGitUntrackedFiles(
     gitExecutable,
   });
 
-  return parseUntrackedFilePaths(statusText);
+  const untrackedFiles = parseUntrackedFilePaths(statusText);
+  if (untrackedFiles.length === 0) {
+    return [];
+  }
+
+  const normalizedRepoRoot = repoRoot ?? resolveGitRepoRoot(input, { cwd, gitExecutable });
+  return untrackedFiles.filter((filePath) =>
+    isReviewableUntrackedPath(normalizedRepoRoot, filePath),
+  );
 }
 
 /** Return the raw Git patch text for one untracked file using `git diff --no-index`. */

src/core/loaders.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { loadAppBootstrap } from "./loaders";
@@ -192,6 +192,30 @@ describe("loadAppBootstrap", () => {
     expect(bootstrap.changeset.files[1]?.patch).toContain("new file mode");
   });
 
+  test("skips untracked symlinks to directories while loading the rest of the review", async () => {
+    const dir = createTempRepo("hunk-git-untracked-dir-symlink-");
+
+    writeFileSync(join(dir, "tracked.ts"), "export const tracked = 1;\n");
+    git(dir, "add", "tracked.ts");
+    git(dir, "commit", "-m", "initial");
+
+    writeFileSync(join(dir, "tracked.ts"), "export const tracked = 2;\n");
+    writeFileSync(join(dir, "new-file.ts"), "export const added = true;\n");
+    mkdirSync(join(dir, "targetdir"), { recursive: true });
+    symlinkSync("targetdir", join(dir, "linkdir"));
+
+    const bootstrap = await loadFromRepo(dir, {
+      kind: "git",
+      staged: false,
+      options: { mode: "auto" },
+    });
+
+    expect(bootstrap.changeset.files.map((file) => file.path)).toEqual([
+      "tracked.ts",
+      "new-file.ts",
+    ]);
+  });
+
   test("can exclude untracked files from working tree reviews", async () => {
     const dir = createTempRepo("hunk-git-no-untracked-");
 

src/core/loaders.ts

@@ -392,7 +392,7 @@ async function loadGitChangeset(
     agentContext,
   );
   const trackedFiles = trackedChangeset.files;
-  const untrackedFiles = listGitUntrackedFiles(input);
+  const untrackedFiles = listGitUntrackedFiles(input, { cwd, repoRoot });
 
   if (untrackedFiles.length === 0) {
     return trackedChangeset;

src/core/watch.ts

@@ -33,7 +33,7 @@ function statSignature(path: string) {
 function gitWorkingTreeWatchSignature(input: Extract<CliInput, { kind: "git" }>) {
   const trackedPatch = runGitText({ input, args: buildGitDiffArgs(input) });
   const repoRoot = resolveGitRepoRoot(input);
-  const untrackedSignatures = listGitUntrackedFiles(input).map(
+  const untrackedSignatures = listGitUntrackedFiles(input, { repoRoot }).map(
     (filePath) => `untracked:${statSignature(join(repoRoot, filePath))}`,
   );