codex-review-mcp 1.4.0 → 2.0.1

package/dist/review/collectDiff.test.js

@@ -0,0 +1,490 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { collectDiff } from './collectDiff.js';
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+vi.mock('node:child_process');
+vi.mock('node:fs');
+describe('collectDiff', () => {
+    const mockExec = vi.mocked(execFile);
+    const mockStat = vi.mocked(fs.stat);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('Auto Mode - Uncommitted Changes', () => {
+        it('should detect and review uncommitted changes', async () => {
+            // Mock git root detection
+            mockStat.mockResolvedValueOnce({});
+            // Mock git status showing changes
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  src/test.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('HEAD')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, {
+                        stdout: `diff --git a/test.ts b/test.ts
++++ b/test.ts
++added line`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('added line');
+            expect(result).toContain('diff --git');
+        });
+        it('should handle repositories with no HEAD commit yet', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'A  new-file.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('HEAD')) {
+                    cb(new Error('fatal: ambiguous argument'), null);
+                }
+                else if (args?.includes('--staged')) {
+                    cb(null, {
+                        stdout: `diff --git a/new-file.ts b/new-file.ts
++++ b/new-file.ts
++new file content`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('new file content');
+        });
+        it('should include untracked files in auto mode', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  tracked.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('HEAD')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('ls-files') && args?.includes('--others')) {
+                    cb(null, { stdout: 'untracked.ts\n', stderr: '' });
+                }
+                else if (args?.includes('diff') && args?.includes('/dev/null')) {
+                    // Untracked file diff
+                    const error = new Error('');
+                    error.stdout = `diff --git /dev/null b/untracked.ts
++++ b/untracked.ts
++untracked content`;
+                    cb(error, null);
+                }
+                else if (args?.includes('diff') && !args?.includes('/dev/null')) {
+                    cb(null, {
+                        stdout: `diff --git a/tracked.ts b/tracked.ts
++++ b/tracked.ts
++tracked change`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('tracked change');
+            expect(result).toContain('untracked content');
+        });
+    });
+    describe('Auto Mode - Branch vs Default', () => {
+        it('should compare current branch to default branch when no uncommitted changes', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' }); // No uncommitted changes
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(null, { stdout: '  HEAD branch: main\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('--abbrev-ref')) {
+                    cb(null, { stdout: 'feature-branch\n', stderr: '' });
+                }
+                else if (args?.includes('diff') && args?.includes('main...HEAD')) {
+                    cb(null, {
+                        stdout: `diff --git a/feature.ts b/feature.ts
++++ b/feature.ts
++feature code`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('feature code');
+        });
+        it('should return empty when on default branch with clean tree', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(null, { stdout: '  HEAD branch: main\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('--abbrev-ref')) {
+                    cb(null, { stdout: 'main\n', stderr: '' });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toBe('');
+        });
+        it('should fallback to master if main does not exist', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(new Error('No remote'), null);
+                }
+                else if (args?.includes('--verify main')) {
+                    cb(new Error('Not found'), null);
+                }
+                else if (args?.includes('--verify master')) {
+                    cb(null, { stdout: 'def456\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('--abbrev-ref')) {
+                    cb(null, { stdout: 'feature\n', stderr: '' });
+                }
+                else if (args?.includes('diff') && args?.includes('master...HEAD')) {
+                    cb(null, {
+                        stdout: `diff --git a/file.ts b/file.ts
++content`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('content');
+        });
+        it('should use HEAD~1 as last resort baseline', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(new Error('No remote'), null);
+                }
+                else if (args?.includes('--verify main')) {
+                    cb(new Error('Not found'), null);
+                }
+                else if (args?.includes('--verify master')) {
+                    cb(new Error('Not found'), null);
+                }
+                else if (args?.includes('--verify HEAD~1')) {
+                    cb(null, { stdout: 'ghi789\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse') && args?.includes('--abbrev-ref')) {
+                    cb(null, { stdout: 'orphan-branch\n', stderr: '' });
+                }
+                else if (args?.includes('diff') && args?.includes('HEAD~1...HEAD')) {
+                    cb(null, {
+                        stdout: `diff --git a/file.ts b/file.ts
++last commit change`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('last commit change');
+        });
+    });
+    describe('Explicit Target Modes', () => {
+        it('should review staged changes when target is staged', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('--staged')) {
+                    cb(null, {
+                        stdout: `diff --git a/staged.ts b/staged.ts
++staged content`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'staged' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('staged content');
+        });
+        it('should review HEAD changes when target is head', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('diff') && args?.includes('HEAD')) {
+                    cb(null, {
+                        stdout: `diff --git a/head.ts b/head.ts
++head changes`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'head' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('head changes');
+        });
+        it('should compare custom refs when target is range', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('develop...feature')) {
+                    cb(null, {
+                        stdout: `diff --git a/range.ts b/range.ts
++range diff`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = {
+                target: 'range',
+                baseRef: 'develop',
+                headRef: 'feature'
+            };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('range diff');
+        });
+        it('should throw error when range mode missing refs', async () => {
+            const input = { target: 'range' };
+            await expect(collectDiff(input, '/test/repo')).rejects.toThrow('range target requires baseRef and headRef');
+        });
+    });
+    describe('Path Filtering', () => {
+        it('should filter diff to specified paths', async () => {
+            mockStat.mockResolvedValueOnce({});
+            let capturedArgs = [];
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                capturedArgs = args || [];
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  src/test.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, {
+                        stdout: `diff --git a/src/test.ts b/src/test.ts
++filtered content`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = {
+                target: 'auto',
+                paths: ['src/test.ts', 'src/utils.ts']
+            };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).toContain('filtered content');
+            // Verify paths were passed to git diff
+            expect(capturedArgs.some(arg => arg === 'src/test.ts')).toBe(true);
+        });
+        it('should filter out ignored patterns (dist, build, lock files)', async () => {
+            mockStat.mockResolvedValueOnce({});
+            let capturedArgs = [];
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                capturedArgs = args || [];
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  src/test.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                return {};
+            });
+            const input = {
+                target: 'auto',
+                paths: ['dist/bundle.js', 'package-lock.json', 'src/test.ts']
+            };
+            await collectDiff(input, '/test/repo');
+            // Should only include src/test.ts, not dist or lock files
+            expect(capturedArgs.includes('dist/bundle.js')).toBe(false);
+            expect(capturedArgs.includes('package-lock.json')).toBe(false);
+            expect(capturedArgs.some(arg => arg === 'src/test.ts')).toBe(true);
+        });
+    });
+    describe('Binary Files and Size Limits', () => {
+        it('should filter out binary file diff lines', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  image.png\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, {
+                        stdout: `Binary files a/image.png and b/image.png differ
+diff --git a/code.ts b/code.ts
++code change`,
+                        stderr: ''
+                    });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result).not.toContain('Binary files');
+            expect(result).toContain('code change');
+        });
+        it('should cap diff at ~300k characters', async () => {
+            mockStat.mockResolvedValueOnce({});
+            const hugeDiff = 'x'.repeat(400000);
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  huge.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, { stdout: hugeDiff, stderr: '' });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo');
+            expect(result.length).toBeLessThanOrEqual(300100); // Cap + truncation message
+            expect(result).toContain('<!-- diff truncated -->');
+        });
+    });
+    describe('Repository Detection', () => {
+        it('should find git repo by walking up directory tree', async () => {
+            // First call fails (not in /test/repo)
+            // Second call fails (not in /test)
+            // Third call succeeds (found .git in /)
+            mockStat
+                .mockRejectedValueOnce(new Error('ENOENT'))
+                .mockRejectedValueOnce(new Error('ENOENT'))
+                .mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                if (args?.includes('status')) {
+                    cb(null, { stdout: 'M  test.ts\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'abc123\n', stderr: '' });
+                }
+                else if (args?.includes('diff')) {
+                    cb(null, { stdout: 'diff content', stderr: '' });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            const result = await collectDiff(input, '/test/repo/deep/path');
+            expect(result).toContain('diff content');
+        });
+        it('should use workspaceDir when explicitly provided', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                // Verify cwd is set to workspaceDir
+                expect(opts && typeof opts === 'object' && 'cwd' in opts ? opts.cwd : undefined).toBe('/explicit/workspace');
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(null, { stdout: '  HEAD branch: main\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'main\n', stderr: '' });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            await collectDiff(input, '/explicit/workspace');
+        });
+        it('should throw error when workspaceDir provided but no git repo found', async () => {
+            mockStat.mockRejectedValue(new Error('ENOENT'));
+            const input = { target: 'auto' };
+            await expect(collectDiff(input, '/not/a/repo')).rejects.toThrow('Could not locate a Git repository');
+        });
+        it('should respect environment variables for repo root', async () => {
+            const originalEnv = { ...process.env };
+            process.env.CODEX_REPO_ROOT = '/env/workspace';
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                expect(opts && typeof opts === 'object' && 'cwd' in opts ? opts.cwd : undefined).toBe('/env/workspace');
+                if (args?.includes('status')) {
+                    cb(null, { stdout: '', stderr: '' });
+                }
+                else if (args?.includes('remote show origin')) {
+                    cb(null, { stdout: '  HEAD branch: main\n', stderr: '' });
+                }
+                else if (args?.includes('rev-parse')) {
+                    cb(null, { stdout: 'main\n', stderr: '' });
+                }
+                return {};
+            });
+            const input = { target: 'auto' };
+            await collectDiff(input);
+            process.env = originalEnv;
+        });
+    });
+    describe('Error Handling', () => {
+        it('should provide helpful error message when git command fails', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                const cb = callback || opts;
+                const error = new Error('git error');
+                error.stderr = 'fatal: not a git repository';
+                cb(error, null);
+                return {};
+            });
+            const input = { target: 'auto' };
+            await expect(collectDiff(input, '/test/repo')).rejects.toThrow('Failed to collect git diff');
+        });
+        it('should handle git command timeout gracefully', async () => {
+            mockStat.mockResolvedValueOnce({});
+            mockExec.mockImplementation((file, args, opts, callback) => {
+                // Verify maxBuffer is set
+                expect(opts && typeof opts === 'object' && 'maxBuffer' in opts ? opts.maxBuffer : undefined).toBe(10 * 1024 * 1024); // 10MB
+                const cb = callback || opts;
+                const error = new Error('timeout');
+                error.code = 'ETIMEDOUT';
+                cb(error, null);
+                return {};
+            });
+            const input = { target: 'auto' };
+            await expect(collectDiff(input, '/test/repo')).rejects.toThrow();
+        });
+    });
+});

package/dist/review/formatOutput.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest';
+import { formatOutput } from './formatOutput.js';
+describe('formatOutput', () => {
+    describe('Valid Agent Output', () => {
+        it('should return agent markdown as-is when valid', () => {
+            const agentOutput = '# Code Review\n\n## Issues\n\n- Issue 1\n- Issue 2';
+            const result = formatOutput(agentOutput);
+            expect(result).toBe(agentOutput);
+        });
+        it('should preserve formatting and special characters', () => {
+            const agentOutput = `# Review
+      
+## Summary
+- ✅ Good: Type safety
+- ⚠️ Warning: Performance issue
+- ❌ Critical: Security vulnerability
+
+\`\`\`typescript
+function fix() {
+  return true;
+}
+\`\`\`
+
+**Bold** and *italic* text.`;
+            const result = formatOutput(agentOutput);
+            expect(result).toBe(agentOutput);
+            expect(result).toContain('✅');
+            expect(result).toContain('```typescript');
+            expect(result).toContain('**Bold**');
+        });
+        it('should handle multi-line markdown with code blocks', () => {
+            const agentOutput = `# Code Review
+
+## Issues Found
+
+| Severity | File | Issue |
+|----------|------|-------|
+| High | test.ts | Security issue |
+
+\`\`\`diff
+- const bad = eval(userInput);
++ const good = JSON.parse(userInput);
+\`\`\``;
+            const result = formatOutput(agentOutput);
+            expect(result).toBe(agentOutput);
+            expect(result).toContain('```diff');
+            expect(result).toContain('| Severity |');
+        });
+        it('should handle output with only whitespace around content', () => {
+            const agentOutput = '\n\n# Review\n\nContent here\n\n';
+            const result = formatOutput(agentOutput);
+            expect(result).toBe(agentOutput);
+        });
+    });
+    describe('Empty or Invalid Output', () => {
+        it('should return fallback message when output is empty string', () => {
+            const result = formatOutput('');
+            expect(result).toContain('# Code Review');
+            expect(result).toContain('No issues detected or empty output from agent');
+        });
+        it('should return fallback message when output is only whitespace', () => {
+            const result = formatOutput('   \n\n  \t  ');
+            expect(result).toContain('# Code Review');
+            expect(result).toContain('No issues detected or empty output from agent');
+        });
+        it('should return fallback message when output is null/undefined', () => {
+            const result = formatOutput('');
+            expect(result).toContain('# Code Review');
+            expect(result).toContain('No issues detected');
+        });
+        it('should return valid markdown format for fallback', () => {
+            const result = formatOutput('');
+            // Should be valid markdown
+            expect(result).toMatch(/^# Code Review\n\nNo issues detected/);
+            // Should not have trailing whitespace issues
+            const lines = result.split('\n');
+            expect(lines[0]).toBe('# Code Review');
+            expect(lines[1]).toBe('');
+            expect(lines[2]).toContain('No issues detected');
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle extremely long output', () => {
+            const longOutput = '# Review\n\n' + 'x'.repeat(100000);
+            const result = formatOutput(longOutput);
+            expect(result).toBe(longOutput);
+            expect(result.length).toBeGreaterThan(100000);
+        });
+        it('should handle output with unicode characters', () => {
+            const unicode = '# Review 🎉\n\n## 日本語\n\n- Emoji: 🚀 ✨ 🎯\n- Chinese: 中文\n- Arabic: العربية';
+            const result = formatOutput(unicode);
+            expect(result).toBe(unicode);
+            expect(result).toContain('🎉');
+            expect(result).toContain('日本語');
+        });
+        it('should handle output with HTML-like content', () => {
+            const htmlContent = `# Review
+
+<div>This looks like HTML</div>
+
+<script>alert('test')</script>`;
+            const result = formatOutput(htmlContent);
+            // Should preserve as-is (agent output is trusted)
+            expect(result).toBe(htmlContent);
+            expect(result).toContain('<div>');
+        });
+        it('should handle output with markdown escapes', () => {
+            const escaped = '# Review\n\n\\# Not a heading\n\n\\*Not italic\\*';
+            const result = formatOutput(escaped);
+            expect(result).toBe(escaped);
+            expect(result).toContain('\\#');
+        });
+    });
+    describe('Real-World Agent Output Patterns', () => {
+        it('should handle typical GPT-5 Codex review format', () => {
+            const typicalOutput = `# Code Review: Feature Implementation
+
+## Quick Summary
+- Added new user authentication flow
+- Updated API endpoints
+- Improved error handling
+
+## Issues
+
+| Severity | Location | Category | Issue | Fix |
+|----------|----------|----------|-------|-----|
+| Medium | auth.ts:45 | Security | Plain text password | Use bcrypt |
+| Low | api.ts:23 | Style | Missing JSDoc | Add documentation |
+
+## Detailed Fixes
+
+### 1. Password Hashing
+
+\`\`\`typescript
+// Before
+const user = { password: req.body.password };
+
+// After
+const user = { 
+  password: await bcrypt.hash(req.body.password, 10) 
+};
+\`\`\`
+
+## Positive Notes
+- Good use of TypeScript types
+- Proper error boundaries
+
+## Next Steps
+1. Review security practices
+2. Add unit tests`;
+            const result = formatOutput(typicalOutput);
+            expect(result).toBe(typicalOutput);
+            expect(result).toContain('Quick Summary');
+            expect(result).toContain('| Severity |');
+            expect(result).toContain('```typescript');
+            expect(result).toContain('Positive Notes');
+        });
+    });
+});

package/dist/review/gatherContext.js

@@ -82,10 +82,10 @@ async function scanDirectory(dirPath, extensions, visited = new Set()) {
     }
     return files;
 }
-export async function gatherContext() {
+export async function gatherContext(baseDir) {
     const chunks = [];
     const processedPaths = new Set();
-    const cwd = process.cwd();
+    const cwd = baseDir || process.cwd();
     for (const pattern of CANDIDATE_FILES) {
         // Check global size guard before processing each pattern
         if (chunks.join('').length > 50_000)