npm - difit - Versions diffs - 4.0.2 → 4.0.4 - Mend

difit 4.0.2 → 4.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (201) hide show

package/dist/client/index.html CHANGED Viewed

@@ -7,8 +7,10 @@
     <link rel="icon" href="/favicon-white.svg" media="(prefers-color-scheme: dark)" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>difit - Git Diff Viewer</title>
-    <script type="module" crossorigin src="/assets/index-CizZxdOT.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Cn4K2uvR.css">
+    <script type="module" crossorigin src="/assets/index-RcU838Ah.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/chunk-CFjPhJqf.js">
+    <link rel="modulepreload" crossorigin href="/assets/preload-helper-DSXbuxSR.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-Cq_APK7Y.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/git-diff-tui.d.ts CHANGED Viewed

@@ -1,2 +1,2 @@
-import type { FileDiff } from '../types/diff.js';
-export declare function loadGitDiff(targetCommitish: string, baseCommitish: string, repoPath?: string, contextLines?: number): Promise<FileDiff[]>;
+import type { DiffSelection, FileDiff } from '../types/diff.js';
+export declare function loadGitDiff(selection: DiffSelection, repoPath?: string, contextLines?: number): Promise<FileDiff[]>;

package/dist/server/git-diff-tui.js CHANGED Viewed

@@ -1,12 +1,17 @@
 import simpleGit from 'simple-git';
