difit 4.0.2 → 4.0.3

package/dist/server/server.js

@@ -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) => {

package/dist/server/server.test.js

@@ -33,6 +33,11 @@ vi.mock('./git-diff.js', () => {
         parseDiff = vi.fn().mockResolvedValue({
             targetCommit: 'abc123',
             baseCommit: 'def456',
+            baseCommitish: 'def4567',
+            targetCommitish: 'abc1234',
+            requestedBaseCommitish: 'HEAD^',
+            requestedTargetCommitish: 'HEAD',
+            requestedBaseMode: undefined,
             targetMessage: 'Test commit',
             baseMessage: 'Previous commit',
             files: [
@@ -192,8 +197,7 @@ describe('Server Integration Tests', () => {
             // Use a high port number to avoid conflicts
             const preferredPort = 9000;
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort,
             });
             servers.push(result.server); // Track for cleanup
@@ -206,15 +210,13 @@ describe('Server Integration Tests', () => {
             const preferredPort = 9010;
             // Start server on port 9010
             const firstServer = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort,
             });
             servers.push(firstServer.server);
             // Try to start another server on the same port
             const secondServer = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort,
             });
             servers.push(secondServer.server);
@@ -224,8 +226,7 @@ describe('Server Integration Tests', () => {
         });
         it('binds to specified host', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 host: '0.0.0.0',
                 preferredPort: 9020,
             });
@@ -234,22 +235,20 @@ describe('Server Integration Tests', () => {
         });
         it('passes context lines to the initial diff load', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9025,
                 contextLines: 4,
             });
             servers.push(result.server);
             const parser = parserInstances.at(-1);
-            expect(parser?.parseDiff).toHaveBeenCalledWith('HEAD', 'HEAD^', false, 4);
+            expect(parser?.parseDiff).toHaveBeenCalledWith({ targetCommitish: 'HEAD', baseCommitish: 'HEAD^' }, false, 4);
         });
     });
     describe('API endpoints', () => {
         let port;
         beforeEach(async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9030,
             });
             servers.push(result.server);
@@ -266,6 +265,8 @@ describe('Server Integration Tests', () => {
             expect(data.files[0]).toHaveProperty('path', 'test.js');
             expect(data).toHaveProperty('ignoreWhitespace', false);
             expect(data).toHaveProperty('openInEditorAvailable', true);
+            expect(data).toHaveProperty('requestedBaseCommitish', 'HEAD^');
+            expect(data).toHaveProperty('requestedTargetCommitish', 'HEAD');
         });
         it('GET /api/diff?ignoreWhitespace=true handles whitespace ignore', async () => {
             const response = await fetch(`http://localhost:${port}/api/diff?ignoreWhitespace=true`);
@@ -275,8 +276,7 @@ describe('Server Integration Tests', () => {
         });
         it('GET /api/diff preserves context lines when recalculating revisions', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9031,
                 contextLines: 2,
             });
@@ -285,7 +285,78 @@ describe('Server Integration Tests', () => {
             parser?.parseDiff.mockClear();
             const response = await fetch(`http://localhost:${result.port}/api/diff?base=main&target=feature&ignoreWhitespace=true`);
             expect(response.ok).toBe(true);
-            expect(parser?.parseDiff).toHaveBeenCalledWith('feature', 'main', true, 2);
+            expect(parser?.parseDiff).toHaveBeenCalledWith({ targetCommitish: 'feature', baseCommitish: 'main' }, true, 2);
+        });
+        it('GET /api/diff passes baseMode through to the parser', async () => {
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockClear();
+            parser?.parseDiff.mockResolvedValueOnce({
+                targetCommit: 'abc123',
+                baseCommit: 'def456',
+                baseCommitish: 'fedcba9',
+                targetCommitish: '.',
+                requestedBaseCommitish: 'origin/main',
+                requestedTargetCommitish: '.',
+                requestedBaseMode: 'merge-base',
+                files: [],
+                isEmpty: true,
+            });
+            const response = await fetch(`http://localhost:${port}/api/diff?base=origin%2Fmain&target=.&baseMode=merge-base`);
+            const data = (await response.json());
+            expect(response.ok).toBe(true);
+            expect(parser?.parseDiff).toHaveBeenCalledWith({
+                targetCommitish: '.',
+                baseCommitish: 'origin/main',
+                baseMode: 'merge-base',
+            }, false, undefined);
+            expect(data.requestedBaseMode).toBe('merge-base');
+            expect(data.baseCommitish).toBe('fedcba9');
+            expect(data.requestedBaseCommitish).toBe('origin/main');
+        });
+        it('GET /api/diff caches results per revision pair instead of reusing the last request', async () => {
+            const result = await startServer({
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
+                preferredPort: 9032,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockClear();
+            const firstResponse = await fetch(`http://localhost:${result.port}/api/diff?base=main&target=feature`);
+            expect(firstResponse.ok).toBe(true);
+            const secondResponse = await fetch(`http://localhost:${result.port}/api/diff?base=HEAD%5E&target=HEAD`);
+            expect(secondResponse.ok).toBe(true);
+            const thirdResponse = await fetch(`http://localhost:${result.port}/api/diff?base=main&target=feature`);
+            expect(thirdResponse.ok).toBe(true);
+            expect(parser?.parseDiff).toHaveBeenCalledTimes(1);
+            expect(parser?.parseDiff).toHaveBeenNthCalledWith(1, { targetCommitish: 'feature', baseCommitish: 'main' }, false, undefined);
+        });
+        it('GET /api/diff evicts least recently used cached diff responses', async () => {
+            const result = await startServer({
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
+                preferredPort: 9033,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockClear();
+            const revisionPairs = [
+                ['base-a', 'target-a'],
+                ['base-b', 'target-b'],
+                ['base-c', 'target-c'],
+                ['base-d', 'target-d'],
+                ['base-e', 'target-e'],
+                ['base-f', 'target-f'],
+                ['base-g', 'target-g'],
+                ['base-h', 'target-h'],
+                ['base-i', 'target-i'],
+            ];
+            for (const [base, target] of revisionPairs) {
+                const response = await fetch(`http://localhost:${result.port}/api/diff?base=${base}&target=${target}`);
+                expect(response.ok).toBe(true);
+            }
+            const revisitedResponse = await fetch(`http://localhost:${result.port}/api/diff?base=base-a&target=target-a`);
+            expect(revisitedResponse.ok).toBe(true);
+            expect(parser?.parseDiff).toHaveBeenCalledTimes(10);
+            expect(parser?.parseDiff).toHaveBeenLastCalledWith({ targetCommitish: 'target-a', baseCommitish: 'base-a' }, false, undefined);
         });
         it('GET /api/diff returns comment import payload when configured', async () => {
             const importedComments = [
@@ -297,8 +368,7 @@ describe('Server Integration Tests', () => {
                 },
             ];
             const importServer = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9034,
                 commentImports: importedComments,
             });
@@ -319,8 +389,7 @@ describe('Server Integration Tests', () => {
                 },
             ];
             const importServer = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9037,
                 clearComments: true,
                 commentImports: importedComments,
@@ -343,8 +412,7 @@ describe('Server Integration Tests', () => {
                 },
             ];
             const importServer = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9038,
                 commentImports: importedComments,
             });
@@ -502,8 +570,7 @@ describe('Server Integration Tests', () => {
         it('serves dev mode HTML in development', async () => {
             process.env.NODE_ENV = 'development';
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9040,
             });
             servers.push(result.server);
@@ -516,8 +583,7 @@ describe('Server Integration Tests', () => {
         it('serves static files in production mode', async () => {
             process.env.NODE_ENV = 'production';
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9050,
             });
             servers.push(result.server);
@@ -531,8 +597,7 @@ describe('Server Integration Tests', () => {
         it('returns 404 for unknown paths in production mode', async () => {
             process.env.NODE_ENV = 'production';
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9055,
             });
             servers.push(result.server);
@@ -544,8 +609,7 @@ describe('Server Integration Tests', () => {
         it('accepts mode option in server configuration', async () => {
             // Test that mode option is accepted without error
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 mode: 'unified',
             });
             servers.push(result.server);
@@ -554,14 +618,12 @@ describe('Server Integration Tests', () => {
         });
         it('accepts different mode values', async () => {
             const inlineResult = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 mode: 'unified',
             });
             servers.push(inlineResult.server);
             const sideBySideResult = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 mode: 'split',
             });
             servers.push(sideBySideResult.server);
@@ -570,8 +632,7 @@ describe('Server Integration Tests', () => {
         });
         it('mode option should be included in diff response', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 mode: 'inline',
             });
             servers.push(result.server);
@@ -584,14 +645,14 @@ describe('Server Integration Tests', () => {
     describe('Revision options API', () => {
         it('returns available revisions', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             });
             servers.push(result.server);
             const response = await fetch(`http://localhost:${result.port}/api/revisions`);
             const data = (await response.json());
             expect(response.ok).toBe(true);
             expect(data.specialOptions).toHaveLength(3);
+            expect(data.specialOptions).not.toContainEqual({ value: 'merge-base', label: 'Merge Base' });
             expect(data.branches).toEqual([{ name: 'main', current: true }]);
             expect(data.commits).toEqual([
                 { hash: 'abc1234', shortHash: 'abc1234', message: 'Test commit' },
@@ -609,8 +670,7 @@ describe('Server Integration Tests', () => {
         });
         it('handles malformed comment data', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             });
             servers.push(result.server);
             const response = await fetch(`http://localhost:${result.port}/api/comments`, {
@@ -632,8 +692,7 @@ describe('Server Integration Tests', () => {
     describe('CORS configuration', () => {
         it('sets correct CORS headers', async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             });
             servers.push(result.server);
             const response = await fetch(`http://localhost:${result.port}/api/diff`);
@@ -646,8 +705,7 @@ describe('Server Integration Tests', () => {
         let port;
         beforeEach(async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9050,
             });
             servers.push(result.server);
@@ -679,8 +737,7 @@ describe('Server Integration Tests', () => {
         let port;
         beforeEach(async () => {
             const result = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: 9060,
             });
             servers.push(result.server);
@@ -765,8 +822,7 @@ describe('Server Integration Tests', () => {
     describe('Keep-alive option', () => {
         it('accepts keepAlive option without error', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 keepAlive: true,
             });
             servers.push(server);
@@ -774,16 +830,14 @@ describe('Server Integration Tests', () => {
         });
         it('starts normally without keepAlive option', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             });
             servers.push(server);
             expect(port).toBeGreaterThanOrEqual(4966);
         });
         it('does not call process.exit on client disconnect when keepAlive is true', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 keepAlive: true,
                 preferredPort: 9070,
             });
@@ -811,8 +865,7 @@ describe('Server Integration Tests', () => {
         });
         it('calls process.exit on client disconnect when keepAlive is false', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 keepAlive: false,
                 preferredPort: 9080,
             });
@@ -841,8 +894,7 @@ describe('Server Integration Tests', () => {
     describe('Clear Comments functionality', () => {
         it('includes clearComments flag in diff response when provided', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 clearComments: true,
             });
             servers.push(server);
@@ -853,8 +905,7 @@ describe('Server Integration Tests', () => {
         });
         it('does not include clearComments flag when not provided', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             });
             servers.push(server);
             const response = await fetch(`http://localhost:${port}/api/diff`);
@@ -864,8 +915,7 @@ describe('Server Integration Tests', () => {
         });
         it('preserves clearComments flag across diff requests', async () => {
             const { port, server } = await startServer({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 clearComments: true,
             });
             servers.push(server);

package/dist/tui/App.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
+import { type DiffSelection } from '../types/diff.js';
 interface AppProps {
-    targetCommitish: string;
-    baseCommitish: string;
+    selection: DiffSelection;
     mode?: string;
     repoPath?: string;
     contextLines?: number;

package/dist/tui/App.js

@@ -6,7 +6,8 @@ import DiffViewer from './components/DiffViewer.js';
 import FileList from './components/FileList.js';
 import SideBySideDiffViewer from './components/SideBySideDiffViewer.js';
 import StatusBar from './components/StatusBar.js';
-const App = ({ targetCommitish, baseCommitish, mode, repoPath, contextLines, }) => {
+const App = ({ selection, mode, repoPath, contextLines }) => {
+    const { targetCommitish, baseCommitish } = selection;
     const [files, setFiles] = useState([]);
     const [selectedFileIndex, setSelectedFileIndex] = useState(0);
     const [loading, setLoading] = useState(true);
@@ -17,7 +18,7 @@ const App = ({ targetCommitish, baseCommitish, mode, repoPath, contextLines, })
         setLoading(true);
         setError(null);
         try {
-            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish, repoPath, contextLines);
+            const fileDiffs = await loadGitDiff(selection, repoPath, contextLines);
             setFiles(fileDiffs);
             setLoading(false);
         }
@@ -30,7 +31,7 @@ const App = ({ targetCommitish, baseCommitish, mode, repoPath, contextLines, })
         // oxlint-disable-next-line react-hooks-js/set-state-in-effect -- intentional: trigger initial diff load when revisions change
         void loadDiff();
         // oxlint-disable-next-line react/exhaustive-deps
-    }, [targetCommitish, baseCommitish]);
+    }, [baseCommitish, targetCommitish]);
     useInput((input, key) => {
         if (input === 'q' || (key.ctrl && input === 'c')) {
             exit();