difit 2.2.0 → 2.2.2

package/dist/server/server.js

@@ -4,6 +4,7 @@ import express from 'express';
 import open from 'open';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+import { formatCommentsOutput } from '../utils/commentFormatting.js';
 import { getFileExtension } from '../utils/fileUtils.js';
 import { FileWatcherService } from './file-watcher.js';
 import { GitDiffParser } from './git-diff.js';
@@ -124,19 +125,6 @@ export async function startServer(options) {
             res.send('');
         }
     });
-    // Function to format comments for output
-    function formatCommentsOutput(comments) {
-        const prompts = comments.map((comment) => {
-            return `${comment.file}:${Array.isArray(comment.line) ? `L${comment.line[0]}-L${comment.line[1]}` : `L${comment.line}`}\n${comment.body}`;
-        });
-        return [
-            '\n📝 Comments from review session:',
-            '='.repeat(50),
-            prompts.join('\n=====\n'),
-            '='.repeat(50),
-            `Total comments: ${comments.length}\n`,
-        ].join('\n');
-    }
     // Function to output comments when server shuts down
     function outputFinalComments() {
         if (finalComments.length > 0) {

package/dist/server/server.test.js

@@ -5,6 +5,23 @@ import { startServer } from './server.js';
 // Add fetch polyfill for Node.js test environment
 const { fetch } = await import('undici');
 globalThis.fetch = fetch;
+// Helper function to get available port
+async function getAvailablePort(preferredPort) {
+    let port = preferredPort;
+    const maxAttempts = 10;
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            await fetch(`http://localhost:${port}`);
+            // If we get here, port is in use, try next one
+            port++;
+        }
+        catch {
+            // Port is available
+            return port;
+        }
+    }
+    return port;
+}
 // Mock GitDiffParser
 vi.mock('./git-diff.js', () => ({
     GitDiffParser: vi.fn().mockImplementation(() => ({
@@ -29,6 +46,92 @@ vi.mock('./git-diff.js', () => ({
     })),
 }));
 describe('Server Integration Tests', () => {
+    describe('Comments API', () => {
+        it('should accept properly formatted comments', async () => {
+            const port = await getAvailablePort(4966);
+            const result = await startServer({
+                preferredPort: port,
+                openBrowser: false,
+            });
+            try {
+                const comments = [
+                    {
+                        id: '1',
+                        file: 'src/App.tsx',
+                        line: 10,
+                        body: 'Test comment',
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                    {
+                        id: '2',
+                        file: 'src/utils/helper.ts',
+                        line: [20, 30],
+                        body: 'Another comment',
+                        timestamp: '2024-01-01T00:01:00Z',
+                    },
+                ];
+                const response = await fetch(`http://localhost:${result.port}/api/comments`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ comments }),
+                });
+                expect(response.status).toBe(200);
+                const apiResult = await response.json();
+                expect(apiResult).toEqual({ success: true });
+                // Verify the formatted output
+                const outputResponse = await fetch(`http://localhost:${result.port}/api/comments-output`);
+                const output = await outputResponse.text();
+                expect(output).toContain('src/App.tsx:L10');
+                expect(output).toContain('Test comment');
+                expect(output).toContain('src/utils/helper.ts:L20-L30');
+                expect(output).toContain('Another comment');
+                expect(output).not.toContain('undefined');
+            }
+            finally {
+                if (result.server) {
+                    await new Promise((resolve) => {
+                        result.server.close(() => resolve());
+                    });
+                }
+            }
+        });
+        it('should handle comments with missing file property gracefully', async () => {
+            const port = await getAvailablePort(4966);
+            const result = await startServer({
+                preferredPort: port,
+                openBrowser: false,
+            });
+            try {
+                const commentsWithMissingFile = [
+                    {
+                        id: '1',
+                        // file property is missing/undefined
+                        line: 10,
+                        body: 'Comment without file',
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ];
+                const response = await fetch(`http://localhost:${result.port}/api/comments`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ comments: commentsWithMissingFile }),
+                });
+                expect(response.status).toBe(200);
+                // Check the output handles undefined file gracefully
+                const outputResponse = await fetch(`http://localhost:${result.port}/api/comments-output`);
+                const output = await outputResponse.text();
+                expect(output).toContain('<unknown file>:L10');
+                expect(output).toContain('Comment without file');
+            }
+            finally {
+                if (result.server) {
+                    await new Promise((resolve) => {
+                        result.server.close(() => resolve());
+                    });
+                }
+            }
+        });
+    });
     let servers = [];
     let originalProcessExit;
     beforeEach(() => {

package/dist/utils/commentFormatter.d.ts

@@ -0,0 +1,26 @@
+import { type Comment, type LineNumber } from '../types/diff';
+/**
+ * Formats a line number or range for display
+ * @param line - Single line number or line range
+ * @returns Formatted string like "L10" or "L10-L20", or empty string if line is undefined
+ */
+export declare function formatLineNumber(line: LineNumber | undefined): string;
+/**
+ * Formats a single comment for prompt output
+ * @param comment - The comment to format
+ * @returns Formatted string like "file.ts:L10\nComment body"
+ */
+export declare function formatCommentPrompt(comment: Comment): string;
+/**
+ * Formats multiple comments for batch output
+ * @param comments - Array of comments to format
+ * @param separator - Separator between comments (default: "=====")
+ * @returns Formatted string with all comments separated
+ */
+export declare function formatCommentsPrompt(comments: Comment[], separator?: string): string;
+/**
+ * Formats comments for server output with decorative elements
+ * @param comments - Array of comments to format
+ * @returns Formatted string with header and footer
+ */
+export declare function formatCommentsOutput(comments: Comment[]): string;

package/dist/utils/commentFormatter.js

@@ -0,0 +1,50 @@
+/**
+ * Formats a line number or range for display
+ * @param line - Single line number or line range
+ * @returns Formatted string like "L10" or "L10-L20", or empty string if line is undefined
+ */
+export function formatLineNumber(line) {
+    if (!line)
+        return '';
+    if (Array.isArray(line)) {
+        return `L${line[0]}-L${line[1]}`;
+    }
+    return `L${line}`;
+}
+/**
+ * Formats a single comment for prompt output
+ * @param comment - The comment to format
+ * @returns Formatted string like "file.ts:L10\nComment body"
+ */
+export function formatCommentPrompt(comment) {
+    const lineDisplay = formatLineNumber(comment.line);
+    const location = lineDisplay ? `${comment.file}:${lineDisplay}` : comment.file;
+    return `${location}\n${comment.body}`;
+}
+/**
+ * Formats multiple comments for batch output
+ * @param comments - Array of comments to format
+ * @param separator - Separator between comments (default: "=====")
+ * @returns Formatted string with all comments separated
+ */
+export function formatCommentsPrompt(comments, separator = '=====') {
+    if (comments.length === 0) {
+        return 'No comments available.';
+    }
+    return comments.map(formatCommentPrompt).join(`\n${separator}\n`);
+}
+/**
+ * Formats comments for server output with decorative elements
+ * @param comments - Array of comments to format
+ * @returns Formatted string with header and footer
+ */
+export function formatCommentsOutput(comments) {
+    const prompts = formatCommentsPrompt(comments);
+    return [
+        '\n📝 Comments from review session:',
+        '='.repeat(50),
+        prompts,
+        '='.repeat(50),
+        `Total comments: ${comments.length}\n`,
+    ].join('\n');
+}

package/dist/utils/commentFormatting.d.ts

@@ -0,0 +1,4 @@
+import type { Comment } from '../types/diff';
+export declare function formatCommentPrompt(file: string, line: number | number[], body: string): string;
+export declare function formatAllCommentsPrompt(comments: Comment[]): string;
+export declare function formatCommentsOutput(comments: Comment[]): string;

package/dist/utils/commentFormatting.js

@@ -0,0 +1,24 @@
+export function formatCommentPrompt(file, line, body) {
+    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>';
+    return `${filePath}:${lineInfo}\n${body}`;
+}
+export function formatAllCommentsPrompt(comments) {
+    if (comments.length === 0)
+        return '';
+    const prompts = comments.map((comment) => formatCommentPrompt(comment.file, comment.line, comment.body));
+    return prompts.join('\n=====\n');
+}
+export function formatCommentsOutput(comments) {
+    const allPrompts = formatAllCommentsPrompt(comments);
+    return [
+        '\n📝 Comments from review session:',
+        '='.repeat(50),
+        allPrompts,
+        '='.repeat(50),
+        `Total comments: ${comments.length}\n`,
+    ].join('\n');
+}

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

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

package/dist/utils/commentFormatting.test.js

@@ -0,0 +1,220 @@
+import { describe, it, expect } from 'vitest';
+import { formatCommentPrompt, formatAllCommentsPrompt, formatCommentsOutput, } from './commentFormatting';
+describe('commentFormatting', () => {
+    describe('formatCommentPrompt', () => {
+        it('should format single line number correctly', () => {
+            const result = formatCommentPrompt('src/components/Button.tsx', 42, 'Fix accessibility');
+            expect(result).toBe('src/components/Button.tsx:L42\nFix accessibility');
+        });
+        it('should format line range correctly', () => {
+            const result = formatCommentPrompt('src/utils/validation.ts', [100, 120], 'Extract validation logic');
+            expect(result).toBe('src/utils/validation.ts:L100-L120\nExtract validation logic');
+        });
+        it('should handle line range as array correctly', () => {
+            const result = formatCommentPrompt('src/api/client.ts', [75, 80], 'Add retry logic');
+            expect(result).toBe('src/api/client.ts:L75-L80\nAdd retry logic');
+        });
+        it('should handle multi-line comment body', () => {
+            const body = 'This is a comment\nwith multiple lines\nof text';
+            const result = formatCommentPrompt('src/index.ts', 10, body);
+            expect(result).toBe('src/index.ts:L10\nThis is a comment\nwith multiple lines\nof text');
+        });
+        it('should handle file paths with special characters', () => {
+            const result = formatCommentPrompt('src/components/@shared/Button.tsx', 15, 'Update styles');
+            expect(result).toBe('src/components/@shared/Button.tsx:L15\nUpdate styles');
+        });
+        it('should handle undefined file path gracefully', () => {
+            const result = formatCommentPrompt(undefined, 10, 'Comment body');
+            expect(result).toBe('<unknown file>:L10\nComment body');
+        });
+        it('should handle null file path gracefully', () => {
+            const result = formatCommentPrompt(null, 10, 'Comment body');
+            expect(result).toBe('<unknown file>:L10\nComment body');
+        });
+        it('should handle empty string file path', () => {
+            const result = formatCommentPrompt('', 10, 'Comment body');
+            expect(result).toBe('<unknown file>:L10\nComment body');
+        });
+    });
+    describe('formatAllCommentsPrompt', () => {
+        it('should return empty string for empty comments array', () => {
+            const result = formatAllCommentsPrompt([]);
+            expect(result).toBe('');
+        });
+        it('should format single comment without separator', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/App.tsx',
+                    line: 10,
+                    body: 'Single comment',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ];
+            const result = formatAllCommentsPrompt(comments);
+            expect(result).toBe('src/App.tsx:L10\nSingle comment');
+        });
+        it('should format multiple comments with separator', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/App.tsx',
+                    line: 10,
+                    body: 'First comment',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+                {
+                    id: '2',
+                    file: 'src/utils/helper.ts',
+                    line: [20, 25],
+                    body: 'Second comment',
+                    timestamp: '2024-01-01T00:01:00Z',
+                },
+            ];
+            const result = formatAllCommentsPrompt(comments);
+            expect(result).toBe('src/App.tsx:L10\nFirst comment\n=====\nsrc/utils/helper.ts:L20-L25\nSecond comment');
+        });
+        it('should handle comments with line ranges', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/components/Form.tsx',
+                    line: [50, 75],
+                    body: 'Refactor form validation',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+                {
+                    id: '2',
+                    file: 'src/api/endpoints.ts',
+                    line: [100, 150],
+                    body: 'Add error handling',
+                    timestamp: '2024-01-01T00:01:00Z',
+                },
+            ];
+            const result = formatAllCommentsPrompt(comments);
+            expect(result).toBe('src/components/Form.tsx:L50-L75\nRefactor form validation\n=====\nsrc/api/endpoints.ts:L100-L150\nAdd error handling');
+        });
+        it('should preserve comment order', () => {
+            const comments = [
+                {
+                    id: '3',
+                    file: 'third.ts',
+                    line: 30,
+                    body: 'Third',
+                    timestamp: '2024-01-01T00:02:00Z',
+                },
+                {
+                    id: '1',
+                    file: 'first.ts',
+                    line: 10,
+                    body: 'First',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+                {
+                    id: '2',
+                    file: 'second.ts',
+                    line: 20,
+                    body: 'Second',
+                    timestamp: '2024-01-01T00:01:00Z',
+                },
+            ];
+            const result = formatAllCommentsPrompt(comments);
+            expect(result).toBe('third.ts:L30\nThird\n=====\nfirst.ts:L10\nFirst\n=====\nsecond.ts:L20\nSecond');
+        });
+    });
+    describe('formatCommentsOutput', () => {
+        it('should format empty comments with header and footer', () => {
+            const result = formatCommentsOutput([]);
+            const lines = result.split('\n');
+            expect(lines[0]).toBe('');
+            expect(lines[1]).toBe('📝 Comments from review session:');
+            expect(lines[2]).toBe('='.repeat(50));
+            expect(lines[3]).toBe('');
+            expect(lines[4]).toBe('='.repeat(50));
+            expect(lines[5]).toBe('Total comments: 0');
+        });
+        it('should format single comment with header and footer', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/App.tsx',
+                    line: 10,
+                    body: 'Fix this issue',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ];
+            const result = formatCommentsOutput(comments);
+            expect(result).toContain('📝 Comments from review session:');
+            expect(result).toContain('src/App.tsx:L10\nFix this issue');
+            expect(result).toContain('Total comments: 1');
+            expect(result).toContain('='.repeat(50));
+        });
+        it('should format multiple comments with separators', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/App.tsx',
+                    line: 10,
+                    body: 'First issue',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+                {
+                    id: '2',
+                    file: 'src/utils/helper.ts',
+                    line: [20, 30],
+                    body: 'Second issue',
+                    timestamp: '2024-01-01T00:01:00Z',
+                },
+                {
+                    id: '3',
+                    file: 'src/components/Button.tsx',
+                    line: 42,
+                    body: 'Third issue',
+                    timestamp: '2024-01-01T00:02:00Z',
+                },
+            ];
+            const result = formatCommentsOutput(comments);
+            expect(result).toContain('📝 Comments from review session:');
+            expect(result).toContain('src/App.tsx:L10\nFirst issue');
+            expect(result).toContain('=====');
+            expect(result).toContain('src/utils/helper.ts:L20-L30\nSecond issue');
+            expect(result).toContain('src/components/Button.tsx:L42\nThird issue');
+            expect(result).toContain('Total comments: 3');
+        });
+        it('should handle comments with multi-line bodies', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'src/complex.ts',
+                    line: [100, 200],
+                    body: 'This is a complex issue that\nspans multiple lines\nand needs attention',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ];
+            const result = formatCommentsOutput(comments);
+            expect(result).toContain('src/complex.ts:L100-L200');
+            expect(result).toContain('This is a complex issue that\nspans multiple lines\nand needs attention');
+            expect(result).toContain('Total comments: 1');
+        });
+        it('should format output with correct structure', () => {
+            const comments = [
+                {
+                    id: '1',
+                    file: 'test.ts',
+                    line: 1,
+                    body: 'Test comment',
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ];
+            const result = formatCommentsOutput(comments);
+            const lines = result.split('\n');
+            expect(lines[0]).toBe('');
+            expect(lines[1]).toBe('📝 Comments from review session:');
+            expect(lines[2]).toBe('='.repeat(50));
+            expect(lines[3]).toBe('test.ts:L1');
+            expect(lines[4]).toBe('Test comment');
+            expect(lines[5]).toBe('='.repeat(50));
+            expect(lines[6]).toBe('Total comments: 1');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "difit",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "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",
   "type": "module",
   "engines": {
@@ -54,8 +54,7 @@
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-hotkeys-hook": "^5.1.0",
-    "simple-git": "^3.28.0",
-    "uuid": "^11.1.0"
+    "simple-git": "^3.28.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",
@@ -72,7 +71,6 @@
     "@types/prismjs": "^1.26.5",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
-    "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^8.35.1",
     "@typescript-eslint/parser": "^8.35.1",
     "@vitejs/plugin-react": "^4.6.0",
@@ -86,6 +84,7 @@
     "globals": "^16.3.0",
     "happy-dom": "^18.0.1",
     "lefthook": "^1.11.14",
+    "mri": "^1.2.0",
     "playwright": "^1.54.1",
     "postcss": "^8.5.6",
     "prettier": "^3.6.2",