@aiworker/web 1.22.0 → 1.23.0

package/server/lib/git/service.test.js

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
 import simpleGit from 'simple-git';
+import { loadSourceSections, parseSource, sourceKey } from '../walkthrough/sources.js';
+import { registerGitRoutes } from './routes.js';
 
 import {
   checkoutBranch,
@@ -12,7 +14,12 @@ import {
   createWorktree,
   getWorktreeBootstrapStatus,
   getBranches,
+  getUnpushedBranchCounts,
   getRangeDiff,
+  getBranchBase,
+  getCommitDiff,
+  getCommitFiles,
+  getLog,
   getStatus,
   getWorktrees,
   isGitRepository,
@@ -28,6 +35,7 @@ import {
   unstageFiles,
   applyHunk,
   getDiff,
+  getUntrackedDiffs,
   getFileDiff,
   validateWorktreeCreate,
   parseBranchCreationSource,
@@ -54,6 +62,14 @@ const runGit = (cwd, args) =>
     stdio: ['ignore', 'pipe', 'pipe'],
   });
 
+const readBranchConfig = (cwd, branch, key) => {
+  try {
+    return runGit(cwd, ['config', '--get', `branch.${branch}.${key}`]).trim();
+  } catch {
+    return '';
+  }
+};
+
 /**
  * A repository on `next` whose only remote publishes `defaultBranch` and has it
  * recorded as that remote's HEAD — the shape of every repository whose default
@@ -174,28 +190,49 @@ describe.runIf(canRunGit())('setLocalIdentity', () => {
       "ssh -i '/tmp/test key' -o IdentitiesOnly=yes"
     );
   });
+
+  it('configures the stored credential helper for token auth with the targeted simple-git opt-in', async () => {
+    const { tmpDir } = await createTempRepo();
+
+    await setLocalIdentity(tmpDir, {
+      userName: 'Token User',
+      userEmail: 'token@example.com',
+      authType: 'token',
+      host: 'github.com',
+    });
+
+    expect(runGit(tmpDir, ['config', '--local', '--get', 'credential.helper']).trim()).toBe('store');
+  });
+
+  it('clears the stored credential helper when switching to SSH auth', async () => {
+    const { tmpDir } = await createTempRepo();
+
+    await setLocalIdentity(tmpDir, {
+      userName: 'Token User',
+      userEmail: 'token@example.com',
+      authType: 'token',
+      host: 'github.com',
+    });
+    await setLocalIdentity(tmpDir, {
+      userName: 'SSH User',
+      userEmail: 'ssh@example.com',
+      authType: 'ssh',
+      sshKey: '/tmp/test key',
+    });
+
+    expect(runGit(tmpDir, ['config', '--local', '--get', 'core.sshCommand']).trim()).toBe(
+      "ssh -i '/tmp/test key' -o IdentitiesOnly=yes"
+    );
+    expect(() => runGit(tmpDir, ['config', '--local', '--get', 'credential.helper'])).toThrow();
+  });
 });
 
 // ---------------------------------------------------------------------------
 // applyHunk (per-hunk stage / unstage / discard)
 // ---------------------------------------------------------------------------
 
-/** Minimal unified-diff splitter: returns standalone per-hunk patches. */
-const splitHunks = (patch) => {
-  const lines = patch.split(/\r?\n/);
-  const headerEnd = lines.findIndex((line) => /^@@\s/.test(line));
-  if (headerEnd === -1) return [];
-  const header = lines.slice(0, headerEnd);
-  const hunks = [];
-  for (let i = headerEnd; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (/^@@\s/.test(line)) hunks.push([...header, line]);
-    else if (hunks.length > 0) hunks[hunks.length - 1].push(line);
-  }
-  return hunks.map((hunk) => hunk.join('\n'))
-    .filter((hunk) => hunk.trim().length > 0)
-    .map((hunk) => (hunk.endsWith('\n') ? hunk : `${hunk}\n`));
-};
+// Exercise the actual client splitter against the server apply boundary.
+import { splitPatchIntoHunks as splitHunks } from '../../../../ui/src/lib/diff/patchFileDiff.ts';
 
 const writeFile = (repo, name, contents) =>
   fs.promises.writeFile(path.join(repo, name), contents, 'utf8');
@@ -211,6 +248,77 @@ const readWorking = (repo) => fs.promises.readFile(path.join(repo, 'file.txt'),
 const readStaged = async (git) => (await git.raw(['show', ':file.txt'])).replace(/\r\n/g, '\n');
 
 describe('applyHunk', () => {
+  it('stages successive hunks and never discards a stale staged or committed patch', async () => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    const original = Array.from({ length: 60 }, (_, index) => `line${index}`);
+    const changed = [...original];
+    changed[1] = 'FIRST'; changed[25] = 'SECOND'; changed[50] = 'THIRD';
+    await writeFile(tmpDir, 'file.txt', original.join('\n') + '\n');
+    await git.add('file.txt'); await git.commit('Initial');
+    await writeFile(tmpDir, 'file.txt', changed.join('\n') + '\n');
+    const historical = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(historical).toHaveLength(3);
+    await applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'stage' });
+    const remaining = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(remaining).toHaveLength(2);
+    await applyHunk(tmpDir, 'file.txt', { patch: remaining[0], action: 'stage' });
+    const stalePath = path.join(tmpDir, 'stale.patch');
+    await fs.promises.writeFile(stalePath, historical[0]);
+    // Git's reverse applicability check accepts it, but it is no longer an
+    // unstaged hunk. The server must reject it before touching the working file.
+    await git.raw(['apply', '--reverse', '--check', stalePath]);
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'discard' })).rejects.toThrow('refresh and try again');
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    const last = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    expect(last).toHaveLength(1);
+    await applyHunk(tmpDir, 'file.txt', { patch: last[0], action: 'discard' });
+    changed[50] = original[50];
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    expect(await readStaged(git)).toBe(changed.join('\n') + '\n');
+    const staged = splitHunks(await getDiff(tmpDir, { path: 'file.txt', staged: true }));
+    await applyHunk(tmpDir, 'file.txt', { patch: staged[0], action: 'unstage' });
+    expect(await readWorking(tmpDir)).toBe(changed.join('\n') + '\n');
+    await git.add('file.txt'); await git.commit('Committed changes');
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: historical[0], action: 'discard' })).rejects.toThrow('refresh and try again');
+  });
+
+  it.each(['crlf', 'mixed'])('preserves %s file bytes through stage, unstage and discard', async (endings) => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    await git.addConfig('core.autocrlf', 'false');
+    const serialize = (first, last) => Array.from({ length: 30 }, (_, index) => {
+      const text = index === 0 ? first : index === 29 ? last : `line${index}`;
+      return text + (endings === 'crlf' || index % 2 === 0 ? '\r\n' : '\n');
+    }).join('');
+    const original = serialize('first', 'last');
+    const edited = serialize('FIRST', 'LAST');
+    await writeFile(tmpDir, 'file.txt', original);
+    await git.add('file.txt'); await git.commit('Initial');
+    await writeFile(tmpDir, 'file.txt', edited);
+    const hunks = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    await applyHunk(tmpDir, 'file.txt', { patch: hunks[0], action: 'stage' });
+    expect(await git.raw(['show', ':file.txt'])).toBe(serialize('FIRST', 'last'));
+    const staged = splitHunks(await getDiff(tmpDir, { path: 'file.txt', staged: true }));
+    await applyHunk(tmpDir, 'file.txt', { patch: staged[0], action: 'unstage' });
+    expect(await git.raw(['show', ':file.txt'])).toBe(original);
+    const working = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }));
+    await applyHunk(tmpDir, 'file.txt', { patch: working[0], action: 'discard' });
+    expect(await fs.promises.readFile(path.join(tmpDir, 'file.txt'), 'utf8')).toBe(serialize('first', 'LAST'));
+  });
+
+  it('rejects extra files hidden before the requested patch', async () => {
+    if (!canRunGit()) return;
+    const { tmpDir, git } = await createTempRepo();
+    for (const name of ['file.txt', 'other.txt']) await writeFile(tmpDir, name, ORIGINAL_FILE);
+    await git.add('.'); await git.commit('Initial');
+    for (const name of ['file.txt', 'other.txt']) await writeFile(tmpDir, name, EDITED_FILE);
+    const other = splitHunks(await getDiff(tmpDir, { path: 'other.txt' }))[0];
+    const requested = splitHunks(await getDiff(tmpDir, { path: 'file.txt' }))[0];
+    await expect(applyHunk(tmpDir, 'file.txt', { patch: requested + other, action: 'stage' })).rejects.toThrow('refresh and try again');
+    expect(await git.raw(['diff', '--cached'])).toBe('');
+  });
+
   it('rejects an invalid action or a patch without a hunk header', async () => {
     const { tmpDir } = await createTempRepo();
     await expect(applyHunk(tmpDir, 'file.txt', { patch: '@@ -1 +1 @@\n a\n', action: 'bogus' })).rejects.toThrow(
@@ -293,10 +401,9 @@ describe('applyHunk', () => {
     );
   });
 
-  it('accepts hunk patches for files with spaces in their path', async () => {
+  it.each(['file name.txt', 'зміни.txt'])('accepts hunk patches for %s', async (filePath) => {
     if (!canRunGit()) return;
     const { tmpDir, git } = await createTempRepo();
-    const filePath = 'file name.txt';
     await writeFile(tmpDir, filePath, ORIGINAL_FILE);
     await git.add(filePath);
     await git.commit('Initial');
@@ -313,6 +420,71 @@ describe('applyHunk', () => {
   });
 });
 
+describe.runIf(canRunGit())('untracked diffs', () => {
+  it.each(['false', 'warn'])('returns only the patch with core.safecrlf=%s', async (safecrlf) => {
+    const { tmpDir, git } = await createTempRepo();
+    await git.addConfig('core.autocrlf', 'true');
+    await git.addConfig('core.safecrlf', safecrlf);
+    fs.writeFileSync(path.join(tmpDir, 'new file.txt'), 'first\nsecond\n');
+
+    // Confirm this fixture produces a real diff exit, including stderr in the warning case.
+    let expectedPatch;
+    try {
+      runGit(tmpDir, ['diff', '--no-color', '--full-index', '--no-index', '--', '/dev/null', 'new file.txt']);
+      throw new Error('Expected git diff to exit with differences');
+    } catch (error) {
+      expect(error.status).toBe(1);
+      expectedPatch = error.stdout;
+      if (safecrlf === 'warn') {
+        expect(error.stderr).toContain('LF will be replaced by CRLF');
+      }
+    }
+
+    const diff = await getDiff(tmpDir, { path: 'new file.txt' });
+    expect(diff).toBe(expectedPatch);
+    expect(diff).toContain('+first\n+second\n');
+    expect(diff).not.toContain('warning:');
+    expect(await getUntrackedDiffs(tmpDir, ['new file.txt'])).toEqual([diff]);
+  });
+
+  it('accepts an empty untracked file without a process error', async () => {
+    const { tmpDir } = await createTempRepo();
+    fs.writeFileSync(path.join(tmpDir, 'empty.txt'), '');
+    const diff = await getDiff(tmpDir, { path: 'empty.txt' });
+    expect(diff).toContain('new file mode 100644');
+    expect(diff).not.toContain('@@');
+    expect(await getUntrackedDiffs(tmpDir, ['empty.txt'])).toEqual([diff]);
+  });
+
+  it('rejects fatal conversion errors while preserving other batch entries', async () => {
+    const { tmpDir } = await createTempRepo();
+    runGit(tmpDir, ['config', 'diff.broken.textconv', 'false']);
+    fs.writeFileSync(path.join(tmpDir, '.gitattributes'), 'bad.txt diff=broken\n');
+    fs.writeFileSync(path.join(tmpDir, 'first.safe'), 'first\n');
+    fs.writeFileSync(path.join(tmpDir, 'bad.txt'), 'bad\n');
+    fs.writeFileSync(path.join(tmpDir, 'last.safe'), 'last\n');
+
+    await expect(getDiff(tmpDir, { path: 'bad.txt' })).rejects.toThrow('unable to read files to diff');
+    const diffs = await getUntrackedDiffs(tmpDir, ['first.safe', 'bad.txt', 'last.safe'], { concurrency: 1 });
+    expect(diffs).toHaveLength(3);
+    expect(diffs[0]).toContain('+first\n');
+    expect(diffs[1]).toBe('');
+    expect(diffs[2]).toContain('+last\n');
+  });
+
+  it('rejects truncated patches when the process output exceeds the buffer limit', async () => {
+    const { tmpDir } = await createTempRepo();
+    fs.writeFileSync(path.join(tmpDir, 'large.txt'), 'x'.repeat(21 * 1024 * 1024) + '\n');
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      await expect(getDiff(tmpDir, { path: 'large.txt' })).rejects.toThrow('maxBuffer');
+      expect(await getUntrackedDiffs(tmpDir, ['large.txt'])).toEqual(['']);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});
+
 describe('symlink diffs', () => {
   it('treats an untracked directory symlink as a link in patch and split diffs', async () => {
     if (!canRunGit() || process.platform === 'win32') return;
@@ -508,6 +680,24 @@ describe('getWorktrees', () => {
     expect(Array.isArray(result)).toBe(true);
     expect(warnSpy).not.toHaveBeenCalled();
   });
+  it('flags a worktree whose directory was deleted outside git as prunable', async () => {
+    const repo = createTempDir();
+    runGit(repo, ['init', '-b', 'main']);
+    runGit(repo, ['config', 'user.email', 'test@example.com']);
+    runGit(repo, ['config', 'user.name', 'Test User']);
+    runGit(repo, ['commit', '--allow-empty', '-m', 'init']);
+    const worktreePath = path.join(createTempDir(), 'feature');
+    runGit(repo, ['worktree', 'add', worktreePath, '-b', 'feature']);
+
+    const before = await getWorktrees(repo);
+    expect(before.find((entry) => entry.branch === 'feature')).toMatchObject({ prunable: false });
+
+    fs.rmSync(worktreePath, { recursive: true, force: true });
+
+    const after = await getWorktrees(repo);
+    expect(after.find((entry) => entry.branch === 'feature')).toMatchObject({ path: expect.any(String), prunable: true });
+    expect(after.find((entry) => entry.branch === 'main')).toMatchObject({ prunable: false });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -622,7 +812,7 @@ describe('createWorktree', () => {
       const created = await createWorktree(repo, {
         mode: 'new',
         worktreeName: 'hook-test',
-        branchName: 'openchamber/hook-test',
+        branchName: 'aiworker/hook-test',
         returnAfterDirectoryCreated: true,
       });
 
@@ -674,7 +864,7 @@ describe('createWorktree', () => {
       const created = await createWorktree(repo, {
         mode: 'new',
         worktreeName: 'hook-skip-test',
-        branchName: 'openchamber/hook-skip-test',
+        branchName: 'aiworker/hook-skip-test',
         returnAfterDirectoryCreated: true,
       });
 
@@ -717,7 +907,7 @@ describe('createWorktree', () => {
       const created = await createWorktree(repo, {
         mode: 'new',
         worktreeName: 'hook-fail-test',
-        branchName: 'openchamber/hook-fail-test',
+        branchName: 'aiworker/hook-fail-test',
         returnAfterDirectoryCreated: true,
       });
 
@@ -854,6 +1044,135 @@ describe('createWorktree', () => {
       }
     }
   });
+
+  it('does not auto-track the remote start ref when creating a new branch from it', async () => {
+    if (!canRunGit()) return;
+
+    const previousXdgDataHome = process.env.XDG_DATA_HOME;
+    const dataHome = createTempDir();
+    process.env.XDG_DATA_HOME = dataHome;
+
+    try {
+      const { repository } = createRepositoryWithRemote({ defaultBranch: 'main' });
+
+      const created = await createWorktree(repository, {
+        mode: 'new',
+        branchName: 'aiworker/feature',
+        worktreeName: 'feature-wt',
+        startRef: 'remotes/origin/main',
+        setUpstream: true,
+        upstreamRemote: 'origin',
+        upstreamBranch: 'aiworker/feature',
+      });
+
+      expect(created.branch).toBe('aiworker/feature');
+
+      await expect.poll(
+        () => getWorktreeBootstrapStatus(created.path).then((status) => status.status === 'ready' || status.status === 'failed'),
+        { timeout: 5_000 }
+      ).toBe(true);
+
+      expect(readBranchConfig(created.path, 'aiworker/feature', 'remote')).toBe('');
+      expect(readBranchConfig(created.path, 'aiworker/feature', 'merge')).toBe('');
+    } finally {
+      if (previousXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+      } else {
+        process.env.XDG_DATA_HOME = previousXdgDataHome;
+      }
+    }
+  }, 30_000);
+
+  it('falls back to the remote start ref for upstream tracking when no explicit keys are given', async () => {
+    if (!canRunGit()) return;
+
+    const previousXdgDataHome = process.env.XDG_DATA_HOME;
+    const dataHome = createTempDir();
+    process.env.XDG_DATA_HOME = dataHome;
+
+    try {
+      const { repository } = createRepositoryWithRemote({ defaultBranch: 'main' });
+
+      const created = await createWorktree(repository, {
+        mode: 'new',
+        branchName: 'aiworker/fallback-wt',
+        worktreeName: 'fallback-wt',
+        startRef: 'remotes/origin/main',
+        setUpstream: true,
+      });
+
+      await expect.poll(
+        () => readBranchConfig(created.path, 'aiworker/fallback-wt', 'merge'),
+        { timeout: 5_000 }
+      ).toBe('refs/heads/main');
+      expect(readBranchConfig(created.path, 'aiworker/fallback-wt', 'remote')).toBe('origin');
+    } finally {
+      if (previousXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+      } else {
+        process.env.XDG_DATA_HOME = previousXdgDataHome;
+      }
+    }
+  }, 30_000);
+
+  it('falls back to the tracked local branch when the source fetch fails', async () => {
+    if (!canRunGit()) return;
+
+    const previousXdgDataHome = process.env.XDG_DATA_HOME;
+    const dataHome = createTempDir();
+    process.env.XDG_DATA_HOME = dataHome;
+
+    try {
+      const { repository } = createRepositoryWithRemote({ defaultBranch: 'main' });
+      runGit(repository, ['branch', '--set-upstream-to=origin/main', 'next']);
+      runGit(repository, ['remote', 'set-url', 'origin', '/nonexistent/openchamber-unreachable.git']);
+
+      const created = await createWorktree(repository, {
+        mode: 'new',
+        branchName: 'aiworker/stale-ref-wt',
+        worktreeName: 'stale-ref-wt',
+        startRef: 'remotes/origin/main',
+      });
+
+      expect(created.branch).toBe('aiworker/stale-ref-wt');
+      expect(created.sourceFetchFailed).toBe(true);
+      const expectedHead = runGit(repository, ['rev-parse', 'next']).trim();
+      expect(runGit(created.path, ['rev-parse', 'HEAD']).trim()).toBe(expectedHead);
+    } finally {
+      if (previousXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+      } else {
+        process.env.XDG_DATA_HOME = previousXdgDataHome;
+      }
+    }
+  }, 30_000);
+
+  it('rejects creation from a remote start ref that was never fetched and cannot be fetched', async () => {
+    if (!canRunGit()) return;
+
+    const previousXdgDataHome = process.env.XDG_DATA_HOME;
+    const dataHome = createTempDir();
+    process.env.XDG_DATA_HOME = dataHome;
+
+    try {
+      const { repository } = createRepositoryWithRemote({ defaultBranch: 'main' });
+      runGit(repository, ['update-ref', '-d', 'refs/remotes/origin/main']);
+      runGit(repository, ['remote', 'set-url', 'origin', '/nonexistent/openchamber-unreachable.git']);
+
+      await expect(createWorktree(repository, {
+        mode: 'new',
+        branchName: 'aiworker/never-fetched-wt',
+        worktreeName: 'never-fetched-wt',
+        startRef: 'remotes/origin/main',
+      })).rejects.toThrow(/does not appear to be a git repository|Could not read from remote repository/i);
+    } finally {
+      if (previousXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+      } else {
+        process.env.XDG_DATA_HOME = previousXdgDataHome;
+      }
+    }
+  }, 30_000);
 });
 
 // ---------------------------------------------------------------------------
@@ -1498,18 +1817,264 @@ describe.runIf(canRunGit())('getBranches', () => {
   });
 });
 
+describe.runIf(canRunGit())('getUnpushedBranchCounts', () => {
+  it('counts only commits ahead of a locally known upstream', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['branch', '--set-upstream-to=origin/react', 'next']);
+    fs.writeFileSync(path.join(repository, 'ahead.txt'), 'ahead\n');
+    runGit(repository, ['add', 'ahead.txt']);
+    runGit(repository, ['commit', '-m', 'ahead']);
+    runGit(repository, ['checkout', '-b', 'no-upstream']);
+
+    await expect(getUnpushedBranchCounts(repository, ['next', 'no-upstream', 'remotes/origin/react'])).resolves.toEqual({
+      counts: { next: 1 },
+    });
+  });
+});
+
+describe.runIf(canRunGit())('commit comparisons', () => {
+  it('shows only the selected commit and gives walkthrough the identical patch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'README.md'), 'selected version\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'selected']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    fs.writeFileSync(path.join(repository, 'README.md'), 'later version\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'later']);
+    fs.writeFileSync(path.join(repository, 'README.md'), 'uncommitted version\n');
+    const patch = await getCommitDiff(repository, { hash, path: 'README.md' });
+    expect(patch).toContain('+selected version');
+    expect(patch).not.toContain('later version');
+    expect(patch).not.toContain('uncommitted version');
+    expect((await getCommitFiles(repository, hash)).files).toEqual([
+      { path: 'README.md', insertions: 1, deletions: 1, isBinary: false, changeType: 'M' },
+    ]);
+    const source = parseSource({ kind: 'commit', hash });
+    expect(sourceKey(source)).toBe(`commit:${hash}`);
+    expect((await loadSourceSections(repository, source)).sections).toEqual([{ scope: 'commit', patch }]);
+    const routes = new Map();
+    registerGitRoutes({
+      get: (url, handler) => routes.set(url, handler), post() {}, put() {}, delete() {},
+    });
+    let response;
+    await routes.get('/api/git/commit-diff')(
+      { query: { directory: repository, hash, path: 'README.md' } },
+      { json: (body) => { response = body; }, status: (code) => { throw new Error(`Unexpected status ${code}`); } },
+    );
+    expect(response).toEqual({ diff: patch });
+  });
+
+  it('handles root and empty commits and rejects invalid hashes', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const root = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect(await getCommitDiff(repository, { hash: root })).toContain('+# Test');
+    expect((await getCommitFiles(repository, root)).files[0].changeType).toBe('A');
+    runGit(repository, ['commit', '--allow-empty', '-m', 'empty']);
+    const empty = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect(await getCommitDiff(repository, { hash: empty })).toBe('');
+    expect(await getCommitFiles(repository, empty)).toEqual({ files: [] });
+    expect(() => parseSource({ kind: 'commit', hash: 'HEAD' })).toThrow();
+    expect(() => parseSource({ kind: 'commit', hash: [root] })).toThrow();
+    await expect(getCommitDiff(repository, { hash: 'HEAD' })).rejects.toThrow();
+    await expect(getCommitFiles(repository, '0'.repeat(40))).rejects.toThrow();
+  });
+
+  it('keeps rename paths and original contents together, including whitespace in names', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const destination = ' new\nname.md';
+    runGit(repository, ['mv', 'README.md', destination]);
+    runGit(repository, ['commit', '-m', 'rename']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    const { files } = await getCommitFiles(repository, hash);
+    expect(files).toEqual([{ path: destination, previousPath: 'README.md', changeType: 'R', insertions: 0, deletions: 0, isBinary: false }]);
+    const patch = await getCommitDiff(repository, { hash, path: destination, previousPath: files[0].previousPath });
+    expect(patch).toContain('rename from README.md');
+    expect(patch).toContain('similarity index 100%');
+  });
+
+  it('compares a merge commit against its first parent', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'side']);
+    fs.writeFileSync(path.join(repository, 'side.txt'), 'side\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'side']);
+    runGit(repository, ['checkout', 'next']);
+    fs.writeFileSync(path.join(repository, 'main.txt'), 'main\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'main']);
+    runGit(repository, ['merge', '--no-ff', 'side', '-m', 'merge']);
+    const hash = runGit(repository, ['rev-parse', 'HEAD']).trim();
+    expect((await getCommitFiles(repository, hash)).files.map((file) => file.path)).toEqual(['side.txt']);
+    const patch = await getCommitDiff(repository, { hash });
+    expect(patch).toContain('+side');
+    expect(patch).not.toContain('main.txt');
+  });
+
+  it('limits current-branch history to 50 commits without including another branch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'other']);
+    runGit(repository, ['commit', '--allow-empty', '-m', 'other branch only']);
+    runGit(repository, ['checkout', 'next']);
+    for (let index = 0; index < 51; index += 1) runGit(repository, ['commit', '--allow-empty', '-m', `current ${index}`]);
+    const history = await getLog(repository, { maxCount: 50, to: 'refs/heads/next' });
+    expect(history.all).toHaveLength(50);
+    expect(history.all[0].message).toBe('current 50');
+    expect(history.all.some((commit) => commit.message === 'other branch only')).toBe(false);
+  });
+});
+
 describe.runIf(canRunGit())('getRangeDiff', () => {
-  it('resolves a base that exists only on a remote other than origin', async () => {
+  it('loads a committed deletion that no longer exists in HEAD or the working tree', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['rm', 'README.md']);
+    runGit(repository, ['commit', '-m', 'delete file']);
+    const diff = await getRangeDiff(repository, { base: 'origin/react', head: 'next', path: 'README.md', includeWorkingTree: true });
+    expect(diff).toContain('deleted file mode');
+    expect(diff).toContain('-# Test');
+  });
+
+  it('carries the working-tree option through the actual HTTP route handlers', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'local.txt'), 'current local work\n');
+    const routes = new Map();
+    registerGitRoutes({
+      get: (url, handler) => routes.set(url, handler),
+      post() {},
+      put() {},
+      delete() {},
+    });
+    const query = { directory: repository, base: 'origin/react', head: 'next', includeWorkingTree: 'true' };
+    for (const endpoint of ['range-diff', 'range-files']) {
+      let status = 200;
+      let body;
+      const response = {
+        status(value) { status = value; return this; },
+        json(value) { body = value; },
+      };
+      await routes.get(`/api/git/${endpoint}`)({ query }, response);
+      expect(status).toBe(200);
+      if (endpoint === 'range-diff') expect(body.diff).toContain('+current local work');
+      else expect(body.files).toEqual([{ path: 'local.txt', status: 'A' }]);
+    }
+  });
+
+  it('asks for a new base after restacking and compares against the selected parent', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['checkout', '-b', 'child', 'origin/react']);
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'child\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'child']);
+    expect(await getBranchBase(repository, 'child')).toEqual({ base: 'origin/react' });
+    runGit(repository, ['checkout', '-b', 'parent', 'origin/react']);
+    fs.writeFileSync(path.join(repository, 'parent.txt'), 'parent\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'parent']);
+    runGit(repository, ['checkout', 'child']);
+    runGit(repository, ['rebase', 'parent']);
+    expect(await getBranchBase(repository, 'child')).toEqual({ base: null });
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'current child\n');
+    const options = { base: 'refs/heads/parent', head: 'child', includeWorkingTree: true };
+    expect(await getRangeFiles(repository, options)).toEqual([{ path: 'child.txt', status: 'A' }]);
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('+current child');
+    expect(diff).not.toContain('parent.txt');
+  });
+
+  it('combines committed, staged, unstaged and untracked work without changing the real index', async () => {
+    const { repository } = createRepositoryWithRemote();
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Committed\n');
+    runGit(repository, ['add', 'README.md']);
+    runGit(repository, ['commit', '-m', 'branch change']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Staged\n');
+    fs.writeFileSync(path.join(repository, 'staged.txt'), 'staged only\n');
+    runGit(repository, ['add', '.']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Current\n');
+    fs.writeFileSync(path.join(repository, 'untracked.txt'), 'new local file\n');
+    fs.writeFileSync(path.join(repository, ' leading space.txt'), 'space path\n');
+    const indexBefore = fs.readFileSync(path.join(repository, '.git/index'));
+    const options = { base: 'origin/react', head: 'next', includeWorkingTree: true };
+
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('-# Test');
+    expect(diff).toContain('+# Current');
+    expect(diff).not.toContain('+# Staged');
+    expect(diff).not.toContain('+# Committed');
+    expect(diff).toContain('+new local file');
+    expect(diff).toContain('+staged only');
+    expect(await getRangeFiles(repository, options)).toEqual(expect.arrayContaining([
+      { path: 'README.md', status: 'M' },
+      { path: 'staged.txt', status: 'A' },
+      { path: 'untracked.txt', status: 'A' },
+      { path: ' leading space.txt', status: 'A' },
+    ]));
+    const { sections } = await loadSourceSections(repository, { kind: 'branch', baseRef: options.base, headRef: options.head });
+    expect(sections).toEqual([{ scope: 'branch', patch: diff }]);
+    expect(fs.readFileSync(path.join(repository, '.git/index'))).toEqual(indexBefore);
+
+    const committed = await getRangeDiff(repository, { base: options.base, head: options.head });
+    expect(committed).toContain('+# Committed');
+    expect(committed).not.toContain('+new local file');
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Latest\n');
+    expect(await getRangeDiff(repository, { ...options, path: 'README.md' })).toContain('+# Latest');
+  });
+
+  it('reports the final file after a staged deletion is recreated, and omits undone branch changes', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['rm', 'README.md']);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Recreated\n');
+    const options = { base: 'origin/react', head: 'next', includeWorkingTree: true };
+    expect(await getRangeFiles(repository, options)).toEqual([{ path: 'README.md', status: 'M' }]);
+    const diff = await getRangeDiff(repository, options);
+    expect(diff).toContain('-# Test');
+    expect(diff).toContain('+# Recreated');
+    expect(diff.match(/diff --git/g)).toHaveLength(1);
+    fs.writeFileSync(path.join(repository, 'README.md'), '# Test\n');
+    expect(await getRangeFiles(repository, options)).toEqual([]);
+    expect(await getRangeDiff(repository, options)).toBe('');
+  });
+
+  it('keeps local and remote bases distinct and rejects a different checked-out branch', async () => {
+    const { repository } = createRepositoryWithRemote();
+    runGit(repository, ['branch', 'react']);
+    fs.writeFileSync(path.join(repository, 'parent.txt'), 'parent work\n');
+    runGit(repository, ['add', '.']);
+    runGit(repository, ['commit', '-m', 'parent work']);
+    runGit(repository, ['branch', '-f', 'react', 'HEAD']);
+    fs.writeFileSync(path.join(repository, 'child.txt'), 'child work\n');
+    const options = { head: 'next', includeWorkingTree: true };
+    const local = await getRangeDiff(repository, { ...options, base: 'react' });
+    const remote = await getRangeDiff(repository, { ...options, base: 'origin/react' });
+    expect(local).not.toContain('parent.txt');
+    expect(remote).toContain('parent.txt');
+    expect(local).toContain('child.txt');
+    expect(await getRangeFiles(repository, { ...options, base: 'react' })).toEqual([{ path: 'child.txt', status: 'A' }]);
+    runGit(repository, ['checkout', 'react']);
+    await expect(getRangeDiff(repository, { ...options, base: 'origin/react' })).rejects.toThrow(/checked-out branch/);
+  });
+
+  it('includes untracked symlinks as links without reading their targets', async () => {
+    const { repository } = createRepositoryWithRemote();
+    const outside = path.join(createTempDir(), 'outside.txt');
+    fs.writeFileSync(outside, 'must not be in a diff\n');
+    fs.symlinkSync(outside, path.join(repository, 'link.txt'));
+    const diff = await getRangeDiff(repository, { base: 'origin/react', head: 'next', includeWorkingTree: true });
+    expect(diff).toContain('new file mode 120000');
+    expect(diff).toContain(outside);
+    expect(diff).not.toContain('must not be in a diff');
+  });
+
+  it('uses an explicitly selected base on a remote other than origin', async () => {
     const { repository } = createRepositoryWithRemote({ remoteName: 'upstream', defaultBranch: 'react' });
-    // Only refs/remotes/upstream/react carries the base — git cannot resolve the
-    // bare name, so an unqualified `react...next` fails with "ambiguous argument".
+    // The selected remote ref must work without a local branch of that name.
     fs.writeFileSync(path.join(repository, 'feature.txt'), 'work\n');
     runGit(repository, ['add', 'feature.txt']);
     runGit(repository, ['commit', '-m', 'feature']);
 
-    const diff = await getRangeDiff(repository, { base: 'react', head: 'next' });
+    const diff = await getRangeDiff(repository, { base: 'upstream/react', head: 'next' });
 
     expect(diff).toContain('feature.txt');
+    await expect(getRangeDiff(repository, { base: 'react', head: 'next' })).rejects.toThrow(/is not available locally/);
   });
 
   it('names an unfetched remote-only ref instead of failing with git\'s ambiguous argument (#2735)', async () => {
@@ -1522,6 +2087,9 @@ describe.runIf(canRunGit())('getRangeDiff', () => {
 });
 
 describe('parseBranchCreationSource', () => {
+  it('does not reuse the creation base after a rebase', () => {
+    expect(parseBranchCreationSource('rebase (finish): refs/heads/feature onto abc123\nbranch: Created from main')).toBeNull();
+  });
   it('returns the source ref from the oldest creation entry', () => {
     // Reflog lists newest entries first; creation is the last line.
     const reflog = [
@@ -1568,7 +2136,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', 'added.txt', 'README.md']);
     runGit(repository, ['commit', '-m', 'changes']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     expect(files).toEqual(expect.arrayContaining([
       { path: 'added.txt', status: 'A' },
@@ -1590,7 +2158,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', '-A']);
     runGit(repository, ['commit', '-m', 'rename']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     const renameEntry = files.find((file) => file.status === 'R');
     expect(renameEntry).toBeDefined();
@@ -1612,7 +2180,7 @@ describe.runIf(canRunGit())('getRangeFiles', () => {
     runGit(repository, ['add', '-A']);
     runGit(repository, ['commit', '-m', 'copy']);
 
-    const files = await getRangeFiles(repository, { base: 'react', head: 'next' });
+    const files = await getRangeFiles(repository, { base: 'origin/react', head: 'next' });
 
     const copyEntry = files.find((file) => file.status === 'C');
     expect(copyEntry).toBeDefined();