difit 0.0.1

package/dist/server/git-diff.test.js

@@ -0,0 +1,292 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { GitDiffParser } from './git-diff';
+// Mock simple-git
+vi.mock('simple-git', () => ({
+    simpleGit: vi.fn(() => ({
+        revparse: vi.fn(),
+        diffSummary: vi.fn(),
+        diff: vi.fn(),
+    })),
+}));
+// Mock child_process
+vi.mock('child_process', async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        execSync: vi.fn(),
+        execFileSync: vi.fn(),
+    };
+});
+// Mock fs
+vi.mock('fs', async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        readFileSync: vi.fn(),
+    };
+});
+describe('GitDiffParser', () => {
+    let parser;
+    let mockExecFileSync;
+    let mockReadFileSync;
+    beforeEach(async () => {
+        parser = new GitDiffParser('/test/repo');
+        vi.clearAllMocks();
+        // Get mocked functions
+        const childProcess = await import('child_process');
+        const fs = await import('fs');
+        mockExecFileSync = childProcess.execFileSync;
+        mockReadFileSync = fs.readFileSync;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('getBlobContent', () => {
+        it('reads from filesystem for working directory', async () => {
+            const mockBuffer = Buffer.from('test content');
+            mockReadFileSync.mockReturnValue(mockBuffer);
+            const result = await parser.getBlobContent('test.txt', 'working');
+            expect(mockReadFileSync).toHaveBeenCalledWith('test.txt');
+            expect(result).toBe(mockBuffer);
+        });
+        it('reads from filesystem for "." ref', async () => {
+            const mockBuffer = Buffer.from('test content');
+            mockReadFileSync.mockReturnValue(mockBuffer);
+            const result = await parser.getBlobContent('test.txt', '.');
+            expect(mockReadFileSync).toHaveBeenCalledWith('test.txt');
+            expect(result).toBe(mockBuffer);
+        });
+        it('uses git show for staged files', async () => {
+            const mockBuffer = Buffer.from('staged content');
+            mockExecFileSync.mockReturnValue(mockBuffer);
+            const result = await parser.getBlobContent('test.txt', 'staged');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', ['show', ':test.txt'], {
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            expect(result).toBe(mockBuffer);
+        });
+        it('uses git cat-file for git refs', async () => {
+            const blobHash = 'abc123def456';
+            const mockBuffer = Buffer.from('git content');
+            mockExecFileSync
+                .mockReturnValueOnce(blobHash + '\n') // First call for rev-parse
+                .mockReturnValueOnce(mockBuffer); // Second call for cat-file
+            const result = await parser.getBlobContent('test.txt', 'HEAD');
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', ['rev-parse', 'HEAD:test.txt'], {
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            expect(mockExecFileSync).toHaveBeenCalledWith('git', ['cat-file', 'blob', blobHash], {
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            expect(result).toBe(mockBuffer);
+        });
+        it('handles file size limit errors', async () => {
+            const error = new Error('maxBuffer exceeded');
+            mockExecFileSync.mockImplementation(() => {
+                throw error;
+            });
+            await expect(parser.getBlobContent('large-file.jpg', 'HEAD')).rejects.toThrow('Image file large-file.jpg is too large to display (over 10MB limit)');
+        });
+        it('handles ENOBUFS errors', async () => {
+            const error = new Error('ENOBUFS: buffer overflow');
+            mockExecFileSync.mockImplementation(() => {
+                throw error;
+            });
+            await expect(parser.getBlobContent('large-file.jpg', 'HEAD')).rejects.toThrow('Image file large-file.jpg is too large to display (over 10MB limit)');
+        });
+        it('handles general git errors', async () => {
+            const error = new Error('fatal: Path does not exist');
+            mockExecFileSync.mockImplementation(() => {
+                throw error;
+            });
+            await expect(parser.getBlobContent('missing.txt', 'HEAD')).rejects.toThrow('Failed to get blob content for missing.txt at HEAD: fatal: Path does not exist');
+        });
+    });
+    describe('parseFileBlock with binary files', () => {
+        it('parses added binary file correctly', () => {
+            const diffLines = [
+                'diff --git a/image.jpg b/image.jpg',
+                'new file mode 100644',
+                'index 0000000..abc123',
+                '--- /dev/null',
+                '+++ b/image.jpg',
+                'Binary files /dev/null and b/image.jpg differ',
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 0,
+            };
+            // Access private method for testing
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toEqual({
+                path: 'image.jpg',
+                oldPath: undefined,
+                status: 'added',
+                additions: 0,
+                deletions: 0,
+                chunks: [], // Binary files should have empty chunks
+            });
+        });
+        it('parses deleted binary file correctly', () => {
+            const diffLines = [
+                'diff --git a/old-image.png b/old-image.png',
+                'deleted file mode 100644',
+                'index abc123..0000000',
+                '--- a/old-image.png',
+                '+++ /dev/null',
+                'Binary files a/old-image.png and /dev/null differ',
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toEqual({
+                path: 'old-image.png',
+                oldPath: undefined,
+                status: 'deleted',
+                additions: 0,
+                deletions: 0,
+                chunks: [],
+            });
+        });
+        it('parses modified binary file correctly', () => {
+            const diffLines = [
+                'diff --git a/photo.jpg b/photo.jpg',
+                'index abc123..def456 100644',
+                '--- a/photo.jpg',
+                '+++ b/photo.jpg',
+                'Binary files a/photo.jpg and b/photo.jpg differ',
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toEqual({
+                path: 'photo.jpg',
+                oldPath: undefined,
+                status: 'modified',
+                additions: 0,
+                deletions: 0,
+                chunks: [],
+            });
+        });
+        it('parses renamed binary file correctly', () => {
+            const diffLines = [
+                'diff --git a/old-name.gif b/new-name.gif',
+                'similarity index 100%',
+                'rename from old-name.gif',
+                'rename to new-name.gif',
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toEqual({
+                path: 'new-name.gif',
+                oldPath: 'old-name.gif',
+                status: 'renamed',
+                additions: 0,
+                deletions: 0,
+                chunks: [],
+            });
+        });
+        it('handles non-binary files normally', () => {
+            const diffLines = [
+                'diff --git a/script.js b/script.js',
+                'index abc123..def456 100644',
+                '--- a/script.js',
+                '+++ b/script.js',
+                '@@ -1,3 +1,4 @@',
+                ' console.log("hello");',
+                '+console.log("world");',
+                ' // end',
+            ];
+            const summary = {
+                insertions: 1,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result).toEqual({
+                path: 'script.js',
+                oldPath: undefined,
+                status: 'added',
+                additions: 1,
+                deletions: 0,
+                chunks: expect.any(Array), // Should have parsed chunks
+            });
+            // Verify chunks were parsed
+            expect(result.chunks).toHaveLength(1);
+            expect(result.chunks[0].header).toBe('@@ -1,3 +1,4 @@');
+        });
+        it('detects added files using /dev/null indicator', () => {
+            const diffLines = [
+                'diff --git a/new-file.txt b/new-file.txt',
+                'index 0000000..abc123 100644',
+                '--- /dev/null',
+                '+++ b/new-file.txt',
+                '@@ -0,0 +1,2 @@',
+                '+line 1',
+                '+line 2',
+            ];
+            const summary = {
+                insertions: 2,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result.status).toBe('added');
+        });
+        it('detects deleted files using /dev/null indicator', () => {
+            const diffLines = [
+                'diff --git a/deleted-file.txt b/deleted-file.txt',
+                'index abc123..0000000 100644',
+                '--- a/deleted-file.txt',
+                '+++ /dev/null',
+                '@@ -1,2 +0,0 @@',
+                '-line 1',
+                '-line 2',
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 2,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result.status).toBe('deleted');
+        });
+    });
+    describe('File status detection improvements', () => {
+        it('prioritizes new file mode over other indicators', () => {
+            const diffLines = [
+                'diff --git a/test.txt b/test.txt',
+                'new file mode 100644',
+                'index 0000000..abc123',
+                '--- a/test.txt', // This might confuse simple parsers
+                '+++ b/test.txt',
+            ];
+            const summary = {
+                insertions: 5,
+                deletions: 0,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result.status).toBe('added');
+        });
+        it('prioritizes deleted file mode over other indicators', () => {
+            const diffLines = [
+                'diff --git a/test.txt b/test.txt',
+                'deleted file mode 100644',
+                'index abc123..0000000',
+                '--- a/test.txt',
+                '+++ b/test.txt', // This might confuse simple parsers
+            ];
+            const summary = {
+                insertions: 0,
+                deletions: 5,
+            };
+            const result = parser.parseFileBlock(diffLines.join('\n'), summary);
+            expect(result.status).toBe('deleted');
+        });
+    });
+});

package/dist/server/server.d.ts

@@ -0,0 +1,11 @@
+interface ServerOptions {
+    commitish: string;
+    preferredPort?: number;
+    openBrowser?: boolean;
+    mode?: string;
+}
+export declare function startServer(options: ServerOptions): Promise<{
+    port: number;
+    url: string;
+}>;
+export {};

package/dist/server/server.js

@@ -0,0 +1,128 @@
+import express from 'express';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import open from 'open';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import { GitDiffParser } from './git-diff.js';
+import { CommentStore } from './comment-store.js';
+export async function startServer(options) {
+    const app = express();
+    const parser = new GitDiffParser();
+    const commentStore = new CommentStore();
+    let diffData = null;
+    app.use(express.json());
+    app.use((_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', 'http://localhost:*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+        next();
+    });
+    const isValidCommit = await parser.validateCommit(options.commitish);
+    if (!isValidCommit) {
+        throw new Error(`Invalid or non-existent commit: ${options.commitish}`);
+    }
+    diffData = await parser.parseDiff(options.commitish);
+    await commentStore.loadFromFile();
+    app.get('/api/diff', (_req, res) => {
+        res.json(diffData);
+    });
+    app.get('/api/comments', async (_req, res) => {
+        const comments = await commentStore.getComments();
+        res.json(comments);
+    });
+    app.post('/api/comments', async (req, res) => {
+        try {
+            const { file, line, body } = req.body;
+            if (!file || typeof line !== 'number' || !body) {
+                return res.status(400).json({ error: 'Missing required fields: file, line, body' });
+            }
+            const comment = await commentStore.addComment(file, line, body);
+            res.json(comment);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to save comment' });
+        }
+    });
+    app.post('/api/comments/:id/prompt', async (req, res) => {
+        try {
+            const comments = await commentStore.getComments();
+            const comment = comments.find((c) => c.id === req.params.id);
+            if (!comment) {
+                return res.status(404).json({ error: 'Comment not found' });
+            }
+            const targetFile = diffData.files.find((f) => f.path === comment.file);
+            if (!targetFile) {
+                return res.status(404).json({ error: 'File not found in diff' });
+            }
+            let diffContent = '';
+            for (const chunk of targetFile.chunks) {
+                diffContent += chunk.header + '\n';
+                for (const line of chunk.lines) {
+                    const prefix = line.type === 'add' ? '+' : line.type === 'delete' ? '-' : ' ';
+                    diffContent += prefix + line.content + '\n';
+                }
+            }
+            const prompt = commentStore.generatePrompt(comment, diffContent);
+            res.json({ prompt });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to generate prompt' });
+        }
+    });
+    const isProduction = process.env.NODE_ENV === 'production';
+    if (isProduction) {
+        // CLI実行ファイルの場所から相対的にクライアントファイルを探す
+        const distPath = join(__dirname, '..', 'client');
+        app.use(express.static(distPath));
+        app.get('*', (_req, res) => {
+            res.sendFile(join(distPath, 'index.html'));
+        });
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.send(`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>ReviewIt - Dev Mode</title>
+          </head>
+          <body>
+            <div id="root"></div>
+            <script>
+              console.log('ReviewIt development mode');
+              console.log('Diff data available at /api/diff');
+            </script>
+          </body>
+        </html>
+      `);
+        });
+    }
+    const port = await findAvailablePort(options.preferredPort || 3000);
+    app.listen(port, '127.0.0.1');
+    const url = `http://localhost:${port}`;
+    if (options.openBrowser) {
+        try {
+            await open(url);
+        }
+        catch (error) {
+            console.warn('Failed to open browser automatically');
+        }
+    }
+    return { port, url };
+}
+async function findAvailablePort(preferredPort) {
+    const net = await import('net');
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(preferredPort, () => {
+            const port = server.address()?.port;
+            server.close(() => resolve(port));
+        });
+        server.on('error', () => {
+            findAvailablePort(preferredPort + 1)
+                .then(resolve)
+                .catch(reject);
+        });
+    });
+}

package/dist/server/server.test.d.ts

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