difit 4.0.1 → 4.0.3

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

@@ -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,7 +1082,10 @@ 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',
                 '-U5',
@@ -1089,6 +1096,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,7 +1110,10 @@ 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']);
@@ -1106,6 +1121,40 @@ index abc123..def456 100644
                 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

@@ -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

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