difit 4.0.5 → 4.0.7

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]);

package/dist/types/diff.d.ts

@@ -32,7 +32,7 @@ export interface ParsedDiff {
     chunks: DiffChunk[];
 }
 export type DiffViewMode = 'split' | 'unified';
-export type LegacyDiffViewMode = 'side-by-side' | 'inline';
+type LegacyDiffViewMode = 'side-by-side' | 'inline';
 export type DiffSide = 'old' | 'new';
 export type DiffLineRange = number | {
     start: number;
@@ -138,6 +138,17 @@ export interface ViewedFileRecord {
     viewedAt: string;
     diffContentHash: string;
 }
+export interface ViewedHashIndexEntry {
+    filePath: string;
+    diffContentHash: string;
+    hashVersion: 1;
+    viewedAt: string;
+}
+export interface ViewedHashIndex {
+    version: 1;
+    lastModifiedAt: string;
+    entries: ViewedHashIndexEntry[];
+}
 export interface LegacyDiffContextStorage {
     version: 1;
     baseCommitish: string;
@@ -168,11 +179,11 @@ export interface CommentThread {
     codeContent?: string;
     messages: DiffCommentMessage[];
 }
-export interface RevisionOption {
+interface RevisionOption {
     value: string;
     label: string;
 }
-export interface BranchInfo {
+interface BranchInfo {
     name: string;
     current: boolean;
 }
@@ -199,7 +210,7 @@ export interface FileExpandedState {
     oldTotalLines?: number;
     newTotalLines?: number;
 }
-export interface ExpandedRange {
+interface ExpandedRange {
     chunkIndex: number;
     direction: 'up' | 'down';
     count: number;

package/dist/types/watch.d.ts

@@ -5,12 +5,41 @@ export declare enum DiffMode {
     DOT = "dot",// HEAD vs working (all changes)
     SPECIFIC = "specific"
 }
+type WatchChangeType = 'file' | 'commit' | 'staging';
+interface ConnectedWatchEvent {
+    type: 'connected';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ReloadWatchEvent {
+    type: 'reload';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ErrorWatchEvent {
+    type: 'error';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface CommentsChangedWatchEvent {
+    type: 'commentsChanged';
+    version: number;
+    timestamp: string;
+}
+export type WatchEvent = ConnectedWatchEvent | ReloadWatchEvent | ErrorWatchEvent | CommentsChangedWatchEvent;
 export interface ClientWatchState {
     isWatchEnabled: boolean;
     diffMode: DiffMode;
     shouldReload: boolean;
     isReloading: boolean;
     lastChangeTime: Date | null;
-    lastChangeType: 'file' | 'commit' | 'staging' | null;
+    lastChangeType: WatchChangeType | null;
     connectionStatus: 'connected' | 'disconnected' | 'reconnecting';
 }
+export {};

package/dist/utils/commentImports.d.ts

@@ -3,7 +3,9 @@ interface MergeCommentImportsResult {
     threads: DiffCommentThread[];
     warnings: string[];
 }
+export declare function normalizeCommentImports(input: unknown): CommentImport[];
 export declare function parseCommentImportValue(value: string): CommentImport[];
+export declare function mergeCommentThreads(existingThreads: DiffCommentThread[], incomingThreads: DiffCommentThread[]): MergeCommentImportsResult;
 export declare function serializeCommentImports(commentImports: CommentImport[]): string;
 export declare function mergeCommentImports(existingThreads: DiffCommentThread[], commentImports: CommentImport[]): MergeCommentImportsResult;
 export {};

package/dist/utils/commentImports.js

@@ -105,7 +105,7 @@ function normalizeCommentImportEntry(value) {
     };
     return normalized;
 }
-function normalizeCommentImports(input) {
+export function normalizeCommentImports(input) {
     if (Array.isArray(input)) {
         return input.map((entry) => normalizeCommentImportEntry(entry));
     }
@@ -204,6 +204,124 @@ function createImportedReply(commentImport, now) {
         updatedAt,
     };
 }
+function cloneLineRange(line) {
+    if (typeof line === 'number') {
+        return line;
+    }
+    return {
+        start: line.start,
+        end: line.end,
+    };
+}
+function clonePosition(position) {
+    return {
+        side: position.side,
+        line: cloneLineRange(position.line),
+    };
+}
+function cloneCodeSnapshot(snapshot) {
+    if (!snapshot) {
+        return undefined;
+    }
+    return {
+        content: snapshot.content,
+        language: snapshot.language,
+    };
+}
+function cloneMessage(message) {
+    return {
+        id: message.id,
+        body: message.body,
+        author: message.author,
+        createdAt: message.createdAt,
+        updatedAt: message.updatedAt,
+    };
+}
+function cloneThread(thread) {
+    return {
+        id: thread.id,
+        filePath: thread.filePath,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        position: clonePosition(thread.position),
+        codeSnapshot: cloneCodeSnapshot(thread.codeSnapshot),
+        messages: thread.messages.map(cloneMessage),
+    };
+}
+function messagesMatch(left, right) {
+    if (left.id === right.id) {
+        return true;
+    }
+    if (normalizeAuthor(left.author) !== normalizeAuthor(right.author)) {
+        return false;
+    }
+    return left.body === right.body && left.createdAt === right.createdAt;
+}
+function threadsMatch(left, right) {
+    if (left.id === right.id) {
+        return true;
+    }
+    if (left.filePath !== right.filePath || !positionsMatch(left.position, right.position)) {
+        return false;
+    }
+    const leftRoot = left.messages[0];
+    const rightRoot = right.messages[0];
+    if (!leftRoot || !rightRoot) {
+        return false;
+    }
+    return messagesMatch(leftRoot, rightRoot);
+}
+function sortReplies(left, right) {
+    const createdAtOrder = left.createdAt.localeCompare(right.createdAt);
+    if (createdAtOrder !== 0) {
+        return createdAtOrder;
+    }
+    return left.id.localeCompare(right.id);
+}
+function pickNewerMessage(existingMessage, incomingMessage) {
+    if (incomingMessage.updatedAt.localeCompare(existingMessage.updatedAt) >= 0) {
+        return cloneMessage(incomingMessage);
+    }
+    return cloneMessage(existingMessage);
+}
+function mergeThread(existingThread, incomingThread) {
+    const mergedMessages = existingThread.messages.map(cloneMessage);
+    for (const incomingMessage of incomingThread.messages) {
+        const matchIndex = mergedMessages.findIndex((message) => messagesMatch(message, incomingMessage));
+        if (matchIndex >= 0) {
+            mergedMessages[matchIndex] = pickNewerMessage(mergedMessages[matchIndex], incomingMessage);
+            continue;
+        }
+        mergedMessages.push(cloneMessage(incomingMessage));
+    }
+    const [rootMessage, ...replyMessages] = mergedMessages;
+    const orderedMessages = rootMessage
+        ? [rootMessage, ...replyMessages.sort(sortReplies)]
+        : replyMessages.sort(sortReplies);
+    const updatedAt = orderedMessages.reduce((latest, message) => maxIsoTimestamp(latest, message.updatedAt), maxIsoTimestamp(existingThread.updatedAt, incomingThread.updatedAt));
+    return {
+        ...cloneThread(existingThread),
+        createdAt: existingThread.createdAt.localeCompare(incomingThread.createdAt) <= 0
+            ? existingThread.createdAt
+            : incomingThread.createdAt,
+        updatedAt,
+        position: clonePosition(existingThread.position),
+        codeSnapshot: cloneCodeSnapshot(incomingThread.codeSnapshot ?? existingThread.codeSnapshot),
+        messages: orderedMessages,
+    };
+}
+export function mergeCommentThreads(existingThreads, incomingThreads) {
+    const threads = existingThreads.map(cloneThread);
+    for (const incomingThread of incomingThreads) {
+        const existingIndex = threads.findIndex((thread) => threadsMatch(thread, incomingThread));
+        if (existingIndex < 0) {
+            threads.push(cloneThread(incomingThread));
+            continue;
+        }
+        threads[existingIndex] = mergeThread(threads[existingIndex], incomingThread);
+    }
+    return { threads, warnings: [] };
+}
 function serializeLineRange(line) {
     if (typeof line === 'number') {
         return line;

package/dist/utils/editorOptions.d.ts

@@ -1,37 +1,60 @@
-export declare const EDITOR_OPTIONS: readonly [{
-    readonly id: "vscode";
-    readonly label: "VS Code";
-    readonly protocol: "vscode";
-    readonly cliCommand: "code";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["vscode", "code"];
-}, {
-    readonly id: "cursor";
-    readonly label: "Cursor";
-    readonly protocol: "cursor";
-    readonly cliCommand: "cursor";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["cursor"];
-}, {
-    readonly id: "zed";
-    readonly label: "Zed";
-    readonly protocol: "zed";
-    readonly cliCommand: "zed";
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "path-suffix";
-    readonly aliases: readonly ["zed"];
-}, {
-    readonly id: "none";
-    readonly label: "Hide “Open in editor” button";
-    readonly protocol: null;
-    readonly cliCommand: null;
-    readonly cliArgs: readonly [];
-    readonly lineFormat: "goto-flag";
-    readonly aliases: readonly ["none", "disabled", "off"];
-}];
-export type EditorOption = (typeof EDITOR_OPTIONS)[number];
-export type EditorOptionId = EditorOption['id'];
+export type EditorOptionId = 'vscode' | 'cursor' | 'zed' | 'textmate' | 'bbedit' | 'emacs' | 'macvim' | 'sublime' | 'nova' | 'custom' | 'none';
+interface EditorOption {
+    readonly id: EditorOptionId;
+    readonly label: string;
+    /**
+     * Executable to run. Empty string for the `custom` placeholder (filled in by
+     * the user) and for `none` (open-in-editor disabled).
+     */
+    readonly command: string;
+    /**
+     * Whitespace-separated argument template. Supports the `%file` and `%line`
+     * placeholders. Parsed just before spawning so quoted segments survive:
+     * e.g. `'-l %line "%file"'`.
+     */
+    readonly argsTemplate: string;
+}
+export declare const CUSTOM_EDITOR_ID: EditorOptionId;
+export declare const NONE_EDITOR_ID: EditorOptionId;
 export declare const DEFAULT_EDITOR_ID: EditorOptionId;
+export declare const EDITOR_OPTIONS: readonly [EditorOption, ...EditorOption[]];
+export declare const DEFAULT_EDITOR_OPTION: EditorOption;
+/**
+ * Case-insensitive lookup by id. Used mostly for the `DIFIT_EDITOR` / `EDITOR`
+ * environment-variable fallback on the server; the browser UI passes the full
+ * `{id, command, argsTemplate}` shape so it does not rely on this helper.
+ */
 export declare const resolveEditorOption: (input?: string) => EditorOption;
+/**
+ * Tokenise a user-supplied arguments template string into individual CLI
+ * arguments. Supports single and double quoted segments so paths and flags
+ * containing spaces can be preserved.
+ *
+ * Inside double-quoted segments `\"` decodes to a literal `"` and `\\` to a
+ * literal `\`, mirroring common shell intuition. Other `\x` sequences pass
+ * through untouched so Lisp/regex fragments like `\s` or `\$` stay intact.
+ * Single-quoted segments are fully literal. The template is handed to
+ * `spawn` as argv directly – no shell is involved.
+ */
+export declare const parseEditorArgsTemplate: (template: string | undefined | null) => string[];
+interface EditorSpawnSpec {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+interface BuildEditorSpawnSpecInput {
+    readonly command: string;
+    readonly argsTemplate: string;
+    readonly filePath: string;
+    readonly lineNumber: number | null;
+}
+/**
+ * Build the final `{ command, args }` tuple to hand to `child_process.spawn`.
+ * Returns `null` when the command is empty so callers can surface a clear
+ * "not configured" error instead of spawning an empty process.
+ *
+ * `%file` and `%line` are substituted as-is inside each token, so composite
+ * tokens such as `"%file:%line"` become `"/abs/file.ts:42"`. When no line
+ * number is available the substitution falls back to `1`.
+ */
+export declare const buildEditorSpawnSpec: (input: BuildEditorSpawnSpecInput) => EditorSpawnSpec | null;
+export {};