difit 2.2.1 → 2.2.3

package/dist/server/schemas/commentSchema.test.js

@@ -1,229 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CommentSchema, CommentsPayloadSchema, LineNumberSchema } from './commentSchema';
-describe('Comment Schema Validation', () => {
-    describe('LineNumberSchema', () => {
-        it('should accept single number', () => {
-            const result = LineNumberSchema.safeParse(42);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toBe(42);
-            }
-        });
-        it('should accept tuple of two numbers', () => {
-            const result = LineNumberSchema.safeParse([10, 20]);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual([10, 20]);
-            }
-        });
-        it('should reject string', () => {
-            const result = LineNumberSchema.safeParse('42');
-            expect(result.success).toBe(false);
-        });
-        it('should reject array with more than 2 numbers', () => {
-            const result = LineNumberSchema.safeParse([1, 2, 3]);
-            expect(result.success).toBe(false);
-        });
-        it('should reject array with less than 2 numbers', () => {
-            const result = LineNumberSchema.safeParse([1]);
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('CommentSchema', () => {
-        it('should accept valid comment with single line number', () => {
-            const comment = {
-                id: '123',
-                file: 'src/app.ts',
-                line: 42,
-                body: 'Test comment',
-                timestamp: '2024-01-01T00:00:00Z',
-            };
-            const result = CommentSchema.safeParse(comment);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual(comment);
-            }
-        });
-        it('should accept valid comment with line range', () => {
-            const comment = {
-                id: '456',
-                file: 'src/utils.ts',
-                line: [10, 20],
-                body: 'Range comment',
-                timestamp: '2024-01-01T00:00:00Z',
-            };
-            const result = CommentSchema.safeParse(comment);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data).toEqual(comment);
-            }
-        });
-        it('should accept comment with optional codeContent', () => {
-            const comment = {
-                id: '789',
-                file: 'src/index.ts',
-                line: 1,
-                body: 'Comment with code',
-                timestamp: '2024-01-01T00:00:00Z',
-                codeContent: 'const x = 42;',
-            };
-            const result = CommentSchema.safeParse(comment);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.codeContent).toBe('const x = 42;');
-            }
-        });
-        it('should reject comment without required fields', () => {
-            const invalidComment = {
-                id: '123',
-                // missing file
-                line: 42,
-                body: 'Test',
-                timestamp: '2024-01-01T00:00:00Z',
-            };
-            const result = CommentSchema.safeParse(invalidComment);
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0]?.path).toContain('file');
-            }
-        });
-        it('should reject comment with wrong type for file', () => {
-            const invalidComment = {
-                id: '123',
-                file: 123, // should be string
-                line: 42,
-                body: 'Test',
-                timestamp: '2024-01-01T00:00:00Z',
-            };
-            const result = CommentSchema.safeParse(invalidComment);
-            expect(result.success).toBe(false);
-        });
-        it('should reject comment with invalid line format', () => {
-            const invalidComment = {
-                id: '123',
-                file: 'test.ts',
-                line: 'invalid', // should be number or [number, number]
-                body: 'Test',
-                timestamp: '2024-01-01T00:00:00Z',
-            };
-            const result = CommentSchema.safeParse(invalidComment);
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('CommentsPayloadSchema', () => {
-        it('should accept valid payload with comments array', () => {
-            const payload = {
-                comments: [
-                    {
-                        id: '1',
-                        file: 'file1.ts',
-                        line: 10,
-                        body: 'Comment 1',
-                        timestamp: '2024-01-01T00:00:00Z',
-                    },
-                    {
-                        id: '2',
-                        file: 'file2.ts',
-                        line: [20, 30],
-                        body: 'Comment 2',
-                        timestamp: '2024-01-01T00:01:00Z',
-                    },
-                ],
-            };
-            const result = CommentsPayloadSchema.safeParse(payload);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.comments).toHaveLength(2);
-            }
-        });
-        it('should accept empty comments array', () => {
-            const payload = { comments: [] };
-            const result = CommentsPayloadSchema.safeParse(payload);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.comments).toEqual([]);
-            }
-        });
-        it('should accept payload without comments property', () => {
-            const payload = {};
-            const result = CommentsPayloadSchema.safeParse(payload);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.comments).toBeUndefined();
-            }
-        });
-        it('should reject payload with invalid comment in array', () => {
-            const payload = {
-                comments: [
-                    {
-                        id: '1',
-                        file: 'file1.ts',
-                        line: 10,
-                        body: 'Valid comment',
-                        timestamp: '2024-01-01T00:00:00Z',
-                    },
-                    {
-                        id: '2',
-                        // missing file property
-                        line: 20,
-                        body: 'Invalid comment',
-                        timestamp: '2024-01-01T00:01:00Z',
-                    },
-                ],
-            };
-            const result = CommentsPayloadSchema.safeParse(payload);
-            expect(result.success).toBe(false);
-        });
-        it('should reject payload with comments as non-array', () => {
-            const payload = {
-                comments: 'not an array',
-            };
-            const result = CommentsPayloadSchema.safeParse(payload);
-            expect(result.success).toBe(false);
-        });
-        it('should handle real-world DiffComment format from client', () => {
-            // This simulates the actual DiffComment format sent from client
-            const diffCommentPayload = {
-                comments: [
-                    {
-                        id: 'abc123',
-                        filePath: 'src/components/Button.tsx', // Note: 'filePath' instead of 'file'
-                        position: {
-                            line: 42,
-                            side: 'new',
-                        },
-                        body: 'Fix this button',
-                        createdAt: '2024-01-01T00:00:00Z',
-                    },
-                ],
-            };
-            const result = CommentsPayloadSchema.safeParse(diffCommentPayload);
-            expect(result.success).toBe(false); // Should fail because of incorrect property names
-            if (!result.success) {
-                // Check that it fails because 'file' is missing
-                const fileIssue = result.error.issues.find((issue) => issue.path.includes('file'));
-                expect(fileIssue).toBeDefined();
-            }
-        });
-        it('should accept properly transformed comments from client', () => {
-            // This is what the client should send after transformation
-            const transformedPayload = {
-                comments: [
-                    {
-                        id: 'abc123',
-                        file: 'src/components/Button.tsx', // Correct property name
-                        line: 42, // Extracted from position.line
-                        body: 'Fix this button',
-                        timestamp: '2024-01-01T00:00:00Z', // Renamed from createdAt
-                    },
-                ],
-            };
-            const result = CommentsPayloadSchema.safeParse(transformedPayload);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.comments).toHaveLength(1);
-                expect(result.data.comments[0].file).toBe('src/components/Button.tsx');
-            }
-        });
-    });
-});

