codex-review-mcp 1.2.0 → 1.3.1

package/dist/mcp-server.js

@@ -17,29 +17,42 @@ server.registerTool('perform_code_review', {
         workspaceDir: z.string().optional().describe('Absolute path to the workspace/repository directory. If not provided, attempts to detect from environment or current working directory.'),
     },
 }, async (input, extra) => {
-    const reviewInput = {
-        target: input.target,
-        baseRef: input.baseRef,
-        headRef: input.headRef,
-        focus: input.focus,
-        paths: input.paths,
-        maxTokens: input.maxTokens,
-        workspaceDir: input.workspaceDir,
-    };
-    const onProgress = async (message, progress, total) => {
-        // Attach to tool-call request via related request ID so clients can map progress
-        await server.server.notification({
-            method: 'notifications/progress',
-            params: {
-                progressToken: extra?._meta?.progressToken ?? extra?.requestId,
-                progress,
-                total,
-                message,
-            },
-        }, extra?.requestId ? { relatedRequestId: extra.requestId } : undefined);
-    };
-    const markdown = await performCodeReview(reviewInput, onProgress);
-    return { content: [{ type: 'text', text: markdown, mimeType: 'text/markdown' }] };
+    try {
+        const reviewInput = {
+            target: input.target,
+            baseRef: input.baseRef,
+            headRef: input.headRef,
+            focus: input.focus,
+            paths: input.paths,
+            maxTokens: input.maxTokens,
+            workspaceDir: input.workspaceDir,
+        };
+        const onProgress = async (message, progress, total) => {
+            // Attach to tool-call request via related request ID so clients can map progress
+            await server.server.notification({
+                method: 'notifications/progress',
+                params: {
+                    progressToken: extra?._meta?.progressToken ?? extra?.requestId,
+                    progress,
+                    total,
+                    message,
+                },
+            }, extra?.requestId ? { relatedRequestId: extra.requestId } : undefined);
+        };
+        const markdown = await performCodeReview(reviewInput, onProgress);
+        return { content: [{ type: 'text', text: markdown, mimeType: 'text/markdown' }] };
+    }
+    catch (error) {
+        const errorMessage = error?.message || String(error);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ Code Review Failed\n\n${errorMessage}`,
+                    mimeType: 'text/markdown'
+                }],
+            isError: true
+        };
+    }
 });
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/review/collectDiff.js

@@ -153,8 +153,31 @@ export async function collectDiff(input, workspaceDir) {
             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 = stdout
+        const text = diffText
             .split('\n')
             .filter((line) => !line.startsWith('Binary files '))
             .join('\n');

package/dist/review/invokeAgent.js

@@ -7,8 +7,14 @@ export async function invokeAgent({ prompt, maxTokens }) {
         instructions: 'You are a precise code-review agent. Follow the output contract exactly. Use minimal verbosity.',
         model,
     });
-    const result = await run(agent, prompt);
-    const out = result.finalOutput ?? '';
-    await debugLog(`Agent model=${model} outputLen=${out.length}`);
-    return out;
+    try {
+        const result = await run(agent, prompt);
+        const out = result.finalOutput ?? '';
+        await debugLog(`Agent model=${model} outputLen=${out.length}`);
+        return out;
+    }
+    catch (error) {
+        await debugLog(`Agent error: ${error?.message || String(error)}`);
+        throw new Error(`OpenAI API error: ${error?.message || 'Unknown error occurred'}`);
+    }
 }

package/dist/review/invokeAgent.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { invokeAgent } from './invokeAgent.js';
+import { run } from '@openai/agents';
+// Mock the OpenAI agents SDK
+vi.mock('@openai/agents', () => ({
+    Agent: vi.fn().mockImplementation((config) => config),
+    run: vi.fn(),
+}));
+vi.mock('../util/debug', () => ({
+    debugLog: vi.fn(),
+}));
+describe('invokeAgent', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should successfully return review output', async () => {
+        const mockOutput = '# Code Review\n\nLooks great!';
+        vi.mocked(run).mockResolvedValue({
+            finalOutput: mockOutput,
+        });
+        const result = await invokeAgent({ prompt: 'Review this code' });
+        expect(result).toBe(mockOutput);
+        expect(run).toHaveBeenCalledOnce();
+    });
+    it('should handle empty finalOutput', async () => {
+        vi.mocked(run).mockResolvedValue({
+            finalOutput: null,
+        });
+        const result = await invokeAgent({ prompt: 'Review this code' });
+        expect(result).toBe('');
+    });
+    it('should catch and wrap OpenAI errors', async () => {
+        const mockError = new Error('Rate limit exceeded');
+        vi.mocked(run).mockRejectedValue(mockError);
+        await expect(invokeAgent({ prompt: 'Review this code' })).rejects.toThrow('OpenAI API error: Rate limit exceeded');
+    });
+    it('should handle unknown error types', async () => {
+        vi.mocked(run).mockRejectedValue('Unknown error');
+        await expect(invokeAgent({ prompt: 'Review this code' })).rejects.toThrow('OpenAI API error: Unknown error');
+    });
+    it('should use CODEX_MODEL env var if set', async () => {
+        const originalEnv = process.env.CODEX_MODEL;
+        process.env.CODEX_MODEL = 'gpt-4';
+        vi.mocked(run).mockResolvedValue({
+            finalOutput: 'Review',
+        });
+        await invokeAgent({ prompt: 'Review this code' });
+        // Agent should be created with the model from env
+        const { Agent } = await import('@openai/agents');
+        expect(Agent).toHaveBeenCalledWith(expect.objectContaining({
+            model: 'gpt-4',
+        }));
+        // Restore env
+        if (originalEnv) {
+            process.env.CODEX_MODEL = originalEnv;
+        }
+        else {
+            delete process.env.CODEX_MODEL;
+        }
+    });
+    it('should default to gpt-5-codex when no env var', async () => {
+        const originalEnv = process.env.CODEX_MODEL;
+        delete process.env.CODEX_MODEL;
+        vi.mocked(run).mockResolvedValue({
+            finalOutput: 'Review',
+        });
+        await invokeAgent({ prompt: 'Review this code' });
+        const { Agent } = await import('@openai/agents');
+        expect(Agent).toHaveBeenCalledWith(expect.objectContaining({
+            model: 'gpt-5-codex',
+        }));
+        // Restore env
+        if (originalEnv) {
+            process.env.CODEX_MODEL = originalEnv;
+        }
+    });
+});

package/dist/tools/performCodeReview.js

@@ -14,7 +14,11 @@ export async function performCodeReview(input, onProgress) {
     const context = await gatherContext();
     await onProgress?.('Building prompt…', 45, 100);
     const prompt = buildPrompt({ diffText, context, focus: input.focus });
-    await onProgress?.('Calling GPT-5 Codex…', 65, 100);
+    // Count lines in the diff for progress message
+    const lineCount = diffText.split('\n').length;
+    const addedLines = diffText.split('\n').filter(line => line.startsWith('+')).length;
+    const removedLines = diffText.split('\n').filter(line => line.startsWith('-')).length;
+    await onProgress?.(`Calling GPT-5 Codex with ~${lineCount} lines (+${addedLines} -${removedLines})…`, 65, 100);
     const agentMd = await invokeAgent({ prompt, maxTokens: input.maxTokens });
     await debugLog(`Review produced ${agentMd.length} chars`);
     await onProgress?.('Formatting output…', 90, 100);

package/dist/tools/performCodeReview.test.js

@@ -0,0 +1,103 @@
+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';
+// Mock the dependencies
+vi.mock('../review/collectDiff');
+vi.mock('../review/gatherContext');
+vi.mock('../review/invokeAgent');
+vi.mock('../util/debug', () => ({
+    debugLog: vi.fn(),
+}));
+describe('performCodeReview', () => {
+    const mockDiff = `diff --git a/test.ts b/test.ts
++++ b/test.ts
++export function hello() {
++  return "world";
++}`;
+    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 });
+    });
+    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+\)/);
+    });
+    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');
+    });
+    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');
+    });
+    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');
+    });
+    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();
+        }
+    });
+    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);
+    });
+});

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "codex-review-mcp",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "main": "index.js",
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w",
     "prepare": "npm run build",
     "mcp": "node dist/mcp-server.js",
-    "agents:sample": "node agents-sample.mjs"
+    "agents:sample": "node agents-sample.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage"
   },
   "repository": {
     "type": "git",
@@ -42,7 +46,7 @@
   "description": "MCP server for AI-powered code reviews using GPT-5 Codex",
   "type": "module",
   "bin": {
-    "codex-review-mcp": "./bin/codex-review-mcp"
+    "codex-review-mcp": "bin/codex-review-mcp"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.19.1",
@@ -54,6 +58,8 @@
   },
   "devDependencies": {
     "@types/node": "^24.7.0",
-    "typescript": "^5.9.3"
+    "@vitest/ui": "^3.2.4",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   }
 }