codex-review-mcp 2.3.4 → 2.3.6

package/dist/mcp-server.js

@@ -32,41 +32,44 @@ server.registerTool('perform_code_review', {
 
 🎯 USAGE:
 
-  1. Get the code/diff to review:
+  1. Get the workspace directory and code to review:
+     const workspaceDir = await getWorkspaceDirectory();
      const diff = await runCommand("git diff");
      
-  2. Optionally gather project context:
-     const rules = await readFile(".cursor/rules/project.mdc");
-     
-  3. Call with content:
+  2. Call with content AND workspaceDir for context gathering:
      await perform_code_review({
        content: diff,                    // REQUIRED
+       workspaceDir: workspaceDir,       // ⭐ CRITICAL for .cursor/rules!
        contentType: "diff",              // "diff" or "code"
-       customContext: rules,             // Optional: saves tokens!
        focus: "security and performance" // Optional: specific focus
      });
 
 💡 KEY BENEFITS:
   - Expert Reviews: GPT-5 Codex with project-specific context
-  - Codebase-Aware: Checks YOUR patterns, enforces YOUR rules
+  - Codebase-Aware: Auto-finds .cursor/rules, package.json, tsconfig.json
+  - Prioritized: .cursor/rules are ALWAYS checked first
   - Efficient: Provide customContext to skip auto-gathering
 
+⚠️  IMPORTANT:
+  - workspaceDir is CRITICAL for finding .cursor/rules and project files
+  - Without it, context gathering looks in the wrong directory!
+
 📋 PARAMETERS:
   - content: Code or diff to review (REQUIRED)
+  - workspaceDir: Project directory (CRITICAL for .cursor/rules context)
   - contentType: "diff" | "code"
-  - customContext: Project rules/guidelines (saves tokens if provided)
-  - skipContextGathering: Skip auto-gathering if you don't need context
-  - focus: Specific areas to review (e.g., "security", "performance")
-  - workspaceDir: Base directory for context gathering (defaults to cwd)`,
+  - customContext: Manual context (bypasses auto-gathering if provided)
+  - skipContextGathering: Skip auto-gathering (only use if no context needed)
+  - focus: Specific areas to review (e.g., "security", "performance")`,
     inputSchema: {
         // REQUIRED
         content: z.string().describe('Code or diff content to review (REQUIRED). Agent should run git commands or read files to get this.'),
         // CONTENT TYPE
         contentType: z.enum(['diff', 'code']).optional().describe('Type of content: "diff" for git diffs, "code" for static code review'),
         // CONTEXT OPTIONS
-        customContext: z.string().optional().describe('⭐ RECOMMENDED: Project context (.cursor/rules, CODE_REVIEW.md, etc). Saves tokens and time!'),
-        skipContextGathering: z.boolean().optional().describe('Set to true to skip automatic context gathering (useful if no context needed)'),
-        workspaceDir: z.string().optional().describe('Base directory for context gathering (defaults to current directory)'),
+        workspaceDir: z.string().optional().describe('⭐ CRITICAL: Project root directory for finding .cursor/rules and config files. Without this, context gathering looks in wrong directory!'),
+        customContext: z.string().optional().describe('Optional: Provide manual context to skip auto-gathering (.cursor/rules, CODE_REVIEW.md, etc)'),
+        skipContextGathering: z.boolean().optional().describe('Set to true to skip automatic context gathering (only if no context needed)'),
         // REVIEW OPTIONS
         focus: z.string().optional().describe('Specific areas to focus on (e.g., "security and performance")'),
         maxTokens: z.number().optional().describe('Maximum tokens for review response'),

package/dist/mcp-server.test.js

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { z } from 'zod';
+// Mock the performCodeReview function
+vi.mock('./tools/performCodeReview.js', () => ({
+    performCodeReview: vi.fn()
+}));
+import { performCodeReview } from './tools/performCodeReview.js';
+describe('MCP Server Integration Tests', () => {
+    let server;
+    let client;
+    let serverTransport;
+    let clientTransport;
+    beforeEach(async () => {
+        // Reset mocks
+        vi.clearAllMocks();
+        // Create linked in-memory transports
+        [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        // Import and set up the server (we'll need to refactor mcp-server.ts slightly)
+        // For now, create a test server with the same configuration
+        server = new McpServer({ name: 'codex-review-mcp', version: '2.3.4' });
+        // Register the same tools as in mcp-server.ts
+        server.registerTool('get_version', {
+            title: 'Get Version',
+            description: 'Get the version of the codex-review-mcp server.',
+            inputSchema: {},
+        }, async () => {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `codex-review-mcp version 2.3.4`,
+                        mimeType: 'text/plain'
+                    }],
+                _meta: { version: '2.3.4' }
+            };
+        });
+        server.registerTool('perform_code_review', {
+            title: 'Perform Code Review',
+            description: 'Review code/diffs using GPT-5 Codex',
+            inputSchema: {
+                content: z.string().describe('Code or diff content to review'),
+                contentType: z.enum(['diff', 'code']).optional(),
+                workspaceDir: z.string().optional(),
+                customContext: z.string().optional(),
+                skipContextGathering: z.boolean().optional(),
+                focus: z.string().optional(),
+                maxTokens: z.number().optional(),
+            },
+        }, async (input, extra) => {
+            const onProgress = async (message, progress, total) => {
+                // Only send progress notifications if we have a valid progress token
+                const progressToken = extra?._meta?.progressToken ?? extra?.requestId;
+                if (progressToken === undefined || progressToken === null) {
+                    // Skip progress notifications if no token available
+                    return;
+                }
+                await server.server.notification({
+                    method: 'notifications/progress',
+                    params: {
+                        progressToken,
+                        progress,
+                        total,
+                        message,
+                    },
+                }, extra?.requestId ? { relatedRequestId: extra.requestId } : undefined);
+            };
+            try {
+                const markdown = await performCodeReview({
+                    content: input.content,
+                    contentType: input.contentType,
+                    workspaceDir: input.workspaceDir,
+                    customContext: input.customContext,
+                    skipContextGathering: input.skipContextGathering,
+                    focus: input.focus,
+                    maxTokens: input.maxTokens,
+                }, onProgress);
+                return {
+                    content: [{ type: 'text', text: markdown, mimeType: 'text/markdown' }],
+                    _meta: { version: '2.3.4' }
+                };
+            }
+            catch (error) {
+                const errorMessage = error?.message || String(error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Code Review Failed\n\n**Error:** ${errorMessage}\n\n**Version:** 2.3.4\n\nCheck MCP server logs for details.`,
+                            mimeType: 'text/markdown'
+                        }],
+                    isError: true,
+                    _meta: { version: '2.3.4', error: errorMessage }
+                };
+            }
+        });
+        // Create client
+        client = new Client({
+            name: 'test-client',
+            version: '1.0.0'
+        }, {
+            capabilities: {}
+        });
+        // Connect both
+        await server.connect(serverTransport);
+        await client.connect(clientTransport);
+    });
+    afterEach(async () => {
+        await client.close();
+        await server.close();
+    });
+    describe('Server Capabilities', () => {
+        it('should list all registered tools', async () => {
+            const tools = await client.listTools();
+            expect(tools.tools).toHaveLength(2);
+            expect(tools.tools.map(t => t.name)).toContain('get_version');
+            expect(tools.tools.map(t => t.name)).toContain('perform_code_review');
+        });
+        it('should have correct tool schemas', async () => {
+            const tools = await client.listTools();
+            const getVersionTool = tools.tools.find(t => t.name === 'get_version');
+            expect(getVersionTool).toBeDefined();
+            expect(getVersionTool?.description).toContain('version');
+            const reviewTool = tools.tools.find(t => t.name === 'perform_code_review');
+            expect(reviewTool).toBeDefined();
+            expect(reviewTool?.description).toContain('Review code');
+        });
+    });
+    describe('get_version Tool', () => {
+        it('should return the server version', async () => {
+            const result = await client.callTool({
+                name: 'get_version',
+                arguments: {}
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]).toMatchObject({
+                type: 'text',
+                mimeType: 'text/plain'
+            });
+            const text = result.content[0].text;
+            expect(text).toContain('codex-review-mcp version');
+            expect(text).toContain('2.3.4');
+        });
+        it('should include version in metadata', async () => {
+            const result = await client.callTool({
+                name: 'get_version',
+                arguments: {}
+            });
+            expect(result._meta).toBeDefined();
+            expect(result._meta?.version).toBe('2.3.4');
+        });
+    });
+    describe('perform_code_review Tool', () => {
+        beforeEach(() => {
+            // Mock performCodeReview to return a simple response
+            vi.mocked(performCodeReview).mockResolvedValue('# Code Review\n\nLooks good!');
+        });
+        it('should call performCodeReview with correct parameters', async () => {
+            await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'console.log("test");',
+                    contentType: 'code',
+                    focus: 'security'
+                }
+            });
+            expect(performCodeReview).toHaveBeenCalledWith(expect.objectContaining({
+                content: 'console.log("test");',
+                contentType: 'code',
+                focus: 'security'
+            }), expect.any(Function) // onProgress callback
+            );
+        });
+        it('should pass workspaceDir parameter for context gathering', async () => {
+            // CRITICAL TEST: Verifies workspaceDir flows from MCP layer to performCodeReview
+            const testWorkspaceDir = '/Users/test/Projects/learn-webapp';
+            await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'console.log("test");',
+                    workspaceDir: testWorkspaceDir
+                }
+            });
+            // Verify workspaceDir is passed to performCodeReview
+            expect(performCodeReview).toHaveBeenCalledWith(expect.objectContaining({
+                workspaceDir: testWorkspaceDir
+            }), expect.any(Function));
+        });
+        it('should handle missing workspaceDir (falls back to cwd)', async () => {
+            await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'console.log("test");'
+                    // workspaceDir NOT provided
+                }
+            });
+            // workspaceDir should be undefined, causing gatherContext to use process.cwd()
+            expect(performCodeReview).toHaveBeenCalledWith(expect.objectContaining({
+                workspaceDir: undefined
+            }), expect.any(Function));
+        });
+        it('should return markdown content', async () => {
+            const result = await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'console.log("test");'
+                }
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]).toMatchObject({
+                type: 'text',
+                mimeType: 'text/markdown'
+            });
+            const text = result.content[0].text;
+            expect(text).toContain('Code Review');
+        });
+        it('should handle errors gracefully', async () => {
+            // Mock an error
+            vi.mocked(performCodeReview).mockRejectedValue(new Error('Test error'));
+            const result = await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'console.log("test");'
+                }
+            });
+            expect(result.isError).toBe(true);
+            const text = result.content[0].text;
+            expect(text).toContain('Code Review Failed');
+            expect(text).toContain('Test error');
+        });
+    });
+    describe('Progress Notifications', () => {
+        it('should call onProgress callback with proper parameters', async () => {
+            let onProgressCalled = false;
+            let progressMessages = [];
+            // Mock performCodeReview to call onProgress
+            vi.mocked(performCodeReview).mockImplementation(async (_input, onProgress) => {
+                if (onProgress) {
+                    onProgressCalled = true;
+                    await onProgress('Starting...', 10, 100);
+                    progressMessages.push('Starting...');
+                    await onProgress('Processing...', 50, 100);
+                    progressMessages.push('Processing...');
+                    await onProgress('Done', 100, 100);
+                    progressMessages.push('Done');
+                }
+                return '# Review Complete';
+            });
+            await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'test code'
+                }
+            });
+            // Verify onProgress was called with proper sequence
+            expect(onProgressCalled).toBe(true);
+            expect(progressMessages).toEqual(['Starting...', 'Processing...', 'Done']);
+        });
+        it('should handle progress with value 0 correctly (verifies explicit nullish check)', async () => {
+            // This test verifies we use explicit nullish check (=== null/undefined)
+            // not falsy check (!progressToken) which would incorrectly filter 0
+            let progressValues = [];
+            vi.mocked(performCodeReview).mockImplementation(async (_input, onProgress) => {
+                if (onProgress) {
+                    await onProgress('Start', 0, 100); // 0 is a valid progress value
+                    progressValues.push(0);
+                    await onProgress('Middle', 50, 100);
+                    progressValues.push(50);
+                    await onProgress('End', 100, 100);
+                    progressValues.push(100);
+                }
+                return '# Review Complete';
+            });
+            await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'test code'
+                }
+            });
+            // Should accept 0 as a valid progress value
+            expect(progressValues).toContain(0);
+            expect(progressValues).toContain(50);
+            expect(progressValues).toContain(100);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should catch and report errors with stack trace', async () => {
+            const testError = new Error('Detailed test error');
+            vi.mocked(performCodeReview).mockRejectedValue(testError);
+            const result = await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'test code'
+                }
+            });
+            expect(result.isError).toBe(true);
+            const text = result.content[0].text;
+            expect(text).toContain('❌ Code Review Failed');
+            expect(text).toContain('Detailed test error');
+            expect(result._meta?.error).toBe('Detailed test error');
+        });
+        it('should handle non-Error objects', async () => {
+            vi.mocked(performCodeReview).mockRejectedValue('String error');
+            const result = await client.callTool({
+                name: 'perform_code_review',
+                arguments: {
+                    content: 'test code'
+                }
+            });
+            expect(result.isError).toBe(true);
+            const text = result.content[0].text;
+            expect(text).toContain('String error');
+        });
+    });
+});

package/dist/tools/performCodeReview.js

@@ -37,6 +37,16 @@ export async function performCodeReview(input, onProgress) {
         : shouldSkip
             ? ''
             : await gatherContext(input.workspaceDir);
+    // Debug: Log what context was gathered (to stderr for MCP logs)
+    console.error(`[codex-review-mcp] Context gathered: ${context.length} chars`);
+    const hasCursorRules = context.includes('.cursor/rules');
+    console.error(`[codex-review-mcp] Contains .cursor/rules: ${hasCursorRules}`);
+    if (hasCursorRules) {
+        const cursorFiles = (context.match(/<!-- \.cursor\/rules\/[^>]+ -->/g) || []);
+        console.error(`[codex-review-mcp] Cursor rules files: ${cursorFiles.join(', ')}`);
+    }
+    // Also use debugLog for persistent logging
+    await debugLog(`Context gathered: ${context.length} chars, .cursor/rules: ${hasCursorRules}`);
     // Build expert prompt
     await onProgress?.('Building expert prompt…', 50, 100);
     const isStaticReview = input.contentType === 'code';

package/dist/tools/performCodeReview.test.js

@@ -112,6 +112,34 @@ describe('performCodeReview', () => {
             });
             expect(gatherContextModule.gatherContext).toHaveBeenCalledWith(workspaceDir);
         });
+        it('should use process.cwd() when workspaceDir is not provided', async () => {
+            const gatherSpy = vi.spyOn(gatherContextModule, 'gatherContext').mockResolvedValue('');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            await performCodeReview({
+                content: mockDiff
+                // workspaceDir NOT provided
+            });
+            // Should be called with undefined, which makes gatherContext use process.cwd()
+            expect(gatherSpy).toHaveBeenCalledWith(undefined);
+        });
+        it('should find .cursor/rules when workspaceDir points to correct directory', async () => {
+            // This tests the critical path: workspaceDir -> gatherContext -> .cursor/rules
+            const workspaceDir = '/project/with/cursor/rules';
+            const gatherSpy = vi.spyOn(gatherContextModule, 'gatherContext')
+                .mockResolvedValue('<!-- .cursor/rules/project.mdc -->\n# Cursor Rules\nUse strict mode');
+            vi.spyOn(invokeAgentModule, 'invokeAgent').mockResolvedValue('# Review');
+            const buildPromptSpy = vi.spyOn(buildPromptModule, 'buildPrompt').mockReturnValue('prompt');
+            await performCodeReview({
+                content: mockDiff,
+                workspaceDir
+            });
+            // Verify gatherContext was called with the workspace dir
+            expect(gatherSpy).toHaveBeenCalledWith(workspaceDir);
+            // Verify the gathered context (with .cursor/rules) is passed to buildPrompt
+            expect(buildPromptSpy).toHaveBeenCalledWith(expect.objectContaining({
+                context: expect.stringContaining('.cursor/rules/project.mdc')
+            }));
+        });
     });
     describe('Content Types', () => {
         it('should handle diff content type', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-review-mcp",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "main": "index.js",
   "scripts": {
     "build": "tsc",