difit 4.0.4 → 4.0.6

package/dist/server/server.js

@@ -7,9 +7,9 @@ import open from 'open';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { formatCommentsOutput } from '../utils/commentFormatting.js';
-import { serializeCommentImports } from '../utils/commentImports.js';
+import { mergeCommentImports, normalizeCommentImports, serializeCommentImports, } from '../utils/commentImports.js';
 import { normalizeDiffViewMode } from '../utils/diffMode.js';
-import { resolveEditorOption } from '../utils/editorOptions.js';
+import { buildEditorSpawnSpec, CUSTOM_EDITOR_ID, NONE_EDITOR_ID, resolveEditorOption, } from '../utils/editorOptions.js';
 import { getFileExtension } from '../utils/fileUtils.js';
 import { FileWatcherService } from './file-watcher.js';
 import { GitDiffParser } from './git-diff.js';
@@ -42,6 +42,15 @@ function setCachedDiffResponse(cache, key, value) {
         cache.delete(oldestKey);
     }
 }
+function createResolvedCommentSelection(responseDiffData, fallbackSelection, stdinDiff) {
+    const baseCommitish = responseDiffData.baseCommitish ?? (stdinDiff ? 'stdin' : fallbackSelection.baseCommitish);
+    const targetCommitish = responseDiffData.targetCommitish ?? (stdinDiff ? 'stdin' : fallbackSelection.targetCommitish);
+    const baseMode = responseDiffData.requestedBaseMode ?? fallbackSelection.baseMode;
+    return createDiffSelection(baseCommitish, targetCommitish, baseMode);
+}
+function createCommentSessionKey(selection) {
+    return getDiffSelectionKey(selection);
+}
 export async function startServer(options) {
     const app = express();
     const repositoryPath = resolve(options.repoPath ?? process.cwd());
@@ -96,6 +105,7 @@ export async function startServer(options) {
     };
     // Track current revisions for cache invalidation
     let currentSelection = initialSelection;
+    let currentCommentSelection = createResolvedCommentSelection(initialDiffData, initialSelection, Boolean(options.stdinDiff));
     function parseRepositoryRelativePath(filepath) {
         if (typeof filepath !== 'string' || filepath.length === 0) {
             return { ok: false, error: 'Invalid file path' };
@@ -111,6 +121,51 @@ export async function startServer(options) {
         }
         return { ok: true, path: normalizedFilepath };
     }
+    function parseEditorRequest(value) {
+        if (!value || typeof value !== 'object') {
+            return { id: undefined, command: undefined, argsTemplate: undefined };
+        }
+        const candidate = value;
+        return {
+            id: typeof candidate.id === 'string' ? candidate.id : undefined,
+            command: typeof candidate.command === 'string' ? candidate.command : undefined,
+            argsTemplate: typeof candidate.argsTemplate === 'string' ? candidate.argsTemplate : undefined,
+        };
+    }
+    const commentSessions = new Map();
+    const initialCommentThreads = mergeCommentImports([], initialCommentImports).threads;
+    if (initialCommentThreads.length > 0) {
+        commentSessions.set(createCommentSessionKey(currentCommentSelection), {
+            threads: initialCommentThreads,
+            version: 1,
+        });
+    }
+    function getCommentSelectionFromQuery(query) {
+        const hasBase = typeof query.base === 'string';
+        const hasTarget = typeof query.target === 'string';
+        const hasBaseMode = typeof query.baseMode === 'string';
+        if (!hasBase && !hasTarget && !hasBaseMode) {
+            return currentCommentSelection;
+        }
+        return createDiffSelection(hasBase ? query.base : currentCommentSelection.baseCommitish, hasTarget ? query.target : currentCommentSelection.targetCommitish, hasBaseMode
+            ? parseBaseMode(query.baseMode)
+            : hasBase || hasTarget
+                ? undefined
+                : currentCommentSelection.baseMode);
+    }
+    function getOrCreateCommentSession(selection) {
+        const key = createCommentSessionKey(selection);
+        const existing = commentSessions.get(key);
+        if (existing) {
+            return existing;
+        }
+        const nextSession = {
+            threads: [],
+            version: 0,
+        };
+        commentSessions.set(key, nextSession);
+        return nextSession;
+    }
     app.get('/api/diff', async (req, res) => {
         const ignoreWhitespace = req.query.ignoreWhitespace === 'true';
         const hasBase = typeof req.query.base === 'string';
@@ -137,6 +192,7 @@ export async function startServer(options) {
                 generatedStatusCache.clear();
             }
         }
+        currentCommentSelection = createResolvedCommentSelection(responseDiffData, requestedSelection, Boolean(options.stdinDiff));
         const baseCommitish = responseDiffData.baseCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
         const targetCommitish = responseDiffData.targetCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
         const requestedBaseCommitish = responseDiffData.requestedBaseCommitish ??
@@ -314,31 +370,58 @@ export async function startServer(options) {
             res.status(404).json({ error: 'File not found' });
         }
     });
-    let finalThreads = [];
+    function normalizeLineValue(line) {
+        if (Array.isArray(line) && line.length === 2) {
+            const start = line[0];
+            const end = line[1];
+            if (typeof start === 'number' &&
+                typeof end === 'number' &&
+                Number.isInteger(start) &&
+                Number.isInteger(end) &&
+                start > 0 &&
+                end > 0 &&
+                start <= end) {
+                return { start, end };
+            }
+        }
+        if (typeof line === 'number' && Number.isInteger(line) && line > 0) {
+            return line;
+        }
+        return 1;
+    }
     function normalizeComment(comment) {
+        const now = new Date().toISOString();
+        const timestamp = typeof comment.timestamp === 'string' ? comment.timestamp : now;
+        const threadId = typeof comment.id === 'string' && comment.id.length > 0
+            ? comment.id
+            : createHash('sha256').update(JSON.stringify(comment)).digest('hex').slice(0, 12);
+        const filePath = typeof comment.file === 'string' && comment.file.length > 0 ? comment.file : '<unknown file>';
         return {
-            id: comment.id,
-            file: comment.file,
-            line: comment.line,
-            side: comment.side,
-            createdAt: comment.timestamp,
-            updatedAt: comment.timestamp,
-            codeContent: comment.codeContent,
+            id: threadId,
+            filePath,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            position: {
+                side: comment.side ?? 'new',
+                line: normalizeLineValue(comment.line),
+            },
+            codeSnapshot: typeof comment.codeContent === 'string'
+                ? {
+                    content: comment.codeContent,
+                }
+                : undefined,
             messages: [
                 {
-                    id: comment.id,
+                    id: threadId,
                     body: comment.body,
                     author: comment.author,
-                    createdAt: comment.timestamp,
-                    updatedAt: comment.timestamp,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
                 },
             ],
         };
     }
-    function normalizeThreadPayload(thread) {
-        if ('file' in thread && 'line' in thread) {
-            return thread;
-        }
+    function toCommentThread(thread) {
         return {
             id: thread.id,
             file: thread.filePath,
@@ -352,6 +435,51 @@ export async function startServer(options) {
             messages: thread.messages,
         };
     }
+    function normalizeThreadPayload(thread) {
+        if ('filePath' in thread && 'position' in thread) {
+            return thread;
+        }
+        const threadId = typeof thread.id === 'string' && thread.id.length > 0
+            ? thread.id
+            : createHash('sha256').update(JSON.stringify(thread)).digest('hex').slice(0, 12);
+        const now = new Date().toISOString();
+        const messages = Array.isArray(thread.messages) && thread.messages.length > 0
+            ? thread.messages.map((message, index) => ({
+                id: typeof message.id === 'string' && message.id.length > 0
+                    ? message.id
+                    : `${threadId}:${index}`,
+                body: message.body,
+                author: message.author,
+                createdAt: message.createdAt || thread.createdAt || now,
+                updatedAt: message.updatedAt || message.createdAt || thread.updatedAt || now,
+            }))
+            : [
+                {
+                    id: threadId,
+                    body: '',
+                    createdAt: thread.createdAt || now,
+                    updatedAt: thread.updatedAt || thread.createdAt || now,
+                },
+            ];
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        return {
+            id: threadId,
+            filePath: typeof thread.file === 'string' && thread.file.length > 0 ? thread.file : '<unknown file>',
+            createdAt: thread.createdAt || firstMessage?.createdAt || now,
+            updatedAt: thread.updatedAt || lastMessage?.updatedAt || thread.createdAt || now,
+            position: {
+                side: thread.side ?? 'new',
+                line: normalizeLineValue(thread.line),
+            },
+            codeSnapshot: typeof thread.codeContent === 'string'
+                ? {
+                    content: thread.codeContent,
+                }
+                : undefined,
+            messages,
+        };
+    }
     function parseCommentsPayload(body) {
         const payload = typeof body === 'string'
             ? JSON.parse(body)
@@ -364,9 +492,33 @@ export async function startServer(options) {
         }
         return [];
     }
+    function parseCommentImportsPayload(body) {
+        if (typeof body === 'string') {
+            return normalizeCommentImports(JSON.parse(body));
+        }
+        return normalizeCommentImports(body);
+    }
+    function updateCommentSession(selection, nextThreads) {
+        const session = getOrCreateCommentSession(selection);
+        const previous = JSON.stringify(session.threads);
+        const next = JSON.stringify(nextThreads);
+        session.threads = nextThreads;
+        if (previous === next) {
+            return false;
+        }
+        session.version += 1;
+        fileWatcher.broadcast({
+            type: 'commentsChanged',
+            version: session.version,
+            timestamp: new Date().toISOString(),
+        });
+        return true;
+    }
     app.post('/api/comments', (req, res) => {
         try {
-            finalThreads = parseCommentsPayload(req.body);
+            const selection = getCommentSelectionFromQuery(req.query);
+            const nextThreads = parseCommentsPayload(req.body);
+            updateCommentSession(selection, nextThreads);
             res.json({ success: true });
         }
         catch (error) {
@@ -374,10 +526,43 @@ export async function startServer(options) {
             res.status(400).json({ error: 'Invalid comment data' });
         }
     });
-    app.get('/api/comments-output', (_req, res) => {
+    app.post('/api/comment-imports', (req, res) => {
+        try {
+            const selection = getCommentSelectionFromQuery(req.query);
+            const session = getOrCreateCommentSession(selection);
+            const commentImports = parseCommentImportsPayload(req.body);
+            const importId = createHash('sha256')
+                .update(serializeCommentImports(commentImports))
+                .digest('hex');
+            const merged = mergeCommentImports(session.threads, commentImports);
+            const changed = updateCommentSession(selection, merged.threads);
+            res.json({
+                success: true,
+                changed,
+                count: commentImports.length,
+                importId,
+                warnings: merged.warnings,
+            });
+        }
+        catch (error) {
+            console.error('Error parsing comment imports:', error);
+            res.status(400).json({ error: 'Invalid comment import data' });
+        }
+    });
+    app.get('/api/comments-json', (req, res) => {
+        const selection = getCommentSelectionFromQuery(req.query);
+        const session = getOrCreateCommentSession(selection);
+        res.json({
+            version: session.version,
+            threads: session.threads,
+        });
+    });
+    app.get('/api/comments-output', (req, res) => {
+        const selection = getCommentSelectionFromQuery(req.query);
+        const session = getOrCreateCommentSession(selection);
         res.type('text/plain');
-        if (finalThreads.length > 0) {
-            const output = formatCommentsOutput(finalThreads);
+        if (session.threads.length > 0) {
+            const output = formatCommentsOutput(session.threads.map(toCommentThread));
             res.send(output);
         }
         else {
@@ -400,67 +585,79 @@ export async function startServer(options) {
             return;
         }
         const resolvedPath = resolve(repositoryPath, filepathResult.path);
-        const editorInput = typeof editor === 'string' ? editor : (process.env.DIFIT_EDITOR ?? process.env.EDITOR);
-        const resolvedEditor = resolveEditorOption(editorInput);
-        if (resolvedEditor.protocol === null) {
+        const editorRequest = parseEditorRequest(editor);
+        const editorId = editorRequest.id ?? process.env.DIFIT_EDITOR ?? process.env.EDITOR ?? undefined;
+        if (editorId?.toLowerCase() === NONE_EDITOR_ID) {
             res.status(400).json({ error: 'Open in editor is disabled' });
             return;
         }
+        // The browser always sends command + argsTemplate in the body, so we use
+        // those directly. We only fall back to the preset table when neither is
+        // provided (for example, when DIFIT_EDITOR is set and there's no body).
+        let command;
+        let argsTemplate;
+        if (editorRequest.command !== undefined || editorRequest.argsTemplate !== undefined) {
+            command = (editorRequest.command ?? '').trim();
+            argsTemplate = (editorRequest.argsTemplate ?? '').trim();
+        }
+        else {
+            const preset = resolveEditorOption(editorId);
+            command = preset.command;
+            argsTemplate = preset.argsTemplate;
+        }
+        if (!command || !argsTemplate) {
+            const isCustom = editorId?.toLowerCase() === CUSTOM_EDITOR_ID;
+            res.status(400).json({
+                error: isCustom
+                    ? 'Custom editor is not configured. Set a command and arguments in Settings > System.'
+                    : 'Open in editor is not configured',
+            });
+            return;
+        }
         const lineNumber = (() => {
             const parsed = Number.parseInt(String(line ?? ''), 10);
             return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
         })();
-        const tryOpenWithCli = async () => {
-            if (!resolvedEditor.cliCommand)
-                return false;
-            const args = [...resolvedEditor.cliArgs];
-            if (lineNumber !== null) {
-                const fileWithLine = `${resolvedPath}:${lineNumber}`;
-                if (resolvedEditor.lineFormat === 'goto-flag') {
-                    args.push('-g', fileWithLine);
-                }
-                else {
-                    args.push(fileWithLine);
+        const spawnSpec = buildEditorSpawnSpec({
+            command,
+            argsTemplate,
+            filePath: resolvedPath,
+            lineNumber,
+        });
+        if (!spawnSpec) {
+            res.status(500).json({ error: 'Invalid editor configuration' });
+            return;
+        }
+        const launched = await new Promise((resolvePromise) => {
+            const child = spawn(spawnSpec.command, [...spawnSpec.args], {
+                stdio: 'ignore',
+                detached: true,
+            });
+            child.once('error', (error) => {
+                const code = error.code;
+                if (code && code !== 'ENOENT') {
+                    console.error('Failed to launch editor CLI:', error);
                 }
-            }
-            else {
-                args.push(resolvedPath);
-            }
-            args.push(repositoryPath);
-            return await new Promise((resolvePromise) => {
-                const child = spawn(resolvedEditor.cliCommand, args, { stdio: 'ignore', detached: true });
-                child.once('error', (error) => {
-                    const code = error.code;
-                    if (code && code !== 'ENOENT') {
-                        console.error('Failed to launch editor CLI:', error);
-                    }
-                    resolvePromise(false);
-                });
-                child.once('spawn', () => {
-                    child.unref();
-                    resolvePromise(true);
-                });
+                resolvePromise(false);
+            });
+            child.once('spawn', () => {
+                child.unref();
+                resolvePromise(true);
+            });
+        });
+        if (!launched) {
+            res.status(500).json({
+                error: `Failed to launch editor: command "${spawnSpec.command}" is not available on PATH`,
             });
-        };
-        if (await tryOpenWithCli()) {
-            res.json({ success: true });
             return;
         }
-        const lineSuffix = lineNumber !== null ? `:${lineNumber}` : '';
-        const fileUri = `${resolvedEditor.protocol}://file${encodeURI(resolvedPath)}${lineSuffix}`;
-        try {
-            await open(fileUri);
-            res.json({ success: true });
-        }
-        catch (error) {
-            console.error('Failed to open file in editor:', error);
-            res.status(500).json({ error: 'Failed to open file in editor' });
-        }
+        res.json({ success: true });
     });
     // Function to output comments when server shuts down
     function outputFinalComments() {
-        if (finalThreads.length > 0) {
-            console.log(formatCommentsOutput(finalThreads));
+        const session = getOrCreateCommentSession(currentCommentSelection);
+        if (session.threads.length > 0) {
+            console.log(formatCommentsOutput(session.threads.map(toCommentThread)));
         }
     }
     // SSE endpoint for file watching

package/dist/server/server.test.js

@@ -526,6 +526,234 @@ describe('Server Integration Tests', () => {
             expect(output).toContain('Multi-line comment');
             expect(output).toContain('Total comments: 2');
         });
+        it('POST /api/comment-imports accepts valid comment imports', async () => {
+            const imports = [
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Review comment',
+                },
+            ];
+            const response = await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            expect(response.ok).toBe(true);
+            const data = (await response.json());
+            expect(data.success).toBe(true);
+            expect(data.importId).toEqual(expect.any(String));
+            expect(data.count).toBe(1);
+        });
+        it('POST /api/comment-imports accepts a single object', async () => {
+            const singleImport = {
+                type: 'thread',
+                filePath: 'src/example.ts',
+                position: { side: 'new', line: 5 },
+                body: 'Single object import',
+            };
+            const response = await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(singleImport),
+            });
+            expect(response.ok).toBe(true);
+            const data = (await response.json());
+            expect(data.success).toBe(true);
+            expect(data.count).toBe(1);
+        });
+        it('POST /api/comment-imports rejects invalid data', async () => {
+            const response = await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ invalid: true }),
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data).toHaveProperty('error');
+        });
+        it('GET /api/comments-json returns empty threads by default', async () => {
+            const response = await fetch(`http://localhost:${port}/api/comments-json`);
+            expect(response.ok).toBe(true);
+            const data = (await response.json());
+            expect(data).toHaveProperty('threads');
+            expect(data.threads).toEqual([]);
+        });
+        it('GET /api/comments-json returns threads after posting comments', async () => {
+            const comments = [{ file: 'test.js', line: 10, body: 'JSON test comment' }];
+            await fetch(`http://localhost:${port}/api/comments`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ comments }),
+            });
+            const response = await fetch(`http://localhost:${port}/api/comments-json`);
+            expect(response.ok).toBe(true);
+            const data = (await response.json());
+            expect(data.threads).toHaveLength(1);
+            expect(data.threads[0].messages[0].body).toBe('JSON test comment');
+        });
+        it('POST /api/comment-imports merges into server-side threads for comments-output', async () => {
+            const imports = [
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 42 },
+                    body: 'Merged server-side comment',
+                },
+            ];
+            await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            const outputResponse = await fetch(`http://localhost:${port}/api/comments-output`);
+            const output = await outputResponse.text();
+            expect(output).toContain('src/example.ts:L42');
+            expect(output).toContain('Merged server-side comment');
+        });
+        it('POST /api/comment-imports merges reply into existing thread', async () => {
+            // First add a thread
+            await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify([
+                    {
+                        type: 'thread',
+                        filePath: 'src/reply-test.ts',
+                        position: { side: 'new', line: 5 },
+                        body: 'Original comment',
+                        author: 'User',
+                    },
+                ]),
+            });
+            // Then add a reply
+            await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify([
+                    {
+                        type: 'reply',
+                        filePath: 'src/reply-test.ts',
+                        position: { side: 'new', line: 5 },
+                        body: 'Reply to comment',
+                        author: 'AI',
+                    },
+                ]),
+            });
+            const jsonResponse = await fetch(`http://localhost:${port}/api/comments-json`);
+            const data = (await jsonResponse.json());
+            const thread = data.threads.find((t) => t.filePath === 'src/reply-test.ts');
+            expect(thread).toBeDefined();
+            expect(thread.messages).toHaveLength(2);
+            expect(thread.messages[0].body).toBe('Original comment');
+            expect(thread.messages[1].body).toBe('Reply to comment');
+        });
+        it('POST /api/comment-imports deduplicates identical imports', async () => {
+            const imports = [
+                {
+                    type: 'thread',
+                    filePath: 'src/dedup.ts',
+                    position: { side: 'new', line: 1 },
+                    body: 'Unique comment',
+                },
+            ];
+            // Send the same import twice
+            await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            await fetch(`http://localhost:${port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            const jsonResponse = await fetch(`http://localhost:${port}/api/comments-json`);
+            const data = (await jsonResponse.json());
+            const threads = data.threads.filter((t) => t.filePath === 'src/dedup.ts');
+            expect(threads).toHaveLength(1);
+        });
+        it('isolates comment sessions between different diff selections', async () => {
+            const importServer = await startServer({
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
+                preferredPort: 9039,
+                commentImports: [
+                    {
+                        type: 'thread',
+                        filePath: 'src/cli/comment.test.ts',
+                        position: { side: 'new', line: 10 },
+                        body: 'Startup comment',
+                    },
+                ],
+            });
+            servers.push(importServer.server);
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockImplementation(async (selection) => ({
+                targetCommit: 'abc123',
+                baseCommit: 'def456',
+                baseCommitish: selection.baseCommitish === 'HEAD^' ? 'def4567' : selection.baseCommitish,
+                targetCommitish: selection.targetCommitish === 'HEAD' ? 'abc1234' : selection.targetCommitish,
+                requestedBaseCommitish: selection.baseCommitish,
+                requestedTargetCommitish: selection.targetCommitish,
+                requestedBaseMode: selection.baseMode,
+                targetMessage: 'Test commit',
+                baseMessage: 'Previous commit',
+                files: [
+                    {
+                        path: 'src/cli/comment.test.ts',
+                        additions: 10,
+                        deletions: 5,
+                        chunks: [],
+                    },
+                ],
+                stats: { additions: 10, deletions: 5 },
+                isEmpty: false,
+            }));
+            await fetch(`http://localhost:${importServer.port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify([
+                    {
+                        type: 'thread',
+                        filePath: 'src/cli/comment.test.ts',
+                        position: { side: 'new', line: 20 },
+                        body: 'API comment',
+                    },
+                ]),
+            });
+            let response = await fetch(`http://localhost:${importServer.port}/api/comments-output`);
+            let output = await response.text();
+            expect(output).toContain('Startup comment');
+            expect(output).toContain('API comment');
+            await fetch(`http://localhost:${importServer.port}/api/diff?base=feat%2F292-comment-read-write&target=codex%2Fcomment-session-state`);
+            response = await fetch(`http://localhost:${importServer.port}/api/comments-output`);
+            output = await response.text();
+            expect(output).toBe('');
+            await fetch(`http://localhost:${importServer.port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify([
+                    {
+                        type: 'thread',
+                        filePath: 'src/cli/comment.test.ts',
+                        position: { side: 'new', line: 30 },
+                        body: 'Other diff comment',
+                    },
+                ]),
+            });
+            response = await fetch(`http://localhost:${importServer.port}/api/comments-output`);
+            output = await response.text();
+            expect(output).toContain('Other diff comment');
+            expect(output).not.toContain('Startup comment');
+            expect(output).not.toContain('API comment');
+            await fetch(`http://localhost:${importServer.port}/api/diff?base=HEAD%5E&target=HEAD`);
+            response = await fetch(`http://localhost:${importServer.port}/api/comments-output`);
+            output = await response.text();
+            expect(output).toContain('Startup comment');
+            expect(output).toContain('API comment');
+            expect(output).not.toContain('Other diff comment');
+        });
         it.skip('GET /api/heartbeat returns SSE headers', async () => {
             // Skipped due to connection reset issues in test environment
             // SSE endpoint functionality is verified through manual testing

package/dist/tui/App.js

@@ -28,7 +28,6 @@ const App = ({ selection, mode, repoPath, contextLines }) => {
         }
     };
     useEffect(() => {
-        // 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
     }, [baseCommitish, targetCommitish]);