difit 3.1.18 → 4.0.1

package/dist/utils/commentFormatting.d.ts

@@ -1,4 +1,6 @@
-import type { Comment } from '../types/diff';
+import type { Comment, CommentThread } from '../types/diff';
 export declare function formatCommentPrompt(file: string, line: number | number[], body: string, codeContent?: string): string;
 export declare function formatAllCommentsPrompt(comments: Comment[]): string;
-export declare function formatCommentsOutput(comments: Comment[]): string;
+export declare function formatCommentThreadPrompt(thread: CommentThread): string;
+export declare function formatAllCommentThreadsPrompt(threads: CommentThread[]): string;
+export declare function formatCommentsOutput(input: Comment[] | CommentThread[]): string;

package/dist/utils/commentFormatting.js

@@ -1,38 +1,56 @@
 import { hasSuggestionBlock, parseSuggestionBlocks } from './suggestionUtils.js';
-export function formatCommentPrompt(file, line, body, codeContent) {
-    const lineInfo = typeof line === 'number' ? `L${line}` : Array.isArray(line) ? `L${line[0]}-L${line[1]}` : '';
-    // Handle undefined or null file paths
-    const filePath = file || '<unknown file>';
-    // Check if body contains suggestion blocks
+function getLineInfo(line) {
+    return typeof line === 'number' ? `L${line}` : `L${line[0]}-L${line[1]}`;
+}
+function formatCommentContent(body, codeContent) {
     if (hasSuggestionBlock(body)) {
         const suggestions = parseSuggestionBlocks(body);
         if (suggestions.length > 0) {
-            let result = `${filePath}:${lineInfo}`;
-            // Walk through body preserving text between suggestion blocks
+            let result = '';
             let lastIndex = 0;
             for (const suggestion of suggestions) {
-                // Add text before this suggestion block
                 const textBefore = body.slice(lastIndex, suggestion.startIndex).trim();
                 if (textBefore) {
-                    result += `\n${textBefore}`;
+                    result += `${result ? '\n' : ''}${textBefore}`;
                 }
-                // Add structured ORIGINAL/SUGGESTED format
                 if (codeContent) {
-                    result += `\nORIGINAL:\n\`\`\`\n${codeContent}\n\`\`\``;
+                    result += `${result ? '\n' : ''}ORIGINAL:\n\`\`\`\n${codeContent}\n\`\`\``;
                 }
-                result += `\nSUGGESTED:\n\`\`\`\n${suggestion.suggestedCode}\n\`\`\``;
+                result += `${result ? '\n' : ''}SUGGESTED:\n\`\`\`\n${suggestion.suggestedCode}\n\`\`\``;
                 lastIndex = suggestion.endIndex;
             }
-            // Add remaining text after the last suggestion block
             const textAfter = body.slice(lastIndex).trim();
             if (textAfter) {
-                result += `\n${textAfter}`;
+                result += `${result ? '\n' : ''}${textAfter}`;
             }
             return result;
         }
     }
-    // Regular comment without suggestion
-    return `${filePath}:${lineInfo}\n${body}`;
+    return body;
+}
+function normalizeLegacyComment(comment) {
+    return {
+        id: comment.id,
+        file: comment.file,
+        line: comment.line,
+        side: comment.side,
+        createdAt: comment.timestamp,
+        updatedAt: comment.timestamp,
+        codeContent: comment.codeContent,
+        messages: [
+            {
+                id: comment.id,
+                body: comment.body,
+                author: comment.author,
+                createdAt: comment.timestamp,
+                updatedAt: comment.timestamp,
+            },
+        ],
+    };
+}
+export function formatCommentPrompt(file, line, body, codeContent) {
+    const filePath = file || '<unknown file>';
+    return `${filePath}:${getLineInfo(line)}\n${formatCommentContent(body, codeContent)}`;
 }
 export function formatAllCommentsPrompt(comments) {
     if (comments.length === 0)
@@ -40,13 +58,33 @@ export function formatAllCommentsPrompt(comments) {
     const prompts = comments.map((comment) => formatCommentPrompt(comment.file, comment.line, comment.body, comment.codeContent));
     return prompts.join('\n=====\n');
 }
-export function formatCommentsOutput(comments) {
-    const allPrompts = formatAllCommentsPrompt(comments);
+export function formatCommentThreadPrompt(thread) {
+    const sections = [`${thread.file || '<unknown file>'}:${getLineInfo(thread.line)}`];
+    thread.messages.forEach((message, index) => {
+        if (index === 0) {
+            sections.push(formatCommentContent(message.body, thread.codeContent));
+            return;
+        }
+        const replyIndex = index;
+        const authorLabel = message.author?.trim() || 'Unknown';
+        sections.push(`Reply ${replyIndex} (${authorLabel})`);
+        sections.push(formatCommentContent(message.body, thread.codeContent));
+    });
+    return sections.filter(Boolean).join('\n');
+}
+export function formatAllCommentThreadsPrompt(threads) {
+    if (threads.length === 0)
+        return '';
+    return threads.map((thread) => formatCommentThreadPrompt(thread)).join('\n=====\n');
+}
+export function formatCommentsOutput(input) {
+    const threads = input.map((item) => ('messages' in item ? item : normalizeLegacyComment(item)));
+    const allPrompts = formatAllCommentThreadsPrompt(threads);
     return [
         '\n📝 Comments from review session:',
         '='.repeat(50),
         allPrompts,
         '='.repeat(50),
-        `Total comments: ${comments.length}\n`,
+        `Total comments: ${threads.length}\n`,
     ].join('\n');
 }

package/dist/utils/commentImports.d.ts

@@ -0,0 +1,9 @@
+import type { CommentImport, DiffCommentThread } from '../types/diff.js';
+interface MergeCommentImportsResult {
+    threads: DiffCommentThread[];
+    warnings: string[];
+}
+export declare function parseCommentImportValue(value: string): CommentImport[];
+export declare function serializeCommentImports(commentImports: CommentImport[]): string;
+export declare function mergeCommentImports(existingThreads: DiffCommentThread[], commentImports: CommentImport[]): MergeCommentImportsResult;
+export {};

package/dist/utils/commentImports.js

@@ -0,0 +1,264 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isValidIsoTimestamp(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function normalizeTimestamp(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || value.trim().length === 0 || !isValidIsoTimestamp(value)) {
+        throw new Error(`Invalid comment import field: ${fieldName}`);
+    }
+    return value;
+}
+function normalizeLineRange(value) {
+    if (typeof value === 'number' && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (!isRecord(value)) {
+        throw new Error('Invalid comment import field: position.line');
+    }
+    const start = value.start;
+    const end = value.end;
+    if (typeof start !== 'number' ||
+        typeof end !== 'number' ||
+        !Number.isInteger(start) ||
+        !Number.isInteger(end) ||
+        start <= 0 ||
+        end <= 0 ||
+        start > end) {
+        throw new Error('Invalid comment import field: position.line');
+    }
+    return { start, end };
+}
+function normalizePosition(value) {
+    if (!isRecord(value)) {
+        throw new Error('Invalid comment import field: position');
+    }
+    if (value.side !== 'old' && value.side !== 'new') {
+        throw new Error('Invalid comment import field: position.side');
+    }
+    return {
+        side: value.side,
+        line: normalizeLineRange(value.line),
+    };
+}
+function normalizeCodeSnapshot(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value) || typeof value.content !== 'string') {
+        throw new Error('Invalid comment import field: codeSnapshot');
+    }
+    if (value.language !== undefined && typeof value.language !== 'string') {
+        throw new Error('Invalid comment import field: codeSnapshot.language');
+    }
+    return {
+        content: value.content,
+        language: value.language,
+    };
+}
+function normalizeOptionalString(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid comment import field: ${fieldName}`);
+    }
+    return value;
+}
+function normalizeRequiredBody(value) {
+    if (typeof value !== 'string') {
+        throw new Error('Invalid comment import field: body');
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Invalid comment import field: body');
+    }
+    return trimmed;
+}
+function normalizeCommentImportEntry(value) {
+    if (!isRecord(value)) {
+        throw new Error('Comment import must be an object');
+    }
+    if (value.type !== 'thread' && value.type !== 'reply') {
+        throw new Error('Invalid comment import field: type');
+    }
+    if (typeof value.filePath !== 'string' || value.filePath.trim().length === 0) {
+        throw new Error('Invalid comment import field: filePath');
+    }
+    const createdAt = normalizeTimestamp(value.createdAt, 'createdAt');
+    const updatedAt = normalizeTimestamp(value.updatedAt, 'updatedAt');
+    const normalized = {
+        type: value.type,
+        id: normalizeOptionalString(value.id, 'id'),
+        filePath: value.filePath,
+        position: normalizePosition(value.position),
+        body: normalizeRequiredBody(value.body),
+        author: normalizeOptionalString(value.author, 'author'),
+        createdAt,
+        updatedAt,
+        codeSnapshot: normalizeCodeSnapshot(value.codeSnapshot),
+    };
+    return normalized;
+}
+function normalizeCommentImports(input) {
+    if (Array.isArray(input)) {
+        return input.map((entry) => normalizeCommentImportEntry(entry));
+    }
+    return [normalizeCommentImportEntry(input)];
+}
+export function parseCommentImportValue(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error('Invalid --comment JSON');
+    }
+    return normalizeCommentImports(parsed);
+}
+function getPositionKey(position) {
+    if (typeof position.line === 'number') {
+        return `${position.side}:${position.line}`;
+    }
+    return `${position.side}:${position.line.start}-${position.line.end}`;
+}
+function positionsMatch(left, right) {
+    return getPositionKey(left) === getPositionKey(right);
+}
+function normalizeAuthor(author) {
+    return author?.trim() || '';
+}
+function messageMatchesImport(message, commentImport, includeId = true) {
+    if (includeId && commentImport.id && message.id === commentImport.id) {
+        return true;
+    }
+    if (normalizeAuthor(message.author) !== normalizeAuthor(commentImport.author)) {
+        return false;
+    }
+    if (message.body !== commentImport.body) {
+        return false;
+    }
+    if (commentImport.createdAt && message.createdAt !== commentImport.createdAt) {
+        return false;
+    }
+    return true;
+}
+function rootThreadMatchesImport(thread, commentImport) {
+    if (commentImport.id && thread.id === commentImport.id) {
+        return true;
+    }
+    if (thread.filePath !== commentImport.filePath ||
+        !positionsMatch(thread.position, commentImport.position)) {
+        return false;
+    }
+    const rootMessage = thread.messages[0];
+    if (!rootMessage) {
+        return false;
+    }
+    return messageMatchesImport(rootMessage, commentImport, true);
+}
+function toThreadTimestamp(commentImport, now) {
+    const createdAt = commentImport.createdAt ?? now;
+    const updatedAt = commentImport.updatedAt ?? createdAt;
+    return { createdAt, updatedAt };
+}
+function maxIsoTimestamp(left, right) {
+    return left.localeCompare(right) >= 0 ? left : right;
+}
+function sortByNewestThread(left, right) {
+    return right.updatedAt.localeCompare(left.updatedAt);
+}
+function createImportedThread(commentImport, now) {
+    const { createdAt, updatedAt } = toThreadTimestamp(commentImport, now);
+    const threadId = commentImport.id ?? crypto.randomUUID();
+    return {
+        id: threadId,
+        filePath: commentImport.filePath,
+        createdAt,
+        updatedAt,
+        position: commentImport.position,
+        codeSnapshot: commentImport.codeSnapshot,
+        messages: [
+            {
+                id: commentImport.id ?? threadId,
+                body: commentImport.body,
+                author: commentImport.author,
+                createdAt,
+                updatedAt,
+            },
+        ],
+    };
+}
+function createImportedReply(commentImport, now) {
+    const { createdAt, updatedAt } = toThreadTimestamp(commentImport, now);
+    return {
+        id: commentImport.id ?? crypto.randomUUID(),
+        body: commentImport.body,
+        author: commentImport.author,
+        createdAt,
+        updatedAt,
+    };
+}
+function serializeLineRange(line) {
+    if (typeof line === 'number') {
+        return line;
+    }
+    return { start: line.start, end: line.end };
+}
+export function serializeCommentImports(commentImports) {
+    return JSON.stringify(commentImports.map((commentImport) => ({
+        type: commentImport.type,
+        id: commentImport.id,
+        filePath: commentImport.filePath,
+        position: {
+            side: commentImport.position.side,
+            line: serializeLineRange(commentImport.position.line),
+        },
+        body: commentImport.body,
+        author: commentImport.author,
+        createdAt: commentImport.createdAt,
+        updatedAt: commentImport.updatedAt,
+        codeSnapshot: commentImport.codeSnapshot
+            ? {
+                content: commentImport.codeSnapshot.content,
+                language: commentImport.codeSnapshot.language,
+            }
+            : undefined,
+    })));
+}
+export function mergeCommentImports(existingThreads, commentImports) {
+    const threads = [...existingThreads];
+    const warnings = [];
+    for (const commentImport of commentImports) {
+        const now = new Date().toISOString();
+        if (commentImport.type === 'thread') {
+            const hasDuplicate = threads.some((thread) => rootThreadMatchesImport(thread, commentImport));
+            if (hasDuplicate) {
+                continue;
+            }
+            threads.push(createImportedThread(commentImport, now));
+            continue;
+        }
+        const targetThreads = threads
+            .filter((thread) => thread.filePath === commentImport.filePath &&
+            positionsMatch(thread.position, commentImport.position))
+            .sort(sortByNewestThread);
+        const targetThread = targetThreads[0];
+        if (!targetThread) {
+            warnings.push(`Skipped reply import for ${commentImport.filePath}:${getPositionKey(commentImport.position)} because no matching thread was found.`);
+            continue;
+        }
+        const hasDuplicateReply = targetThread.messages.some((message) => messageMatchesImport(message, commentImport, true));
+        if (hasDuplicateReply) {
+            continue;
+        }
+        const importedReply = createImportedReply(commentImport, now);
+        targetThread.messages = [...targetThread.messages, importedReply];
+        targetThread.updatedAt = maxIsoTimestamp(targetThread.updatedAt, importedReply.updatedAt);
+    }
+    return { threads, warnings };
+}

package/dist/utils/commentImports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/commentImports.test.js

@@ -0,0 +1,197 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mergeCommentImports, parseCommentImportValue, serializeCommentImports, } from './commentImports';
+function createThread({ id, filePath = 'src/example.ts', side = 'new', line = 10, body, updatedAt = '2024-01-01T00:00:00.000Z', }) {
+    return {
+        id,
+        filePath,
+        createdAt: '2024-01-01T00:00:00.000Z',
+        updatedAt,
+        position: {
+            side,
+            line,
+        },
+        messages: [
+            {
+                id,
+                body,
+                author: 'User',
+                createdAt: '2024-01-01T00:00:00.000Z',
+                updatedAt,
+            },
+        ],
+    };
+}
+describe('commentImports', () => {
+    describe('parseCommentImportValue', () => {
+        it('parses a single thread import', () => {
+            const imports = parseCommentImportValue(JSON.stringify({
+                type: 'thread',
+                filePath: 'src/example.ts',
+                position: { side: 'new', line: 10 },
+                body: 'Review comment',
+            }));
+            expect(imports).toEqual([
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Review comment',
+                    id: undefined,
+                    author: undefined,
+                    createdAt: undefined,
+                    updatedAt: undefined,
+                    codeSnapshot: undefined,
+                },
+            ]);
+        });
+        it('parses an array of imports', () => {
+            const imports = parseCommentImportValue(JSON.stringify([
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Root',
+                },
+                {
+                    type: 'reply',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Reply',
+                },
+            ]));
+            expect(imports).toHaveLength(2);
+            expect(imports[0]?.type).toBe('thread');
+            expect(imports[1]?.type).toBe('reply');
+        });
+        it('rejects malformed json', () => {
+            expect(() => parseCommentImportValue('{')).toThrow('Invalid --comment JSON');
+        });
+        it('rejects invalid import shape', () => {
+            expect(() => parseCommentImportValue(JSON.stringify({
+                type: 'thread',
+                filePath: '',
+                position: { side: 'new', line: 0 },
+                body: '',
+            }))).toThrow('Invalid comment import field: filePath');
+        });
+    });
+    describe('serializeCommentImports', () => {
+        it('creates a stable payload string for hashing', () => {
+            const commentImports = [
+                {
+                    type: 'thread',
+                    id: 'thread-1',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: { start: 10, end: 12 } },
+                    body: 'Root',
+                    author: 'AI',
+                    createdAt: '2024-01-01T00:00:00.000Z',
+                    updatedAt: '2024-01-01T00:00:00.000Z',
+                    codeSnapshot: { content: 'const value = 1;' },
+                },
+            ];
+            expect(serializeCommentImports(commentImports)).toBe(JSON.stringify([
+                {
+                    type: 'thread',
+                    id: 'thread-1',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: { start: 10, end: 12 } },
+                    body: 'Root',
+                    author: 'AI',
+                    createdAt: '2024-01-01T00:00:00.000Z',
+                    updatedAt: '2024-01-01T00:00:00.000Z',
+                    codeSnapshot: { content: 'const value = 1;', language: undefined },
+                },
+            ]));
+        });
+    });
+    describe('mergeCommentImports', () => {
+        it('adds a new thread import', () => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2024-02-01T00:00:00.000Z'));
+            const result = mergeCommentImports([], [
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported thread',
+                },
+            ]);
+            expect(result.warnings).toEqual([]);
+            expect(result.threads).toHaveLength(1);
+            expect(result.threads[0]?.messages[0]?.body).toBe('Imported thread');
+            vi.useRealTimers();
+        });
+        it('skips a duplicate thread import with the same root message', () => {
+            const existing = [createThread({ id: 'thread-1', body: 'Imported thread' })];
+            const result = mergeCommentImports(existing, [
+                {
+                    type: 'thread',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported thread',
+                    author: 'User',
+                },
+            ]);
+            expect(result.threads).toHaveLength(1);
+        });
+        it('adds a reply to the newest matching thread', () => {
+            const olderThread = createThread({
+                id: 'thread-1',
+                body: 'Root 1',
+                updatedAt: '2024-01-01T00:00:00.000Z',
+            });
+            const newerThread = createThread({
+                id: 'thread-2',
+                body: 'Root 2',
+                updatedAt: '2024-01-02T00:00:00.000Z',
+            });
+            const result = mergeCommentImports([olderThread, newerThread], [
+                {
+                    type: 'reply',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported reply',
+                    author: 'AI',
+                },
+            ]);
+            expect(result.threads[0]?.messages).toHaveLength(1);
+            expect(result.threads[1]?.messages).toHaveLength(2);
+            expect(result.threads[1]?.messages[1]?.body).toBe('Imported reply');
+        });
+        it('skips a duplicate reply import', () => {
+            const existing = createThread({ id: 'thread-1', body: 'Root' });
+            existing.messages.push({
+                id: 'reply-1',
+                body: 'Imported reply',
+                author: 'AI',
+                createdAt: '2024-01-02T00:00:00.000Z',
+                updatedAt: '2024-01-02T00:00:00.000Z',
+            });
+            const result = mergeCommentImports([existing], [
+                {
+                    type: 'reply',
+                    id: 'reply-1',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported reply',
+                    author: 'AI',
+                },
+            ]);
+            expect(result.threads[0]?.messages).toHaveLength(2);
+        });
+        it('warns and skips reply import when no matching thread exists', () => {
+            const result = mergeCommentImports([], [
+                {
+                    type: 'reply',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported reply',
+                },
+            ]);
+            expect(result.threads).toEqual([]);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain('Skipped reply import');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "difit",
-  "version": "3.1.18",
+  "version": "4.0.1",
   "description": "A lightweight command-line tool that spins up a local web server to display Git commit diffs in a GitHub-like Files changed view",
   "keywords": [
     "cli",

package/dist/client/assets/channel-Ca4c0q8d.js

@@ -1 +0,0 @@
-import{V as a,W as n}from"./mermaid.core-DTPtVBG7.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-VBA2DB6C-CJLw9sK7.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DwKPHpbL.js";import{_ as i}from"./mermaid.core-DTPtVBG7.js";import"./chunk-FMBD7UC4-C0eJ7JsI.js";import"./chunk-JSJVCQXG-QZotPSqo.js";import"./chunk-55IACEB6-PRBuiJg9.js";import"./chunk-KX2RTZJC-B8du3tt8.js";import"./index-mE8CA51x.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/client/assets/classDiagram-v2-RAHNMMFH-CJLw9sK7.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DwKPHpbL.js";import{_ as i}from"./mermaid.core-DTPtVBG7.js";import"./chunk-FMBD7UC4-C0eJ7JsI.js";import"./chunk-JSJVCQXG-QZotPSqo.js";import"./chunk-55IACEB6-PRBuiJg9.js";import"./chunk-KX2RTZJC-B8du3tt8.js";import"./index-mE8CA51x.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/client/assets/clone-D0mDLEir.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-DivSZEOF.js";var e=4;function a(o){return r(o,e)}export{a as c};