codex-review-mcp 2.5.1 → 2.7.0

package/dist/review/buildPrompt.js

@@ -7,8 +7,22 @@ export function buildPrompt({ diffText, context, focus, version, isStaticReview
         '',
         'You are an expert TypeScript, React 18, Material UI, and Emotion UI code reviewer. Be concise, specific, and actionable.',
         '',
-        '⚠️  CRITICAL CONSTRAINT: Review ONLY the files and changes shown in the diff below.',
-        'Do NOT reference, suggest, or mention files that are not in this diff.',
+        '⚠️  CRITICAL CONSTRAINTS:',
+        '1. Review ONLY the files and changes shown in the diff below.',
+        '2. Do NOT reference, suggest, or mention files that are not in this diff.',
+        '3. EVERY finding MUST include:',
+        '   - Exact file path and line number(s) that exist in the diff',
+        '   - A short quoted code snippet from that exact location as evidence',
+        '   - If you cannot quote the code, the finding is invalid',
+        '',
+        '💡 WHEN IN DOUBT, ASK - DON\'T GUESS:',
+        'If you need more information to give accurate feedback, ask clarifying questions instead of making assumptions.',
+        'Good questions help the coding agent provide better context. Examples:',
+        '  • "I see a new `useUserData` hook but don\'t see its tests - are they in a separate PR?"',
+        '  • "This component uses `CustomModal` - is this a new pattern or existing abstraction I should reference?"',
+        '  • "The error handling here is minimal - is there a global error boundary handling this?"',
+        '  • "I need to see the full `UserService` interface to verify this usage is type-safe"',
+        'Asking questions is ALWAYS better than asserting something you cannot verify from the diff.',
         '',
         'PRIORITY HIERARCHY:',
         '1. Project documentation (.cursor/rules/*, CODE_REVIEW.md, CONTRIBUTING.md) - HIGHEST PRIORITY',
@@ -24,10 +38,35 @@ export function buildPrompt({ diffText, context, focus, version, isStaticReview
         '- When project guidelines conflict with best practices, follow the project',
         focusLine,
         '',
+        'COMMON CODE SMELLS TO FLAG:',
+        '- Hardcoded pixel values or magic numbers (should use theme.spacing(), theme.ms(), or constants)',
+        '- Unnecessary useEffect hooks (prefer derived state, useMemo, or direct calculations)',
+        '- setTimeout/setInterval without clear cleanup or justification',
+        '- Direct DOM manipulation (document.querySelector, etc.) instead of React refs',
+        '- Inline styles with hardcoded colors/sizes instead of theme values',
+        '',
         `\n---\n${reviewType}${isStaticReview ? ' - Code Files' : ' (unified=0)'}:\n`,
         diffText,
         context ? '\n---\nProject context and guidelines (FOLLOW THESE STRICTLY):\n' + context : '',
-        '\n---\nOutput strictly as Markdown with the following sections:\n',
-        '1) Title + scope summary\n2) Quick Summary (3–6 bullets)\n3) Issues table: severity | file:lines | category | explanation | suggested fix\n4) Inline suggested edits for top issues\n5) Positive notes (mention when code follows project guidelines well)\n6) Next steps',
+        '',
+        '---',
+        'BEFORE YOU RESPOND - VALIDATE EACH FINDING:',
+        '- [ ] File path exists in the diff above',
+        '- [ ] Line number(s) exist in that file',
+        '- [ ] Code snippet is quoted verbatim from that location',
+        '- [ ] Issue ties to project rules/patterns (not just generic advice)',
+        '- [ ] If you cannot verify all above → ASK a specific question instead of asserting',
+        '',
+        'Remember: A good clarifying question is more valuable than a questionable assertion.',
+        '',
+        '---',
+        'Output strictly as Markdown with the following sections:',
+        '1) Title + scope summary',
+        '2) Quick Summary (3–6 bullets)',
+        '3) Issues table: severity | file:lines | category | explanation | suggested fix',
+        '4) Inline suggested edits for top issues',
+        '5) Clarifying Questions (if any) - list specific questions that would help provide better feedback',
+        '6) Positive notes (mention when code follows project guidelines well)',
+        '7) Next steps',
     ].join('\n');
 }

package/dist/review/buildPrompt.test.js

@@ -62,10 +62,12 @@ describe('buildPrompt', () => {
         });
         // Verify key sections are present
         expect(prompt).toContain('You are an expert TypeScript, React 18, Material UI, and Emotion UI code reviewer');
-        expect(prompt).toContain('CRITICAL CONSTRAINT: Review ONLY the files');
+        expect(prompt).toContain('CRITICAL CONSTRAINTS');
+        expect(prompt).toContain('Review ONLY the files');
+        expect(prompt).toContain('EVERY finding MUST include');
+        expect(prompt).toContain('BEFORE YOU RESPOND - VALIDATE EACH FINDING');
         expect(prompt).toContain('PRIORITY HIERARCHY');
         expect(prompt).toContain('CORE PRINCIPLES');
-        // Severity is determined by GPT-5 based on context, not pre-defined
         expect(prompt).toContain('Output strictly as Markdown with the following sections');
     });
     it('should include the diff text', () => {
@@ -92,8 +94,11 @@ describe('buildPrompt', () => {
         const prompt = buildPrompt({
             diffText: mockDiff,
         });
-        expect(prompt).toContain('CRITICAL CONSTRAINT: Review ONLY the files');
+        expect(prompt).toContain('CRITICAL CONSTRAINTS');
+        expect(prompt).toContain('Review ONLY the files');
         expect(prompt).toContain('Do NOT reference, suggest, or mention files that are not in this diff');
+        expect(prompt).toContain('EVERY finding MUST include');
+        expect(prompt).toContain('quoted code snippet from that exact location as evidence');
     });
     it('should include guidance hierarchy with proper priorities', () => {
         const prompt = buildPrompt({

package/dist/review/gatherContext.js

@@ -83,6 +83,140 @@ async function scanDirectory(dirPath, extensions, visited = new Set()) {
     }
     return files;
 }
+/**
+ * Parse diff to extract changed files
+ */
+function parseChangedFiles(diff) {
+    const files = [];
+    const lines = diff.split('\n');
+    for (const line of lines) {
+        // Match "diff --git a/path/to/file b/path/to/file"
+        if (line.startsWith('diff --git')) {
+            const match = line.match(/b\/(.+)$/);
+            if (match && match[1]) {
+                // Unescape Git-escaped paths (e.g., "My\ Button.tsx" → "My Button.tsx")
+                const filePath = match[1].replace(/\\(.)/g, '$1');
+                files.push(filePath);
+            }
+        }
+        // Also match "+++ b/path/to/file"
+        else if (line.startsWith('+++') && line.includes('b/')) {
+            const match = line.match(/\+\+\+ b\/(.+)$/);
+            if (match && match[1]) {
+                // Unescape Git-escaped paths
+                const filePath = match[1].replace(/\\(.)/g, '$1');
+                files.push(filePath);
+            }
+        }
+    }
+    return [...new Set(files)]; // Dedupe
+}
+/**
+ * Detect new exported components/functions per file
+ */
+function detectNewExports(diff) {
+    const exportsByFile = {};
+    let currentFile = null;
+    const lines = diff.split('\n');
+    for (const line of lines) {
+        // Track which file we're in
+        if (line.startsWith('+++ b/')) {
+            const match = line.match(/\+\+\+ b\/(.+)$/);
+            // Unescape Git-escaped paths to match parseChangedFiles behavior
+            currentFile = match && match[1] ? match[1].replace(/\\(.)/g, '$1') : null;
+            continue;
+        }
+        // Only look at added lines in a known file
+        if (!line.startsWith('+') || !currentFile)
+            continue;
+        // Match: export function ComponentName
+        // Match: export default function Component
+        // Match: export async function getData
+        // Match: export const ComponentName
+        // Match: export class ComponentName
+        const match = line.match(/^\+\s*export\s+(?:default\s+)?(?:async\s+)?(?:function|const|class)\s+([A-Za-z_]\w*)/);
+        if (match && match[1]) {
+            if (!exportsByFile[currentFile]) {
+                exportsByFile[currentFile] = [];
+            }
+            if (!exportsByFile[currentFile].includes(match[1])) {
+                exportsByFile[currentFile].push(match[1]);
+            }
+        }
+    }
+    return exportsByFile;
+}
+/**
+ * Check if test file exists for given source file
+ */
+async function checkForTestFile(sourcePath, baseDir) {
+    const testPatterns = [
+        // Same directory patterns
+        sourcePath.replace(/\.tsx?$/, '.test.ts'),
+        sourcePath.replace(/\.tsx?$/, '.test.tsx'),
+        sourcePath.replace(/\.tsx?$/, '.spec.ts'),
+        sourcePath.replace(/\.tsx?$/, '.spec.tsx'),
+        // __tests__ directory patterns
+        sourcePath.replace(/^src\//, 'src/__tests__/').replace(/\.tsx?$/, '.test.ts'),
+        sourcePath.replace(/^src\//, 'src/__tests__/').replace(/\.tsx?$/, '.test.tsx'),
+        sourcePath.replace(/^src\//, 'src/__tests__/').replace(/\.tsx?$/, '.spec.ts'),
+        sourcePath.replace(/^src\//, 'src/__tests__/').replace(/\.tsx?$/, '.spec.tsx'),
+    ];
+    for (const pattern of testPatterns) {
+        const testPath = join(baseDir, pattern);
+        const exists = await readIfExists(testPath);
+        if (exists !== null) {
+            return pattern;
+        }
+    }
+    return null;
+}
+/**
+ * Gather smart context based on the diff
+ */
+export async function gatherSmartContext(diff, baseDir) {
+    const cwd = baseDir || process.cwd();
+    const chunks = [];
+    let totalSize = 0;
+    const MAX_SMART_CONTEXT_SIZE = 20_000; // 20KB budget for smart context
+    // 1. Extract changed files from diff
+    const changedFiles = parseChangedFiles(diff);
+    // 2. Read full content of changed files (up to 3 files to stay within budget)
+    for (const file of changedFiles.slice(0, 3)) {
+        if (totalSize >= MAX_SMART_CONTEXT_SIZE)
+            break;
+        const fullPath = join(cwd, file);
+        const content = await readIfExists(fullPath);
+        if (content) {
+            const capped = content.slice(0, 8000); // Cap each file at 8KB
+            chunks.push(`\n<!-- FULL CONTEXT: ${file} -->\n${capped}`);
+            totalSize += capped.length;
+        }
+    }
+    // 3. Check for test coverage when new exports are detected
+    const exportsByFile = detectNewExports(diff);
+    const filesWithExports = Object.keys(exportsByFile);
+    if (filesWithExports.length > 0) {
+        for (const file of filesWithExports) {
+            // Only check TypeScript/React files
+            if (!/\.(ts|tsx)$/.test(file))
+                continue;
+            const exportsForFile = exportsByFile[file];
+            const testFile = await checkForTestFile(file, cwd);
+            if (!testFile) {
+                // Match test file extension to source extension
+                const suggestedTest = file.endsWith('.tsx')
+                    ? file.replace(/\.tsx$/, '.test.tsx')
+                    : file.replace(/\.ts$/, '.test.ts');
+                chunks.push(`\n<!-- TEST COVERAGE: ${file} -->\n⚠️  No test file found for ${file} which exports: ${exportsForFile.join(', ')}\nConsider adding: ${suggestedTest}`);
+            }
+            else {
+                chunks.push(`\n<!-- TEST COVERAGE: ${file} -->\n✓ Test file exists: ${testFile}`);
+            }
+        }
+    }
+    return chunks.join('\n');
+}
 export async function gatherContext(baseDir) {
     const chunks = [];
     const processedPaths = new Set();

package/dist/review/gatherContext.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { gatherContext } from './gatherContext.js';
+import { gatherContext, gatherSmartContext } from './gatherContext.js';
 import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
 vi.mock('node:fs', () => ({
     promises: {
         readFile: vi.fn(),
@@ -353,3 +354,357 @@ describe('gatherContext', () => {
         });
     });
 });
+describe('gatherSmartContext', () => {
+    const mockCwd = '/test/workspace';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('File Parsing', () => {
+        it('should extract changed files from diff', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/components/UserCard.tsx b/src/components/UserCard.tsx
+index 1234567..abcdefg 100644
+--- a/src/components/UserCard.tsx
++++ b/src/components/UserCard.tsx
+@@ -1,3 +1,4 @@
++import { useState } from 'react';
+ export function UserCard() {`;
+            mockReadFile.mockResolvedValue('// Full file content\nexport function UserCard() {}');
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should read the full file
+            expect(mockReadFile).toHaveBeenCalledWith(join(mockCwd, 'src/components/UserCard.tsx'), 'utf8');
+            expect(result).toContain('FULL CONTEXT: src/components/UserCard.tsx');
+            expect(result).toContain('export function UserCard()');
+        });
+        it('should handle multiple changed files', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/UserCard.tsx b/src/UserCard.tsx
++++ b/src/UserCard.tsx
+diff --git a/src/UserList.tsx b/src/UserList.tsx
++++ b/src/UserList.tsx
+diff --git a/src/utils.ts b/src/utils.ts
++++ b/src/utils.ts`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('UserCard'))
+                    return 'UserCard content';
+                if (path.includes('UserList'))
+                    return 'UserList content';
+                if (path.includes('utils'))
+                    return 'utils content';
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should read up to 3 files
+            expect(result).toContain('UserCard content');
+            expect(result).toContain('UserList content');
+            expect(result).toContain('utils content');
+        });
+        it('should cap at 3 files to stay within budget', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/file1.tsx b/file1.tsx
++++ b/file1.tsx
+diff --git a/file2.tsx b/file2.tsx
++++ b/file2.tsx
+diff --git a/file3.tsx b/file3.tsx
++++ b/file3.tsx
+diff --git a/file4.tsx b/file4.tsx
++++ b/file4.tsx`;
+            mockReadFile.mockResolvedValue('file content');
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should only read first 3 files
+            expect(mockReadFile).toHaveBeenCalledTimes(3);
+        });
+        it('should cap each file at 8KB', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/large.tsx b/large.tsx
++++ b/large.tsx`;
+            const largeContent = 'x'.repeat(20000); // 20KB
+            mockReadFile.mockResolvedValue(largeContent);
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should be capped at 8000 chars
+            const contentMatch = result.match(/FULL CONTEXT:.*?\n(.*)/s);
+            if (contentMatch) {
+                expect(contentMatch[1].length).toBeLessThanOrEqual(8000);
+            }
+        });
+    });
+    describe('New Exports Detection', () => {
+        it('should detect new exported components per file', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/UserCard.tsx b/src/UserCard.tsx
+index abc123..def456 100644
+--- a/src/UserCard.tsx
++++ b/src/UserCard.tsx
+@@ -1,3 +1,4 @@
++export function UserCard() {}
++export const UserList = () => {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                // Only return content for the source file, not test files
+                if (path.includes('UserCard.tsx') && !path.includes('test') && !path.includes('spec') && !path.includes('__tests__')) {
+                    return 'export function UserCard() {}';
+                }
+                // All test file patterns should fail
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should warn about missing tests for THIS file's exports
+            expect(result).toContain('TEST COVERAGE: src/UserCard.tsx');
+            expect(result).toContain('No test file found');
+            expect(result).toContain('UserCard');
+            expect(result).toContain('UserList');
+        });
+        it('should detect test files when they exist', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/UserCard.tsx b/src/UserCard.tsx
+index abc123..def456 100644
+--- a/src/UserCard.tsx
++++ b/src/UserCard.tsx
+@@ -1,3 +1,4 @@
++export function UserCard() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('UserCard.tsx') && !path.includes('test'))
+                    return 'export function UserCard() {}';
+                if (path.includes('UserCard.test.tsx'))
+                    return 'test content';
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should confirm test exists
+            expect(result).toContain('TEST COVERAGE');
+            expect(result).toContain('Test file exists');
+            expect(result).toContain('UserCard.test.tsx');
+        });
+        it('should find test file in spec.ts pattern', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/UserService.ts b/src/UserService.ts
++++ b/src/UserService.ts
+@@ -1,3 +1,4 @@
++export class UserService {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                const pathStr = String(path);
+                // Source file
+                if (pathStr.endsWith('src/UserService.ts')) {
+                    return 'export class UserService {}';
+                }
+                // Test file found at .spec.ts pattern
+                if (pathStr.includes('UserService.spec.ts')) {
+                    return 'test content';
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should have found the test file and reported it
+            expect(result).toContain('TEST COVERAGE');
+            expect(result).toContain('Test file exists');
+            expect(result).toContain('UserService.spec.ts');
+        });
+        it('should only check TypeScript/React files for tests', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/README.md b/README.md
+index abc..def 100644
+--- a/README.md
++++ b/README.md
+@@ -1,1 +1,2 @@
++export function Something() {}
+diff --git a/src/Component.tsx b/src/Component.tsx
+index ghi..jkl 100644
+--- a/src/Component.tsx
++++ b/src/Component.tsx
+@@ -1,1 +1,2 @@
++export function Component() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('README.md'))
+                    return 'readme content';
+                if (path.includes('Component.tsx') && !path.includes('test'))
+                    return 'component content';
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should only check Component.tsx, not README.md
+            expect(result).toContain('TEST COVERAGE: src/Component.tsx');
+            expect(result).not.toContain('TEST COVERAGE: README.md');
+        });
+        it('should detect lowercase and async function exports', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/api.ts b/src/api.ts
+index abc..def 100644
+--- a/src/api.ts
++++ b/src/api.ts
+@@ -1,1 +1,3 @@
++export async function fetchUserData() {}
++export function parseResponse() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('api.ts') && !path.includes('test')) {
+                    return 'export async function fetchUserData() {}';
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should detect both async and regular lowercase functions
+            expect(result).toContain('TEST COVERAGE: src/api.ts');
+            expect(result).toContain('fetchUserData');
+            expect(result).toContain('parseResponse');
+            // Should suggest .test.ts for .ts files
+            expect(result).toContain('api.test.ts');
+        });
+        it('should detect default exports', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/MyComponent.tsx b/src/MyComponent.tsx
+index abc..def 100644
+--- a/src/MyComponent.tsx
++++ b/src/MyComponent.tsx
+@@ -1,1 +1,2 @@
++export default function MyComponent() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('MyComponent.tsx') && !path.includes('test')) {
+                    return 'export default function MyComponent() {}';
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should detect default export
+            expect(result).toContain('TEST COVERAGE: src/MyComponent.tsx');
+            expect(result).toContain('MyComponent');
+            // Should suggest .test.tsx for .tsx files
+            expect(result).toContain('MyComponent.test.tsx');
+        });
+        it('should find tests in __tests__ directory', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/components/Button.tsx b/src/components/Button.tsx
+index abc..def 100644
+--- a/src/components/Button.tsx
++++ b/src/components/Button.tsx
+@@ -1,1 +1,2 @@
++export function Button() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                const pathStr = String(path);
+                if (pathStr.endsWith('src/components/Button.tsx')) {
+                    return 'export function Button() {}';
+                }
+                // Test file in __tests__ directory
+                if (pathStr.includes('src/__tests__/components/Button.test.tsx')) {
+                    return 'test content';
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should find test in __tests__ directory
+            expect(result).toContain('TEST COVERAGE');
+            expect(result).toContain('Test file exists');
+            expect(result).toContain('__tests__/components/Button.test.tsx');
+        });
+        it('should detect empty test files correctly', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/UserCard.tsx b/src/UserCard.tsx
+index abc..def 100644
+--- a/src/UserCard.tsx
++++ b/src/UserCard.tsx
+@@ -1,1 +1,2 @@
++export function UserCard() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                if (path.includes('UserCard.tsx') && !path.includes('test')) {
+                    return 'export function UserCard() {}';
+                }
+                // Empty test file (should still be detected!)
+                if (path.includes('UserCard.test.tsx')) {
+                    return ''; // Empty string
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should recognize empty test file as existing
+            expect(result).toContain('TEST COVERAGE');
+            expect(result).toContain('Test file exists');
+            expect(result).not.toContain('No test file found');
+        });
+        it('should handle files without exports gracefully', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/utils.ts b/src/utils.ts
+index abc..def 100644
+--- a/src/utils.ts
++++ b/src/utils.ts
+@@ -1,1 +1,2 @@
++// Just a comment, no exports`;
+            mockReadFile.mockResolvedValue('// Just a comment');
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should not complain about missing tests if no exports
+            expect(result).not.toContain('No test file found');
+            // Should still include full file context
+            expect(result).toContain('FULL CONTEXT: src/utils.ts');
+        });
+    });
+    describe('Budget Management', () => {
+        it('should respect 20KB budget for smart context', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/file1.tsx b/file1.tsx
++++ b/file1.tsx
+diff --git a/file2.tsx b/file2.tsx
++++ b/file2.tsx
+diff --git a/file3.tsx b/file3.tsx
++++ b/file3.tsx`;
+            // Each file is 8KB (within per-file limit)
+            mockReadFile.mockResolvedValue('x'.repeat(8000));
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should not exceed 20KB total (3 files × 8KB = 24KB, but budget is 20KB)
+            expect(result.length).toBeLessThanOrEqual(25000); // Small buffer for markers
+        });
+        it('should handle missing files gracefully', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/missing.tsx b/missing.tsx
++++ b/missing.tsx`;
+            mockReadFile.mockRejectedValue(new Error('ENOENT'));
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should not throw, just skip the file
+            expect(result).toBeDefined();
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle empty diff', async () => {
+            const result = await gatherSmartContext('', mockCwd);
+            expect(result).toBe('');
+        });
+        it('should handle diff with no file changes', async () => {
+            const diff = `Some random text
+without any file markers`;
+            const result = await gatherSmartContext(diff, mockCwd);
+            expect(result).toBe('');
+        });
+        it('should handle malformed diff gracefully', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            mockReadFile.mockRejectedValue(new Error('ENOENT'));
+            const diff = `diff --git a/
++++ b/
+---malformed---`;
+            const result = await gatherSmartContext(diff, mockCwd);
+            expect(result).toBeDefined();
+        });
+        it('should unescape Git-escaped file paths', async () => {
+            const mockReadFile = vi.mocked(fs.readFile);
+            const diff = `diff --git a/src/components/My\\ Button.tsx b/src/components/My\\ Button.tsx
+index abc..def 100644
+--- a/src/components/My\\ Button.tsx
++++ b/src/components/My\\ Button.tsx
+@@ -1,1 +1,2 @@
++export function MyButton() {}`;
+            mockReadFile.mockImplementation(async (path) => {
+                const pathStr = String(path);
+                // Should be called with unescaped path
+                if (pathStr.includes('src/components/My Button.tsx')) {
+                    return 'export function MyButton() {}';
+                }
+                return Promise.reject(new Error('ENOENT'));
+            });
+            const result = await gatherSmartContext(diff, mockCwd);
+            // Should have read the file with unescaped path
+            expect(mockReadFile).toHaveBeenCalledWith(join(mockCwd, 'src/components/My Button.tsx'), 'utf8');
+            expect(result).toContain('FULL CONTEXT: src/components/My Button.tsx');
+            // Should also detect exports with unescaped path
+            expect(result).toContain('TEST COVERAGE: src/components/My Button.tsx');
+            expect(result).toContain('MyButton');
+        });
+    });
+});

