codex-review-mcp 2.3.5 → 2.3.7

package/dist/mcp-server.test.js

@@ -171,6 +171,34 @@ describe('MCP Server Integration Tests', () => {
             }), 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',

package/dist/review/gatherContext.js

@@ -1,9 +1,10 @@
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
 const CANDIDATE_FILES = [
-    '.cursor/rules/tsx.mdc',
-    '.cursor/rules/project.mdc',
-    '.cursor/rules/', // directory to scan for all .md and .mdc files
+    '.cursor/rules/tsx.mdc', // Primary: React/TypeScript rules for code review
+    '.cursor/rules/project.mdc', // Secondary: Project-specific rules
+    // Note: We only check specific files, not the entire .cursor/rules/ directory
+    // Other files in .cursor/rules/customrules/ are for other agents
     'CODE_REVIEW.md',
     'CONTRIBUTING.md',
     'ARCHITECTURE.md',

package/dist/review/gatherContext.test.js

@@ -24,12 +24,8 @@ describe('gatherContext', () => {
             const mockReadFile = vi.mocked(fs.readFile);
             const mockReaddir = vi.mocked(fs.readdir);
             const mockRealpath = vi.mocked(fs.realpath);
-            // Mock .cursor/rules directory scanning
-            mockRealpath.mockResolvedValue('/test/workspace/.cursor/rules');
-            mockReaddir.mockResolvedValue([
-                { name: 'project.mdc', isFile: () => true, isDirectory: () => false },
-                { name: 'tsx.mdc', isFile: () => true, isDirectory: () => false },
-            ]);
+            mockRealpath.mockRejectedValue(new Error('ENOENT')); // No directory scanning
+            mockReaddir.mockResolvedValue([]);
             mockReadFile.mockImplementation(async (path) => {
                 if (path.includes('.cursor/rules/project.mdc'))
                     return '# Project Rules\nStrict guidelines';
@@ -46,6 +42,34 @@ describe('gatherContext', () => {
             // Verify files are marked with their paths
             expect(context).toMatch(/<!--.*\.cursor\/rules.*-->/);
         });
+        it('should gracefully handle repos without .cursor/rules files', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const mockReaddir = vi.mocked(fs.readdir);
+            const mockRealpath = vi.mocked(fs.realpath);
+            mockRealpath.mockRejectedValue(new Error('ENOENT'));
+            mockReaddir.mockResolvedValue([]);
+            mockReadFile.mockImplementation(async (path) => {
+                // .cursor/rules files don't exist
+                if (path.includes('.cursor/rules'))
+                    return Promise.reject(new Error('ENOENT'));
+                // But other files do
+                if (path.includes('CODE_REVIEW.md'))
+                    return '# Code Review Standards\nBe thorough';
+                if (path.includes('package.json'))
+                    return '{"name": "my-project", "scripts": {"test": "jest"}}';
+                if (path.includes('tsconfig.json'))
+                    return '{"compilerOptions": {"strict": true}}';
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const context = await gatherContext();
+            // Should NOT contain .cursor/rules (they don't exist)
+            expect(context).not.toContain('.cursor/rules');
+            // Should still gather other useful context
+            expect(context).toContain('Code Review Standards');
+            expect(context).toContain('package.json');
+            expect(context).toContain('tsconfig.json');
+            expect(context.length).toBeGreaterThan(0);
+        });
         it('should include CODE_REVIEW.md when present', async () => {
             const mockReadFile = vi.mocked(fs.readFile);
             const mockReaddir = vi.mocked(fs.readdir);
@@ -169,25 +193,25 @@ describe('gatherContext', () => {
             // Should stop before processing all files
             expect(context.length).toBeLessThanOrEqual(60000); // Allow some overhead
         });
-        it('should skip node_modules and other ignored directories', async () => {
+        it('should check specific cursor rules files without directory scanning', async () => {
             const mockReadFile = vi.mocked(fs.readFile);
             const mockReaddir = vi.mocked(fs.readdir);
             const mockRealpath = vi.mocked(fs.realpath);
-            mockRealpath.mockResolvedValue('/test/workspace/.cursor/rules');
-            mockReaddir.mockResolvedValue([
-                { name: 'node_modules', isDirectory: () => true, isFile: () => false },
-                { name: '.git', isDirectory: () => true, isFile: () => false },
-                { name: 'project.mdc', isFile: () => true, isDirectory: () => false },
-            ]);
+            mockRealpath.mockRejectedValue(new Error('ENOENT')); // No directory scanning
+            mockReaddir.mockResolvedValue([]); // No directory scanning
             mockReadFile.mockImplementation(async (path) => {
-                if (path.includes('project.mdc'))
-                    return '# Project Rules';
+                if (path.includes('.cursor/rules/tsx.mdc'))
+                    return '# TSX Rules\nReact patterns';
+                if (path.includes('.cursor/rules/project.mdc'))
+                    return '# Project Rules\nGuidelines';
                 return Promise.reject(new Error('ENOENT'));
             });
             const context = await gatherContext();
-            // Should include project.mdc but not traverse node_modules or .git
+            // Should include specific cursor rules files
+            expect(context).toContain('TSX Rules');
             expect(context).toContain('Project Rules');
-            expect(mockReaddir).toHaveBeenCalledTimes(1); // Only the .cursor/rules directory
+            // Should NOT scan directories (no readdir calls for .cursor/rules/)
+            expect(mockReaddir).toHaveBeenCalledTimes(0);
         });
         it('should handle circular symlinks gracefully', async () => {
             const mockReadFile = vi.mocked(fs.readFile);
@@ -257,32 +281,29 @@ describe('gatherContext', () => {
         });
     });
     describe('File Format Support', () => {
-        it('should scan .cursor/rules directory for .md and .mdc files', async () => {
+        it('should check specific cursor rules files only (no directory scan)', async () => {
             const mockReadFile = vi.mocked(fs.readFile);
             const mockReaddir = vi.mocked(fs.readdir);
             const mockRealpath = vi.mocked(fs.realpath);
-            mockRealpath.mockResolvedValue('/test/workspace/.cursor/rules');
-            mockReaddir.mockResolvedValue([
-                { name: 'project.mdc', isFile: () => true, isDirectory: () => false },
-                { name: 'readme.md', isFile: () => true, isDirectory: () => false },
-                { name: 'config.json', isFile: () => true, isDirectory: () => false },
-            ]);
+            mockRealpath.mockRejectedValue(new Error('ENOENT')); // No directory scanning
+            mockReaddir.mockResolvedValue([]); // No directory scanning
             mockReadFile.mockImplementation(async (path) => {
-                if (path.includes('project.mdc'))
-                    return '# Project';
-                if (path.includes('readme.md'))
-                    return '# Readme';
-                if (path.includes('config.json'))
-                    return '{}';
+                if (path.includes('.cursor/rules/tsx.mdc'))
+                    return '# TSX Rules';
+                if (path.includes('.cursor/rules/project.mdc'))
+                    return '# Project Rules';
+                if (path.includes('tsconfig.json'))
+                    return '{ "compilerOptions": {} }';
                 return Promise.reject(new Error('ENOENT'));
             });
             const context = await gatherContext();
-            expect(context).toContain('Project');
-            expect(context).toContain('Readme');
-            // Verify .json files from directory scan are not included (checking for the file marker)
-            expect(context).not.toMatch(/<!--.*\.cursor\/rules\/config\.json.*-->/);
-            // But ts config from the root candidate list should still be included
+            // Should include specific tsx.mdc and project.mdc files
+            expect(context).toContain('TSX Rules');
+            expect(context).toContain('Project Rules');
+            // Should include tsconfig from root candidate list
             expect(context).toContain('tsconfig.json');
+            // Should NOT scan .cursor/rules/ directory (avoids picking up other agent rules)
+            expect(mockReaddir).toHaveBeenCalledTimes(0);
         });
         it('should support multiple ESLint config formats', async () => {
             const mockReadFile = vi.mocked(fs.readFile);

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.5",
+  "version": "2.3.7",
   "main": "index.js",
   "scripts": {
     "build": "tsc",