fix: correctly showing Updated Files in repos without any commits

Author: wladimiiir

CHANGELOG.md

@@ -11,6 +11,7 @@
 - added drag and drop support for tasks and subtasks
 - avoid showing password dialog on start up in some cases
 - added getOpenProjects to Extension Context API
+- correctly showing Updated Files in repos without any commits
 
 ## [0.75.0]
 

src/main/worktrees/__tests__/worktree-manager.updated-files.test.ts

@@ -39,7 +39,7 @@ vi.mock('fs/promises', () => ({
 }));
 
 vi.mock('istextorbinary', () => ({
-  isBinary: () => false,
+  isBinary: vi.fn(() => false),
 }));
 
 const fs = await import('fs/promises');
@@ -168,3 +168,89 @@ describe('WorktreeManager - getUpdatedFiles symlink filtering', () => {
     expect(paths).not.toContain('resources/linux');
   });
 });
+
+describe('WorktreeManager - getUpdatedFiles no HEAD (no commits)', () => {
+  let worktreeManager: WorktreeManager;
+  const testPath = '/test/worktree';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    worktreeManager = new WorktreeManager();
+  });
+
+  it('should return staged files when there are no commits (non-worktree mode)', async () => {
+    const diffContent =
+      'diff --git a/src/main.ts b/src/main.ts\nnew file mode 100644\n--- /dev/null\n+++ b/src/main.ts\n@@ -0,0 +1,3 @@\n+line1\n+line2\n+line3';
+
+    useMockSeq(createMockSeq([new Error('HEAD not found'), { stdout: '3\t0\tsrc/main.ts\0', stderr: '' }, { stdout: diffContent, stderr: '' }]));
+    (lstatSync as Mock).mockReturnValue({ isSymbolicLink: () => false });
+    (fs.default.access as Mock).mockResolvedValue(undefined);
+    (fs.default.readFile as Mock).mockResolvedValue(Buffer.from('hello'));
+
+    const result = await worktreeManager.getUpdatedFiles(testPath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('src/main.ts');
+    expect(result[0].additions).toBe(3);
+    expect(result[0].deletions).toBe(0);
+    expect(result[0].diff).toBe(diffContent);
+  });
+
+  it('should filter symlink paths in no-HEAD mode', async () => {
+    useMockSeq(
+      createMockSeq([
+        new Error('HEAD not found'),
+        { stdout: '3\t0\tsrc/main.ts\0-\t-\tresources/linux\0', stderr: '' },
+        { stdout: 'diff content', stderr: '' },
+      ]),
+    );
+    (lstatSync as Mock).mockImplementation((p: string) => ({
+      isSymbolicLink: () => p.includes('resources/linux'),
+    }));
+    (fs.default.access as Mock).mockResolvedValue(undefined);
+    (fs.default.readFile as Mock).mockResolvedValue(Buffer.from('hello'));
+
+    const result = await worktreeManager.getUpdatedFiles(testPath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('src/main.ts');
+  });
+
+  it('should handle binary files in no-HEAD mode', async () => {
+    // @ts-expect-error istextorbinary library does not provide TypeScript definitions
+    const { isBinary } = await import('istextorbinary');
+    (isBinary as Mock).mockReturnValue(true);
+
+    useMockSeq(createMockSeq([new Error('HEAD not found'), { stdout: '-\t-\tassets/image.png\0', stderr: '' }]));
+    (lstatSync as Mock).mockReturnValue({ isSymbolicLink: () => false });
+    (fs.default.access as Mock).mockResolvedValue(undefined);
+    (fs.default.readFile as Mock).mockResolvedValue(Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+
+    const result = await worktreeManager.getUpdatedFiles(testPath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('assets/image.png');
+    expect(result[0].diff).toBe('');
+
+    (isBinary as Mock).mockReturnValue(false);
+  });
+
+  it('should return staged files in worktree mode when no HEAD exists', async () => {
+    const mainBranch = 'main';
+    const diffContent = 'diff --git a/src/app.ts b/src/app.ts\nnew file mode 100644\n--- /dev/null\n+++ b/src/app.ts\n@@ -0,0 +1,2 @@\n+hello\n+world';
+
+    useMockSeq(
+      createMockSeq([new Error('log failed'), new Error('HEAD not found'), { stdout: '2\t0\tsrc/app.ts\0', stderr: '' }, { stdout: diffContent, stderr: '' }]),
+    );
+    (lstatSync as Mock).mockReturnValue({ isSymbolicLink: () => false });
+    (fs.default.access as Mock).mockResolvedValue(undefined);
+    (fs.default.readFile as Mock).mockResolvedValue(Buffer.from('hello'));
+
+    const result = await worktreeManager.getUpdatedFiles(testPath, 'worktree', mainBranch);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('src/app.ts');
+    expect(result[0].additions).toBe(2);
+    expect(result[0].diff).toBe(diffContent);
+  });
+});

src/main/worktrees/worktree-manager.ts

@@ -1813,7 +1813,7 @@ export class WorktreeManager {
       // Check if HEAD exists (no commits yet in worktree)
       await execWithShellPath('git rev-parse HEAD', { cwd: worktreePath });
     } catch {
-      return files;
+      return files.concat(await this.getNoHeadUpdatedFiles(worktreePath));
     }
 
     try {
@@ -1956,7 +1956,7 @@ export class WorktreeManager {
     try {
       await execWithShellPath('git rev-parse HEAD', { cwd: worktreePath });
     } catch {
-      return [];
+      return await this.getNoHeadUpdatedFiles(worktreePath);
     }
 
     const { stdout } = await execWithShellPath('git diff --numstat -z HEAD', {
@@ -2019,6 +2019,82 @@ export class WorktreeManager {
     return files;
   }
 
+  /**
+   * No-HEAD mode: repo has no commits yet. Uses the well-known empty tree hash
+   * as the diff base, which is equivalent to `git diff HEAD` against an empty repo.
+   * Shows staged files and unstaged modifications to staged files (same as `git diff HEAD`
+   * would show if HEAD pointed to an empty commit). Untracked files are not shown,
+   * consistent with the existing HEAD-based behavior.
+   */
+  private async getNoHeadUpdatedFiles(worktreePath: string): Promise<UpdatedFile[]> {
+    const EMPTY_TREE_HASH = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+    const files: UpdatedFile[] = [];
+
+    try {
+      const { stdout } = await execWithShellPath(`git diff --numstat -z ${EMPTY_TREE_HASH}`, {
+        cwd: worktreePath,
+      });
+
+      const entries = stdout.split('\0').filter((entry) => entry.trim() !== '');
+
+      for (const entry of entries) {
+        const parts = entry.split('\t');
+        if (parts.length < 3) {
+          continue;
+        }
+
+        const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10);
+        const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10);
+        const filePath = parts.slice(2).join('\t');
+        if (!filePath) {
+          continue;
+        }
+
+        if (this.isSymlinkPath(worktreePath, filePath)) {
+          continue;
+        }
+
+        const absoluteFilePath = join(worktreePath, filePath);
+
+        let diff = '';
+        try {
+          const fileExists = await fs
+            .access(absoluteFilePath)
+            .then(() => true)
+            .catch(() => false);
+
+          if (fileExists) {
+            const fileContentBuffer = await fs.readFile(absoluteFilePath);
+            if (isBinary(filePath, fileContentBuffer)) {
+              files.push({ path: filePath, additions, deletions, diff });
+              continue;
+            }
+          }
+
+          const escapedPath = filePath.replace(/"/g, '\\"');
+          const { stdout: diffOutput } = await execWithShellPath(`git diff --unified=3 ${EMPTY_TREE_HASH} -- "${escapedPath}"`, {
+            cwd: worktreePath,
+            maxBuffer: 10 * 1024 * 1024,
+          });
+          diff = diffOutput;
+        } catch (diffError) {
+          logger.warn(`Failed to get diff for file ${filePath}:`, {
+            error: diffError instanceof Error ? diffError.message : String(diffError),
+          });
+          diff = '';
+        }
+
+        files.push({ path: filePath, additions, deletions, diff });
+      }
+    } catch (error) {
+      logger.warn('Failed to get updated files for repo with no commits:', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    return files;
+  }
+
   /**
    * Parse the output of `git diff-tree -p -r` into a map of filePath -> diff text.
    * Splits on "diff --git" boundaries to isolate per-file patches.