package/dist/tools/performCodeReview.js

@@ -1,4 +1,4 @@
-import { gatherContext } from '../review/gatherContext.js';
+import { gatherContext, gatherSmartContext } from '../review/gatherContext.js';
 import { buildPrompt } from '../review/buildPrompt.js';
 import { invokeAgent } from '../review/invokeAgent.js';
 import { formatOutput } from '../review/formatOutput.js';
@@ -37,14 +37,22 @@ export async function performCodeReview(input, onProgress) {
         : shouldSkip
             ? ''
             : await gatherContext(input.workspaceDir);
+    // Gather smart context based on the diff (full files + test coverage)
+    let smartContext = '';
+    if (!shouldSkip && !usingCustom && input.workspaceDir) {
+        smartContext = await gatherSmartContext(input.content, input.workspaceDir);
+    }
+    const combinedContext = [context, smartContext].filter(Boolean).join('\n\n');
     // Log context gathering results (informational, not errors!)
-    const hasCursorRules = context.includes('.cursor/rules');
+    const hasCursorRules = combinedContext.includes('.cursor/rules');
     if (hasCursorRules) {
-        const cursorFiles = (context.match(/<!-- \.cursor\/rules\/[^>]+ -->/g) || []);
-        console.error(`[codex-review-mcp] Context: ${context.length} chars with .cursor/rules → ${cursorFiles.map(f => f.replace('<!-- ', '').replace(' -->', '')).join(', ')}`);
+        const cursorFiles = (combinedContext.match(/<!-- \.cursor\/rules\/[^>]+ -->/g) || []);
+        const smartInfo = smartContext ? ` + ${smartContext.length} smart context` : '';
+        console.error(`[codex-review-mcp] Context: ${context.length} chars with .cursor/rules → ${cursorFiles.map(f => f.replace('<!-- ', '').replace(' -->', '')).join(', ')}${smartInfo}`);
     }
-    else if (context.length > 0) {
-        console.error(`[codex-review-mcp] Context: ${context.length} chars from package.json, tsconfig.json, etc. (no .cursor/rules in repo)`);
+    else if (combinedContext.length > 0) {
+        const smartInfo = smartContext ? ` + ${smartContext.length} smart context` : '';
+        console.error(`[codex-review-mcp] Context: ${context.length} chars from package.json, tsconfig.json, etc. (no .cursor/rules in repo)${smartInfo}`);
     }
     else {
         console.error(`[codex-review-mcp] No project context found (generic review mode)`);
@@ -56,7 +64,7 @@ export async function performCodeReview(input, onProgress) {
     const isStaticReview = input.contentType === 'code';
     const prompt = buildPrompt({
         diffText: input.content,
-        context,
+        context: combinedContext,
         focus: input.focus,
         version: VERSION,
         isStaticReview

package/package.json

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