package/dist/utils/commentFormatter.d.ts

@@ -1,26 +0,0 @@
-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

@@ -1,50 +0,0 @@
-/**
- * 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/gitUtils.d.ts

@@ -1,4 +0,0 @@
-import type { SimpleGit } from 'simple-git';
-export declare function shortHash(hash: string): string;
-export declare function createCommitRangeString(baseHash: string, targetHash: string): string;
-export declare function resolveCommitDisplayString(baseCommitish: string, targetCommitish: string, git: SimpleGit): Promise<string>;

package/dist/utils/gitUtils.js

@@ -1,29 +0,0 @@
-export function shortHash(hash) {
-    return hash.substring(0, 7);
-}
-export function createCommitRangeString(baseHash, targetHash) {
-    return `${baseHash}...${targetHash}`;
-}
-export async function resolveCommitDisplayString(baseCommitish, targetCommitish, git) {
-    // Handle target special chars (base is always a regular commit)
-    if (targetCommitish === 'working') {
-        // Show unstaged changes (working vs staged)
-        return 'Working Directory (unstaged changes)';
-    }
-    else if (targetCommitish === 'staged') {
-        // Show staged changes against base commit
-        const baseHash = await git.revparse([baseCommitish]);
-        return `${shortHash(baseHash)} vs Staging Area (staged changes)`;
-    }
-    else if (targetCommitish === '.') {
-        // Show all uncommitted changes against base commit
-        const baseHash = await git.revparse([baseCommitish]);
-        return `${shortHash(baseHash)} vs Working Directory (all uncommitted changes)`;
-    }
-    else {
-        // Both are regular commits: standard commit-to-commit comparison
-        const targetHash = await git.revparse([targetCommitish]);
-        const baseHash = await git.revparse([baseCommitish]);
-        return createCommitRangeString(shortHash(baseHash), shortHash(targetHash));
-    }
-}

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

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

package/dist/utils/gitUtils.test.js

@@ -1,63 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { shortHash, createCommitRangeString, resolveCommitDisplayString } from './gitUtils';
-describe('Git Utils', () => {
-    describe('shortHash', () => {
-        it('should return first 7 characters of hash', () => {
-            expect(shortHash('a1b2c3d4e5f6789012345678901234567890abcd')).toBe('a1b2c3d');
-            expect(shortHash('1234567890abcdef')).toBe('1234567');
-            expect(shortHash('abc123')).toBe('abc123');
-        });
-        it('should handle short hashes', () => {
-            expect(shortHash('abc')).toBe('abc');
-            expect(shortHash('')).toBe('');
-            expect(shortHash('a')).toBe('a');
-        });
-    });
-    describe('createCommitRangeString', () => {
-        it('should create commit range string with triple dots', () => {
-            expect(createCommitRangeString('abc1234', 'def5678')).toBe('abc1234...def5678');
-            expect(createCommitRangeString('a1b2c3d', '4e5f6g7')).toBe('a1b2c3d...4e5f6g7');
-        });
-        it('should handle empty strings', () => {
-            expect(createCommitRangeString('', '')).toBe('...');
-            expect(createCommitRangeString('abc123', '')).toBe('abc123...');
-            expect(createCommitRangeString('', 'def456')).toBe('...def456');
-        });
-    });
-    describe('resolveCommitDisplayString', () => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const mockGit = {
-            revparse: vi.fn(),
-        };
-        beforeEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should handle working directory target', async () => {
-            const result = await resolveCommitDisplayString('main', 'working', mockGit);
-            expect(result).toBe('Working Directory (unstaged changes)');
-            expect(mockGit.revparse).not.toHaveBeenCalled();
-        });
-        it('should handle staged target', async () => {
-            mockGit.revparse.mockResolvedValue('a1b2c3d4e5f6789012345678901234567890abcd');
-            const result = await resolveCommitDisplayString('main', 'staged', mockGit);
-            expect(result).toBe('a1b2c3d vs Staging Area (staged changes)');
-            expect(mockGit.revparse).toHaveBeenCalledWith(['main']);
-        });
-        it('should handle dot (.) target', async () => {
-            mockGit.revparse.mockResolvedValue('a1b2c3d4e5f6789012345678901234567890abcd');
-            const result = await resolveCommitDisplayString('main', '.', mockGit);
-            expect(result).toBe('a1b2c3d vs Working Directory (all uncommitted changes)');
-            expect(mockGit.revparse).toHaveBeenCalledWith(['main']);
-        });
-        it('should handle regular commit to commit comparison', async () => {
-            mockGit.revparse
-                .mockResolvedValueOnce('def4567890abcdef1234567890abcdef12345678') // target (called first)
-                .mockResolvedValueOnce('a1b2c3d4e5f6789012345678901234567890abcd'); // base (called second)
-            const result = await resolveCommitDisplayString('main', 'develop', mockGit);
-            expect(result).toBe('a1b2c3d...def4567');
-            expect(mockGit.revparse).toHaveBeenCalledWith(['develop']);
-            expect(mockGit.revparse).toHaveBeenCalledWith(['main']);
-            expect(mockGit.revparse).toHaveBeenCalledTimes(2);
-        });
-    });
-});