codex-review-mcp 1.4.0 → 2.0.0

package/dist/tools/performCodeReview.test.js

@@ -1,15 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { performCodeReview } from './performCodeReview.js';
-import * as collectDiffModule from '../review/collectDiff.js';
 import * as gatherContextModule from '../review/gatherContext.js';
 import * as invokeAgentModule from '../review/invokeAgent.js';
+import * as buildPromptModule from '../review/buildPrompt.js';
 // Mock the dependencies
-vi.mock('../review/collectDiff');
 vi.mock('../review/gatherContext');
 vi.mock('../review/invokeAgent');
+vi.mock('../review/buildPrompt');
 vi.mock('../util/debug', () => ({
     debugLog: vi.fn(),
 }));
+vi.mock('node:fs', () => ({
+    readFileSync: vi.fn(() => JSON.stringify({ version: '2.0.0' })),
+}));
 describe('performCodeReview', () => {
     const mockDiff = `diff --git a/test.ts b/test.ts
 +++ b/test.ts
@@ -19,85 +22,202 @@ describe('performCodeReview', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    it('should call progress callback with correct sequence', async () => {
-        // Setup mocks
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(mockDiff);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review\n\nLooks good!');
-        // Track progress calls
-        const progressCalls = [];
-        const onProgress = vi.fn(async (message, progress, total) => {
-            progressCalls.push({ message, progress, total });
-        });
-        // Execute
-        await performCodeReview({ target: 'auto' }, onProgress);
-        // Verify progress sequence
-        expect(progressCalls.length).toBeGreaterThan(0);
-        expect(progressCalls[0]).toEqual({ message: 'Collecting diff…', progress: 10, total: 100 });
-        // Find the "Calling GPT-5 Codex" message
-        const codexCall = progressCalls.find(call => call.message.includes('Calling GPT-5 Codex'));
-        expect(codexCall).toBeDefined();
-        expect(codexCall?.message).toMatch(/Calling GPT-5 Codex with ~\d+ lines/);
-        expect(codexCall?.progress).toBe(65);
-        // Verify final progress
-        const lastCall = progressCalls[progressCalls.length - 1];
-        expect(lastCall).toEqual({ message: 'Done', progress: 100, total: 100 });
+    describe('Core Functionality', () => {
+        it('should perform review with required content parameter', async () => {
+            // Setup mocks
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review\n\nLooks good!');
+            // Execute
+            const result = await performCodeReview({
+                content: mockDiff
+            });
+            // Verify
+            expect(result).toContain('# Review');
+            expect(result).toContain('Looks good!');
+            expect(invokeAgentModule.invokeAgent).toHaveBeenCalled();
+        });
+        it('should throw error when content is missing', async () => {
+            await expect(performCodeReview({ content: '' })).rejects.toThrow('content is required');
+        });
+        it('should throw error when content is only whitespace', async () => {
+            await expect(performCodeReview({ content: '   \n  \t  ' })).rejects.toThrow('content is required');
+        });
     });
-    it('should include line count in GPT-5 Codex progress message', async () => {
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(mockDiff);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review\n\nLooks good!');
-        const progressCalls = [];
-        const onProgress = vi.fn(async (message, progress) => {
-            progressCalls.push({ message, progress });
-        });
-        await performCodeReview({ target: 'auto' }, onProgress);
-        const codexCall = progressCalls.find(call => call.message.includes('Calling GPT-5 Codex'));
-        expect(codexCall?.message).toMatch(/\+\d+ -\d+\)/);
+    describe('Progress Callbacks', () => {
+        it('should call progress callback with correct sequence', async () => {
+            // Setup mocks
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review\n\nLooks good!');
+            // Track progress calls
+            const progressCalls = [];
+            const onProgress = vi.fn(async (message, progress, total) => {
+                progressCalls.push({ message, progress, total });
+            });
+            // Execute
+            await performCodeReview({ content: mockDiff }, onProgress);
+            // Verify progress sequence
+            expect(progressCalls.length).toBeGreaterThan(0);
+            expect(progressCalls[0]).toMatchObject({ message: 'Preparing review…', progress: 10 });
+            expect(progressCalls[progressCalls.length - 1]).toMatchObject({ message: 'Done', progress: 100 });
+        });
     });
-    it('should throw error when diff is empty', async () => {
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue('');
-        await expect(performCodeReview({ target: 'auto' })).rejects.toThrow('No changes to review');
+    describe('Context Management', () => {
+        it('should use customContext when provided', async () => {
+            const customContext = '# Project Rules\n\nUse strict mode';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('should not be called');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff,
+                customContext
+            });
+            // Verify gatherContext was NOT called
+            expect(gatherContextModule.gatherContext).not.toHaveBeenCalled();
+            // Verify buildPrompt received customContext
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ context: customContext }));
+        });
+        it('should skip context gathering when skipContextGathering is true', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('should not be called');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff,
+                skipContextGathering: true
+            });
+            // Verify gatherContext was NOT called
+            expect(gatherContextModule.gatherContext).not.toHaveBeenCalled();
+            // Verify buildPrompt received empty context
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ context: '' }));
+        });
+        it('should auto-gather context when no customContext and not skipped', async () => {
+            const autoContext = '# Auto-gathered\n\nConfig files';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue(autoContext);
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff
+            });
+            // Verify gatherContext WAS called
+            expect(gatherContextModule.gatherContext).toHaveBeenCalled();
+            // Verify buildPrompt received auto-gathered context
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ context: autoContext }));
+        });
+        it('should pass workspaceDir to gatherContext', async () => {
+            const workspaceDir = '/custom/workspace';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            await performCodeReview({
+                content: mockDiff,
+                workspaceDir
+            });
+            expect(gatherContextModule.gatherContext).toHaveBeenCalledWith(workspaceDir);
+        });
     });
-    it('should propagate errors from invokeAgent', async () => {
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(mockDiff);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockRejectedValue(new Error('OpenAI API error: Rate limit exceeded'));
-        await expect(performCodeReview({ target: 'auto' })).rejects.toThrow('OpenAI API error');
+    describe('Content Types', () => {
+        it('should handle diff content type', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff,
+                contentType: 'diff'
+            });
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ isStaticReview: false }));
+        });
+        it('should handle code content type', async () => {
+            const codeContent = 'export function test() { return true; }';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: codeContent,
+                contentType: 'code'
+            });
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ isStaticReview: true }));
+        });
     });
-    it('should call collectDiff with correct workspaceDir', async () => {
-        const collectDiffSpy = vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(mockDiff);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
-        await performCodeReview({ target: 'auto', workspaceDir: '/test/path' });
-        expect(collectDiffSpy).toHaveBeenCalledWith(expect.objectContaining({ target: 'auto', workspaceDir: '/test/path' }), '/test/path');
+    describe('Review Parameters', () => {
+        it('should pass focus parameter to buildPrompt', async () => {
+            const focus = 'security and performance';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff,
+                focus
+            });
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ focus }));
+        });
+        it('should pass maxTokens to invokeAgent', async () => {
+            const maxTokens = 4000;
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            const invokeAgentSpy = vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            await performCodeReview({
+                content: mockDiff,
+                maxTokens
+            });
+            expect(invokeAgentSpy).toHaveBeenCalledWith(expect.objectContaining({ maxTokens }));
+        });
+        it('should pass workspaceDir to invokeAgent', async () => {
+            const workspaceDir = '/test/workspace';
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            const invokeAgentSpy = vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            await performCodeReview({
+                content: mockDiff,
+                workspaceDir
+            });
+            expect(invokeAgentSpy).toHaveBeenCalledWith(expect.objectContaining({ workspaceDir }));
+        });
     });
-    it('should handle all target modes', async () => {
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(mockDiff);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
-        const targets = ['auto', 'staged', 'head', 'range'];
-        for (const target of targets) {
-            const input = target === 'range'
-                ? { target, baseRef: 'main', headRef: 'feature' }
-                : { target };
-            await performCodeReview(input);
-            expect(collectDiffModule.collectDiff).toHaveBeenCalled();
-        }
+    describe('Version Tracking', () => {
+        it('should include version in buildPrompt', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff
+            });
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({ version: '2.0.0' }));
+        });
     });
-    it('should handle diffs with untracked files', async () => {
-        const diffWithUntracked = `diff --git a/tracked.ts b/tracked.ts
-+++ b/tracked.ts
-+modified tracked file
-diff --git a/newfile.ts b/newfile.ts
-new file mode 100644
-+++ b/newfile.ts
-+new untracked file`;
-        vi.spyOn(collectDiffModule, 'collectDiff').mockResolvedValue(diffWithUntracked);
-        vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
-        vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
-        const result = await performCodeReview({ target: 'auto' });
-        expect(result).toBeTruthy();
-        expect(collectDiffModule.collectDiff).toHaveBeenCalledWith(expect.objectContaining({ target: 'auto' }), undefined);
+    describe('Progress Messages', () => {
+        it('should show correct message when using customContext', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const progressCalls = [];
+            const onProgress = vi.fn(async (message) => {
+                progressCalls.push(message);
+            });
+            await performCodeReview({
+                content: mockDiff,
+                customContext: 'rules'
+            }, onProgress);
+            expect(progressCalls).toContain('Using provided project context…');
+        });
+        it('should show correct message when skipping context', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const progressCalls = [];
+            const onProgress = vi.fn(async (message) => {
+                progressCalls.push(message);
+            });
+            await performCodeReview({
+                content: mockDiff,
+                skipContextGathering: true
+            }, onProgress);
+            expect(progressCalls).toContain('Skipping context gathering…');
+        });
+        it('should show correct message when auto-gathering context', async () => {
+            vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const progressCalls = [];
+            const onProgress = vi.fn(async (message) => {
+                progressCalls.push(message);
+            });
+            await performCodeReview({
+                content: mockDiff
+            }, onProgress);
+            expect(progressCalls).toContain('Gathering project context…');
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-review-mcp",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "main": "index.js",
   "scripts": {
     "build": "tsc",
@@ -58,6 +58,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.7.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"

package/dist/review/collectDiff.js

@@ -1,192 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { promises as fs } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { minimatch } from 'minimatch';
-const exec = promisify(execFile);
-const DEFAULT_IGNORES = [
-    '**/dist/**',
-    '**/build/**',
-    '**/*.lock',
-];
-function filterPaths(paths) {
-    if (!paths || paths.length === 0)
-        return undefined;
-    return paths.filter((p) => !DEFAULT_IGNORES.some((g) => minimatch(p, g)));
-}
-export async function collectDiff(input, workspaceDir) {
-    async function findRepoRoot(startDir) {
-        let dir = startDir;
-        // Walk up to filesystem root (max ~25 hops as a safety guard)
-        for (let i = 0; i < 25; i++) {
-            try {
-                // Accept both .git directory and file (worktree) as signal of repo root
-                await fs.stat(join(dir, '.git'));
-                return dir;
-            }
-            catch {
-                const parent = dirname(dir);
-                if (parent === dir)
-                    break;
-                dir = parent;
-            }
-        }
-        return null;
-    }
-    async function detectDefaultBranch(repoRoot) {
-        // Try to get default branch from remote
-        try {
-            const { stdout } = await exec('git', ['remote', 'show', 'origin'], { cwd: repoRoot, encoding: 'utf8' });
-            const match = stdout.match(/HEAD branch:\s*(\S+)/);
-            if (match?.[1])
-                return match[1];
-        }
-        catch {
-            // Remote not available or other error, continue to fallback
-        }
-        // Fallback: check if main or master exists locally
-        for (const branch of ['main', 'master']) {
-            try {
-                await exec('git', ['rev-parse', '--verify', branch], { cwd: repoRoot });
-                return branch;
-            }
-            catch {
-                // Branch doesn't exist, try next
-            }
-        }
-        // Last resort: use HEAD~1 as baseline if it exists
-        try {
-            await exec('git', ['rev-parse', '--verify', 'HEAD~1'], { cwd: repoRoot });
-            return 'HEAD~1';
-        }
-        catch {
-            return null;
-        }
-    }
-    async function hasUncommittedChanges(repoRoot) {
-        try {
-            const { stdout } = await exec('git', ['status', '--porcelain'], { cwd: repoRoot, encoding: 'utf8' });
-            return stdout.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async function getCurrentBranch(repoRoot) {
-        try {
-            const { stdout } = await exec('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoRoot, encoding: 'utf8' });
-            return stdout.trim();
-        }
-        catch {
-            return null;
-        }
-    }
-    async function hasHeadCommit(repoRoot) {
-        try {
-            await exec('git', ['rev-parse', '--verify', 'HEAD'], { cwd: repoRoot });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    // Priority order: explicit workspaceDir param > env vars > process.cwd()
-    const preferredStart = workspaceDir || process.env.CODEX_REPO_ROOT || process.env.WORKSPACE_ROOT || process.env.INIT_CWD || process.cwd();
-    const preferredRoot = await findRepoRoot(preferredStart);
-    // If workspaceDir was explicitly provided but no repo found, fail immediately
-    if (workspaceDir && !preferredRoot) {
-        throw new Error(`Could not locate a Git repository starting from workspaceDir "${workspaceDir}".`);
-    }
-    const repoRoot = preferredRoot || (await findRepoRoot(process.cwd())) || process.cwd();
-    const args = ['diff', '--unified=0'];
-    if (input.target === 'auto') {
-        // Auto mode: detect what to review
-        const hasChanges = await hasUncommittedChanges(repoRoot);
-        if (hasChanges) {
-            // Review uncommitted changes vs HEAD (or staged if no commits yet)
-            if (await hasHeadCommit(repoRoot)) {
-                args.push('HEAD');
-            }
-            else {
-                args.splice(1, 0, '--staged');
-            }
-        }
-        else {
-            // No uncommitted changes, review branch vs default
-            const currentBranch = await getCurrentBranch(repoRoot);
-            const defaultBranch = await detectDefaultBranch(repoRoot);
-            if (!defaultBranch) {
-                // Can't determine default branch - nothing to review
-                return '';
-            }
-            if (currentBranch === defaultBranch) {
-                // On default branch with no changes - nothing to review
-                return '';
-            }
-            // Review current branch vs default branch
-            args.push(`${defaultBranch}...HEAD`);
-        }
-    }
-    else {
-        // Explicit target modes
-        switch (input.target) {
-            case 'staged':
-                args.splice(1, 0, '--staged');
-                break;
-            case 'head':
-                args.push('HEAD');
-                break;
-            case 'range':
-                if (!input.baseRef || !input.headRef) {
-                    throw new Error('range target requires baseRef and headRef');
-                }
-                args.push(`${input.baseRef}...${input.headRef}`);
-                break;
-        }
-    }
-    const filtered = filterPaths(input.paths);
-    if (filtered && filtered.length)
-        args.push(...filtered);
-    try {
-        const { stdout } = await exec('git', args, {
-            encoding: 'utf8',
-            maxBuffer: 10 * 1024 * 1024,
-            cwd: repoRoot,
-        });
-        let diffText = stdout;
-        // In auto mode with uncommitted changes, also include untracked files
-        if (input.target === 'auto' && await hasUncommittedChanges(repoRoot)) {
-            try {
-                const { stdout: untrackedFiles } = await exec('git', ['ls-files', '--others', '--exclude-standard'], { encoding: 'utf8', cwd: repoRoot });
-                const files = untrackedFiles.trim().split('\n').filter(f => f);
-                for (const file of files) {
-                    try {
-                        const { stdout: fileDiff } = await exec('git', ['diff', '--no-index', '--unified=0', '/dev/null', file], { encoding: 'utf8', cwd: repoRoot });
-                        diffText += '\n' + fileDiff;
-                    }
-                    catch (diffErr) {
-                        // git diff --no-index returns exit code 1 when there are differences
-                        if (diffErr.stdout) {
-                            diffText += '\n' + diffErr.stdout;
-                        }
-                    }
-                }
-            }
-            catch {
-                // If we can't get untracked files, continue with just tracked changes
-            }
-        }
-        // Drop obvious binary diffs
-        const text = diffText
-            .split('\n')
-            .filter((line) => !line.startsWith('Binary files '))
-            .join('\n');
-        // Enforce size cap ~300k chars
-        const cap = 300_000;
-        return text.length > cap ? text.slice(0, cap) + '\n<!-- diff truncated -->\n' : text;
-    }
-    catch (err) {
-        const msg = err?.stderr || err?.message || String(err);
-        throw new Error(`Failed to collect git diff: ${msg}`);
-    }
-}