-import { validateDiffArguments, createCommitRangeString } from '../cli/utils.js';
-export async function loadGitDiff(targetCommitish, baseCommitish, repoPath, contextLines) {
+import { validateDiffArguments } from '../cli/utils.js';
+import { getMergeBaseTargetRef, normalizeBaseMode } from '../utils/diffSelection.js';
+export async function loadGitDiff(selection, repoPath, contextLines) {
+    const { targetCommitish, baseCommitish } = selection;
     // Validate arguments
     const validation = validateDiffArguments(targetCommitish, baseCommitish);
     if (!validation.valid) {
         throw new Error(validation.error);
     }
     const git = simpleGit(repoPath);
+    const effectiveBaseCommitish = normalizeBaseMode(selection.baseMode) === 'merge-base'
+        ? (await git.raw(['merge-base', getMergeBaseTargetRef(targetCommitish), baseCommitish])).trim()
+        : baseCommitish;
     let diff;
     // Handle target special chars (base is always a regular commit)
     if (targetCommitish === 'working') {
@@ -15,18 +20,15 @@ export async function loadGitDiff(targetCommitish, baseCommitish, repoPath, cont
     }
     else if (targetCommitish === 'staged') {
         // Show staged changes against base commit
-        diff = await git.diff(['--cached', baseCommitish, '--name-status']);
+        diff = await git.diff(['--cached', effectiveBaseCommitish, '--name-status']);
     }
     else if (targetCommitish === '.') {
         // Show all uncommitted changes against base commit
-        diff = await git.diff([baseCommitish, '--name-status']);
+        diff = await git.diff([effectiveBaseCommitish, '--name-status']);
     }
     else {
         // Both are regular commits: standard commit-to-commit comparison
-        diff = await git.diff([
-            createCommitRangeString(baseCommitish, targetCommitish),
-            '--name-status',
-        ]);
+        diff = await git.diff([effectiveBaseCommitish, targetCommitish, '--name-status']);
         if (!diff.trim()) {
             // Try without parent (for initial commit)
             const diffInitial = await git.diff([targetCommitish, '--name-status']);
@@ -55,17 +57,18 @@ export async function loadGitDiff(targetCommitish, baseCommitish, repoPath, cont
         }
         else if (targetCommitish === 'staged') {
             // Show staged changes against base commit
-            fileDiff = await git.diff(['--cached', baseCommitish, ...contextArgs, '--', path]);
+            fileDiff = await git.diff(['--cached', effectiveBaseCommitish, ...contextArgs, '--', path]);
         }
         else if (targetCommitish === '.') {
             // Show all uncommitted changes against base commit
-            fileDiff = await git.diff([baseCommitish, ...contextArgs, '--', path]);
+            fileDiff = await git.diff([effectiveBaseCommitish, ...contextArgs, '--', path]);
         }
         else {
             try {
                 // Both are regular commits: standard commit-to-commit comparison
                 fileDiff = await git.diff([
-                    createCommitRangeString(baseCommitish, targetCommitish),
+                    effectiveBaseCommitish,
+                    targetCommitish,
                     ...contextArgs,
                     '--',
                     path,

package/dist/server/git-diff-tui.test.js CHANGED Viewed

@@ -1,13 +1,15 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { loadGitDiff } from './git-diff-tui.js';
 const mockDiff = vi.hoisted(() => vi.fn());
-const mockSimpleGit = vi.hoisted(() => vi.fn(() => ({ diff: mockDiff })));
+const mockRaw = vi.hoisted(() => vi.fn());
+const mockSimpleGit = vi.hoisted(() => vi.fn(() => ({ diff: mockDiff, raw: mockRaw })));
 vi.mock('simple-git', () => ({
     default: mockSimpleGit,
 }));
 describe('loadGitDiff', () => {
     beforeEach(() => {
         mockDiff.mockReset();
+        mockRaw.mockReset();
         mockSimpleGit.mockClear();
     });
     it.each([
@@ -36,14 +38,14 @@ describe('loadGitDiff', () => {
             name: 'commit comparisons',
             targetCommitish: 'HEAD',
             baseCommitish: 'HEAD^',
-            expectedListArgs: ['HEAD^...HEAD', '--name-status'],
-            expectedFileArgs: ['HEAD^...HEAD', '-U5', '--', 'src/file.ts'],
+            expectedListArgs: ['HEAD^', 'HEAD', '--name-status'],
+            expectedFileArgs: ['HEAD^', 'HEAD', '-U5', '--', 'src/file.ts'],
         },
     ])('passes context lines for $name', async ({ targetCommitish, baseCommitish, expectedListArgs, expectedFileArgs }) => {
         mockDiff
             .mockResolvedValueOnce('M\tsrc/file.ts')
             .mockResolvedValueOnce('@@ -1 +1 @@\n-old line\n+new line\n');
-        const result = await loadGitDiff(targetCommitish, baseCommitish, '/repo', 5);
+        const result = await loadGitDiff({ targetCommitish, baseCommitish }, '/repo', 5);
         expect(mockSimpleGit).toHaveBeenCalledWith('/repo');
         expect(mockDiff).toHaveBeenNthCalledWith(1, expectedListArgs);
         expect(mockDiff).toHaveBeenNthCalledWith(2, expectedFileArgs);
@@ -57,4 +59,18 @@ describe('loadGitDiff', () => {
             },
         ]);
     });
+    it('uses merge-base for merge-base selections', async () => {
+        mockRaw.mockResolvedValue('mergebase123\n');
+        mockDiff
+            .mockResolvedValueOnce('M\tsrc/file.ts')
+            .mockResolvedValueOnce('@@ -1 +1 @@\n-old line\n+new line\n');
+        await loadGitDiff({
+            targetCommitish: '.',
+            baseCommitish: 'origin/main',
+            baseMode: 'merge-base',
+        }, '/repo', 5);
+        expect(mockRaw).toHaveBeenCalledWith(['merge-base', 'HEAD', 'origin/main']);
+        expect(mockDiff).toHaveBeenNthCalledWith(1, ['mergebase123', '--name-status']);
+        expect(mockDiff).toHaveBeenNthCalledWith(2, ['mergebase123', '-U5', '--', 'src/file.ts']);
+    });
 });

package/dist/server/git-diff.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { type DiffResponse } from '../types/diff.js';
+import { type DiffResponse, type DiffSelection } from '../types/diff.js';
 export declare class GitDiffParser {
     private git;
     private repoPath;
@@ -7,7 +7,8 @@ export declare class GitDiffParser {
     private static readonly GENERATED_HEADER_SCAN_BYTES;
     constructor(repoPath?: string);
     private normalizeRepositoryRelativePath;
-    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean, contextLines?: number): Promise<DiffResponse>;
+    private resolveBaseCommitish;
+    parseDiff(selection: DiffSelection, ignoreWhitespace?: boolean, contextLines?: number): Promise<DiffResponse>;
     private parseUnifiedDiff;
     private decodeGitPath;
     private extractPathFromLine;

package/dist/server/git-diff.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import { simpleGit } from 'simple-git';
 import { isAbsolute, resolve, sep } from 'path';
 import { validateDiffArguments, shortHash, createCommitRangeString } from '../cli/utils.js';
+import { getMergeBaseTargetRef, normalizeBaseMode } from '../utils/diffSelection.js';
 import { isGeneratedFile } from './generated-file-check.js';
 export class GitDiffParser {
     git;
@@ -28,15 +29,28 @@ export class GitDiffParser {
         }
         return normalizedFilepath;
     }
-    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false, contextLines) {
+    async resolveBaseCommitish(selection) {
+        if (normalizeBaseMode(selection.baseMode) !== 'merge-base') {
+            return selection.baseCommitish;
+        }
+        const targetRef = getMergeBaseTargetRef(selection.targetCommitish);
+        const mergeBase = await this.git.raw(['merge-base', targetRef, selection.baseCommitish]);
+        return mergeBase.trim();
+    }
+    async parseDiff(selection, ignoreWhitespace = false, contextLines) {
+        const { targetCommitish, baseCommitish } = selection;
+        const requestedBaseMode = normalizeBaseMode(selection.baseMode) === 'merge-base' ? 'merge-base' : undefined;
         try {
             // Validate arguments
             const validation = validateDiffArguments(targetCommitish, baseCommitish);
             if (!validation.valid) {
                 throw new Error(validation.error);
             }
+            const effectiveBaseCommitish = await this.resolveBaseCommitish(selection);
             let resolvedCommit;
             let diffArgs;
+            let resolvedBaseCommitish = effectiveBaseCommitish;
+            let resolvedTargetCommitish = targetCommitish;
             // Handle target special chars (base is always a regular commit)
             if (targetCommitish === 'working') {
                 // Show unstaged changes (working vs staged)
@@ -45,22 +59,26 @@ export class GitDiffParser {
             }
             else if (targetCommitish === 'staged') {
                 // Show staged changes against base commit
-                const baseHash = await this.git.revparse([baseCommitish]);
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
                 resolvedCommit = `${shortHash(baseHash)} vs Staging Area (staged changes)`;
-                diffArgs = ['--cached', baseCommitish];
+                resolvedBaseCommitish = shortHash(baseHash);
+                diffArgs = ['--cached', effectiveBaseCommitish];
             }
             else if (targetCommitish === '.') {
                 // Show all uncommitted changes against base commit
-                const baseHash = await this.git.revparse([baseCommitish]);
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
                 resolvedCommit = `${shortHash(baseHash)} vs Working Directory (all uncommitted changes)`;
-                diffArgs = [baseCommitish];
+                resolvedBaseCommitish = shortHash(baseHash);
+                diffArgs = [effectiveBaseCommitish];
             }
             else {
                 // Both are regular commits: standard commit-to-commit comparison
                 const targetHash = await this.git.revparse([targetCommitish]);
-                const baseHash = await this.git.revparse([baseCommitish]);
+                const baseHash = await this.git.revparse([effectiveBaseCommitish]);
                 resolvedCommit = createCommitRangeString(shortHash(baseHash), shortHash(targetHash));
-                diffArgs = [resolvedCommit];
+                resolvedBaseCommitish = shortHash(baseHash);
+                resolvedTargetCommitish = shortHash(targetHash);
+                diffArgs = [baseHash, targetHash];
             }
             if (ignoreWhitespace) {
                 diffArgs.push('-w');
@@ -78,6 +96,11 @@ export class GitDiffParser {
                 commit: resolvedCommit,
                 files,
                 isEmpty: files.length === 0,
+                baseCommitish: resolvedBaseCommitish,
+                targetCommitish: resolvedTargetCommitish,
+                requestedBaseCommitish: baseCommitish,
+                requestedTargetCommitish: targetCommitish,
+                requestedBaseMode,
             };
         }
         catch (error) {

package/dist/server/git-diff.test.js CHANGED Viewed

@@ -5,6 +5,7 @@ vi.mock('simple-git', () => ({
     simpleGit: vi.fn(() => ({
         revparse: vi.fn(),
         diff: vi.fn(),
+        raw: vi.fn(),
     })),
 }));
 // Mock child_process
@@ -967,7 +968,10 @@ index abc123..def456 100644
             parser.git.revparse.mockResolvedValue('abc1234567890abcdef1234567890abcdef12');
             const getBlobContentSpy = vi.spyOn(parser, 'getBlobContent');
             getBlobContentSpy.mockResolvedValue(Buffer.from('// @generated\nconst x = 1;'));
-            const response = await parser.parseDiff('HEAD', 'HEAD~1');
+            const response = await parser.parseDiff({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD~1',
+            });
             expect(response.files[0].path).toBe(file);
             expect(response.files[0].isGenerated).toBe(false);
             expect(getBlobContentSpy).not.toHaveBeenCalled();
@@ -1078,9 +1082,13 @@ index abc123..def456 100644
                 .mockResolvedValueOnce('1234567890abcdef1234567890abcdef12345678')
                 .mockResolvedValueOnce('abcdef1234567890abcdef1234567890abcdef12');
             gitDiff.mockResolvedValue('');
-            const response = await parser.parseDiff('HEAD', 'HEAD~1', false, 5);
+            const response = await parser.parseDiff({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD~1',
+            }, false, 5);
             expect(gitDiff).toHaveBeenCalledWith([
-                'abcdef1...1234567',
+                'abcdef1234567890abcdef1234567890abcdef12',
+                '1234567890abcdef1234567890abcdef12345678',
                 '-U5',
                 '--no-ext-diff',
                 '--color=never',
@@ -1089,6 +1097,11 @@ index abc123..def456 100644
                 commit: 'abcdef1...1234567',
                 files: [],
                 isEmpty: true,
+                baseCommitish: 'abcdef1',
+                targetCommitish: '1234567',
+                requestedBaseCommitish: 'HEAD~1',
+                requestedTargetCommitish: 'HEAD',
+                requestedBaseMode: undefined,
             });
         });
         it('accepts branch refs with revision suffixes', async () => {
@@ -1098,14 +1111,56 @@ index abc123..def456 100644
                 .mockResolvedValueOnce('1234567890abcdef1234567890abcdef12345678')
                 .mockResolvedValueOnce('abcdef1234567890abcdef1234567890abcdef12');
             gitDiff.mockResolvedValue('');
-            const response = await parser.parseDiff('codex/comment-thread', 'codex/comment-thread^');
+            const response = await parser.parseDiff({
+                targetCommitish: 'codex/comment-thread',
+                baseCommitish: 'codex/comment-thread^',
+            });
             expect(gitRevparse).toHaveBeenNthCalledWith(1, ['codex/comment-thread']);
             expect(gitRevparse).toHaveBeenNthCalledWith(2, ['codex/comment-thread^']);
-            expect(gitDiff).toHaveBeenCalledWith(['abcdef1...1234567', '--no-ext-diff', '--color=never']);
+            expect(gitDiff).toHaveBeenCalledWith([
+                'abcdef1234567890abcdef1234567890abcdef12',
+                '1234567890abcdef1234567890abcdef12345678',
+                '--no-ext-diff',
+                '--color=never',
+            ]);
             expect(response).toEqual({
                 commit: 'abcdef1...1234567',
                 files: [],
                 isEmpty: true,
+                baseCommitish: 'abcdef1',
+                targetCommitish: '1234567',
+                requestedBaseCommitish: 'codex/comment-thread^',
+                requestedTargetCommitish: 'codex/comment-thread',
+                requestedBaseMode: undefined,
+            });
+        });
+        it('uses merge-base when baseMode is merge-base', async () => {
+            const gitDiff = parser.git.diff;
+            const gitRevparse = parser.git.revparse;
+            const gitRaw = parser.git.raw;
+            gitRaw.mockResolvedValue('fedcba9876543210fedcba9876543210fedcba98\n');
+            gitRevparse.mockResolvedValueOnce('fedcba9876543210fedcba9876543210fedcba98');
+            gitDiff.mockResolvedValue('');
+            const response = await parser.parseDiff({
+                targetCommitish: '.',
+                baseCommitish: 'origin/main',
+                baseMode: 'merge-base',
+            });
+            expect(gitRaw).toHaveBeenCalledWith(['merge-base', 'HEAD', 'origin/main']);
+            expect(gitDiff).toHaveBeenCalledWith([
+                'fedcba9876543210fedcba9876543210fedcba98',
+                '--no-ext-diff',
+                '--color=never',
+            ]);
+            expect(response).toEqual({
+                commit: 'fedcba9 vs Working Directory (all uncommitted changes)',
+                files: [],
+                isEmpty: true,
+                baseCommitish: 'fedcba9',
+                targetCommitish: '.',
+                requestedBaseCommitish: 'origin/main',
+                requestedTargetCommitish: '.',
+                requestedBaseMode: 'merge-base',
             });
         });
     });

package/dist/server/server.d.ts CHANGED Viewed

@@ -1,9 +1,8 @@
 import { type Server } from 'http';
 import { type DiffMode } from '../types/watch.js';
-import { type CommentImport } from '@/types/diff.js';
+import { type CommentImport, type DiffSelection } from '@/types/diff.js';
 interface ServerOptions {
-    targetCommitish?: string;
-    baseCommitish?: string;
+    selection?: DiffSelection;
     stdinDiff?: string;
     preferredPort?: number;
     host?: string;

package/dist/server/server.js CHANGED Viewed

@@ -13,23 +13,56 @@ import { resolveEditorOption } from '../utils/editorOptions.js';
 import { getFileExtension } from '../utils/fileUtils.js';
 import { FileWatcherService } from './file-watcher.js';
 import { GitDiffParser } from './git-diff.js';
+import { createDiffSelection, diffSelectionsEqual, getDiffSelectionKey, } from '../utils/diffSelection.js';
 const GENERATED_STATUS_CACHE_TTL_MS = 60_000;
+const MAX_DIFF_CACHE_ENTRIES = 8;
+function createDiffCacheKey(selection, ignoreWhitespace) {
+    return `${getDiffSelectionKey(selection)}\u0000${ignoreWhitespace ? '1' : '0'}`;
+}
+function getCachedDiffResponse(cache, key) {
+    const cached = cache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    // Refresh insertion order to keep the most recently used entry.
+    cache.delete(key);
+    cache.set(key, cached);
+    return cached;
+}
+function setCachedDiffResponse(cache, key, value) {
+    if (cache.has(key)) {
+        cache.delete(key);
+    }
+    cache.set(key, value);
+    while (cache.size > MAX_DIFF_CACHE_ENTRIES) {
+        const oldestKey = cache.keys().next().value;
+        if (typeof oldestKey !== 'string') {
+            break;
+        }
+        cache.delete(oldestKey);
+    }
+}
 export async function startServer(options) {
     const app = express();
     const repositoryPath = resolve(options.repoPath ?? process.cwd());
     const repositoryId = createHash('sha256').update(repositoryPath).digest('hex');
     const initialCommentImports = options.commentImports || [];
-    const initialBaseCommitish = options.baseCommitish ?? '';
-    const initialTargetCommitish = options.targetCommitish ?? '';
+    const initialSelection = options.selection ?? createDiffSelection('', '');
     const commentImportId = initialCommentImports.length > 0
         ? createHash('sha256').update(serializeCommentImports(initialCommentImports)).digest('hex')
         : undefined;
     const parser = new GitDiffParser(repositoryPath);
     const fileWatcher = new FileWatcherService();
     const generatedStatusCache = new Map();
-    let diffDataCache = null;
-    let currentIgnoreWhitespace = options.ignoreWhitespace || false;
+    const diffDataCache = new Map();
+    const initialIgnoreWhitespace = options.ignoreWhitespace || false;
     const diffMode = normalizeDiffViewMode(options.mode);
+    const parseBaseMode = (value) => {
+        if (value === 'merge-base') {
+            return 'merge-base';
+        }
+        return undefined;
+    };
     app.use(express.json());
     app.use(express.text()); // For sendBeacon text/plain requests
     app.use((_req, res, next) => {
@@ -40,28 +73,29 @@ export async function startServer(options) {
     });
     // Skip validation if using stdin diff
     if (!options.stdinDiff) {
-        const isValidCommit = await parser.validateCommit(options.targetCommitish ?? '');
+        const isValidCommit = await parser.validateCommit(initialSelection.targetCommitish);
         if (!isValidCommit) {
-            throw new Error(`Invalid or non-existent commit: ${options.targetCommitish}`);
+            throw new Error(`Invalid or non-existent commit: ${initialSelection.targetCommitish}`);
         }
     }
     // Generate initial diff data for isEmpty check
+    let initialDiffData;
     if (options.stdinDiff) {
         // Parse stdin diff directly
-        diffDataCache = parser.parseStdinDiff(options.stdinDiff);
+        initialDiffData = parser.parseStdinDiff(options.stdinDiff);
     }
     else {
-        diffDataCache = await parser.parseDiff(options.targetCommitish ?? '', options.baseCommitish ?? '', currentIgnoreWhitespace, options.contextLines);
+        initialDiffData = await parser.parseDiff(initialSelection, initialIgnoreWhitespace, options.contextLines);
+        setCachedDiffResponse(diffDataCache, createDiffCacheKey(initialSelection, initialIgnoreWhitespace), initialDiffData);
     }
     // Function to invalidate cache when file changes are detected
     const invalidateCache = () => {
-        diffDataCache = null;
+        diffDataCache.clear();
         generatedStatusCache.clear();
         parser.clearResolvedCommitCache();
     };
     // Track current revisions for cache invalidation
-    let currentBaseCommitish = options.baseCommitish ?? '';
-    let currentTargetCommitish = options.targetCommitish ?? '';
+    let currentSelection = initialSelection;
     function parseRepositoryRelativePath(filepath) {
         if (typeof filepath !== 'string' || filepath.length === 0) {
             return { ok: false, error: 'Invalid file path' };
@@ -79,56 +113,47 @@ export async function startServer(options) {
     }
     app.get('/api/diff', async (req, res) => {
         const ignoreWhitespace = req.query.ignoreWhitespace === 'true';
-        const requestedBase = req.query.base || options.baseCommitish || '';
-        const requestedTarget = req.query.target || options.targetCommitish || '';
+        const hasBase = typeof req.query.base === 'string';
+        const hasTarget = typeof req.query.target === 'string';
+        const hasBaseMode = typeof req.query.baseMode === 'string';
+        const requestedSelection = createDiffSelection(hasBase ? req.query.base : currentSelection.baseCommitish, hasTarget ? req.query.target : currentSelection.targetCommitish, hasBaseMode
+            ? parseBaseMode(req.query.baseMode)
+            : hasBase || hasTarget
+                ? undefined
+                : currentSelection.baseMode);
         const shouldIncludeCommentImports = initialCommentImports.length > 0 &&
-            (Boolean(options.stdinDiff) ||
-                (requestedBase === initialBaseCommitish && requestedTarget === initialTargetCommitish));
-        // Check if revisions or whitespace setting changed
-        const revisionsChanged = requestedBase !== currentBaseCommitish || requestedTarget !== currentTargetCommitish;
-        const whitespaceChanged = ignoreWhitespace !== currentIgnoreWhitespace;
-        // Regenerate diff data if cache is invalid or settings changed
-        if (!diffDataCache || ((revisionsChanged || whitespaceChanged) && !options.stdinDiff)) {
-            currentIgnoreWhitespace = ignoreWhitespace;
-            currentBaseCommitish = requestedBase;
-            currentTargetCommitish = requestedTarget;
-            diffDataCache = await parser.parseDiff(requestedTarget, requestedBase, ignoreWhitespace, options.contextLines);
-            generatedStatusCache.clear();
-        }
-        // Resolve symbolic refs like HEAD/HEAD^ to actual hashes for the UI
-        let resolvedBase = currentBaseCommitish || 'stdin';
-        let resolvedTarget = currentTargetCommitish || 'stdin';
-        if (!options.stdinDiff &&
-            currentBaseCommitish &&
-            !['working', 'staged', '.'].includes(currentBaseCommitish)) {
-            try {
-                resolvedBase = await parser.resolveCommitish(currentBaseCommitish);
-            }
-            catch {
-                // If resolution fails, keep original value
+            (Boolean(options.stdinDiff) || diffSelectionsEqual(requestedSelection, initialSelection));
+        currentSelection = requestedSelection;
+        let responseDiffData = initialDiffData;
+        if (!options.stdinDiff) {
+            const cacheKey = createDiffCacheKey(requestedSelection, ignoreWhitespace);
+            const cached = getCachedDiffResponse(diffDataCache, cacheKey);
+            if (cached) {
+                responseDiffData = cached;
             }
-        }
-        if (!options.stdinDiff &&
-            currentTargetCommitish &&
-            !['working', 'staged', '.'].includes(currentTargetCommitish)) {
-            try {
-                resolvedTarget = await parser.resolveCommitish(currentTargetCommitish);
-            }
-            catch {
-                // If resolution fails, keep original value
+            else {
+                responseDiffData = await parser.parseDiff(requestedSelection, ignoreWhitespace, options.contextLines);
+                setCachedDiffResponse(diffDataCache, cacheKey, responseDiffData);
+                generatedStatusCache.clear();
             }
         }
-        const requestedBaseCommitish = currentBaseCommitish || 'stdin';
-        const requestedTargetCommitish = currentTargetCommitish || 'stdin';
+        const baseCommitish = responseDiffData.baseCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
+        const targetCommitish = responseDiffData.targetCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
+        const requestedBaseCommitish = responseDiffData.requestedBaseCommitish ??
+            (requestedSelection.baseCommitish || (options.stdinDiff ? 'stdin' : undefined));
+        const requestedTargetCommitish = responseDiffData.requestedTargetCommitish ??
+            (requestedSelection.targetCommitish || (options.stdinDiff ? 'stdin' : undefined));
+        const requestedBaseMode = responseDiffData.requestedBaseMode ?? requestedSelection.baseMode;
         res.json({
-            ...diffDataCache,
+            ...responseDiffData,
             ignoreWhitespace,
             mode: diffMode,
             openInEditorAvailable: !options.stdinDiff,
-            baseCommitish: resolvedBase,
-            targetCommitish: resolvedTarget,
+            baseCommitish,
+            targetCommitish,
             requestedBaseCommitish,
             requestedTargetCommitish,
+            requestedBaseMode,
             clearComments: options.clearComments,
             repositoryId,
             commentImports: shouldIncludeCommentImports ? initialCommentImports : undefined,
@@ -147,7 +172,7 @@ export async function startServer(options) {
                 return;
             }
             const normalizedFilepath = filepathResult.path;
-            const ref = req.query.ref || currentTargetCommitish || 'HEAD';
+            const ref = req.query.ref || currentSelection.targetCommitish || 'HEAD';
             const cacheKey = `${ref}:${normalizedFilepath}`;
             const now = Date.now();
             const cached = generatedStatusCache.get(cacheKey);
@@ -179,7 +204,7 @@ export async function startServer(options) {
             return;
         }
         try {
-            const { branches, commits, originDefaultBranch, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentBaseCommitish, currentTargetCommitish);
+            const { branches, commits, originDefaultBranch, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentSelection.baseCommitish, currentSelection.targetCommitish);
             const response = {
                 specialOptions: [
                     { value: '.', label: 'All Uncommitted Changes' },
@@ -528,7 +553,7 @@ export async function startServer(options) {
         }
     }
     // Check if diff is empty and skip browser opening
-    if (diffDataCache?.isEmpty) {
+    if (initialDiffData.isEmpty) {
         // Don't open browser if no differences found
     }
     else if (options.openBrowser) {
@@ -539,7 +564,7 @@ export async function startServer(options) {
             console.warn('Failed to open browser automatically');
         }
     }
-    return { port, url, isEmpty: diffDataCache?.isEmpty || false, server };
+    return { port, url, isEmpty: initialDiffData.isEmpty || false, server };
 }
 async function startServerWithFallback(app, preferredPort, host) {
     return new Promise((resolve, reject) => {