codecritique 2.0.7 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",

package/src/project-analyzer.js

@@ -405,8 +405,25 @@ export class ProjectAnalyzer {
               return depthA - depthB;
             });
 
-            // Take only the first 500 after sorting to ensure we have shallow files
-            const sortedFiles = allFiles.slice(0, TERM_SEARCH_CONTENT_CANDIDATE_LIMIT);
+            // Dedupe by path before capping: transient duplicate rows can exist for
+            // the same file (different content_hash) when a partial run hasn't pruned
+            // stale embeddings, and they would otherwise consume candidate slots and
+            // bloat the content query. Keep the shallowest occurrence (allFiles is
+            // already depth-sorted), then take the first 500 distinct shallow files.
+            const seenPaths = new Set();
+            const sortedFiles = [];
+            for (const file of allFiles) {
+              if (file.path) {
+                if (seenPaths.has(file.path)) {
+                  continue;
+                }
+                seenPaths.add(file.path);
+              }
+              sortedFiles.push(file);
+              if (sortedFiles.length >= TERM_SEARCH_CONTENT_CANDIDATE_LIMIT) {
+                break;
+              }
+            }
             if (sortedFiles.length === 0) {
               return [];
             }
@@ -415,14 +432,20 @@ export class ProjectAnalyzer {
             const contentByPath = new Map();
             if (candidatePaths.length > 0) {
               const pathList = candidatePaths.map((candidatePath) => `'${escapeSqlString(candidatePath)}'`).join(', ');
+              // No row limit here: the result set is already bounded by the IN list of
+              // distinct candidate paths. A limit could truncate rows when duplicate
+              // rows exist for a path, silently dropping content for matched files.
               const contentResults = await table
                 .query()
                 .select(['path', 'content'])
                 .where(`${projectPathFilter} AND path IN (${pathList})`)
-                .limit(TERM_SEARCH_CONTENT_CANDIDATE_LIMIT)
                 .toArray();
 
               for (const result of contentResults) {
+                // Prefer non-empty content when duplicate rows exist for a path.
+                if (contentByPath.get(result.path)) {
+                  continue;
+                }
                 contentByPath.set(result.path, result.content || '');
               }
             }

package/src/rag-analyzer.js

@@ -27,6 +27,7 @@ import { isGenericDocument, getGenericDocumentContext } from './utils/document-d
 import { isTestFile, shouldProcessFile } from './utils/file-validation.js';
 import { detectFileType, detectLanguageFromExtension } from './utils/language-detection.js';
 import { debug, verboseLog } from './utils/logging.js';
+import { formatPlannedHolisticFileContext, mergeHolisticFileContextPlans } from './utils/pr-file-context.js';
 import { addLineNumbers } from './utils/string-utils.js';
 
 // Constants for content processing
@@ -471,8 +472,10 @@ async function runAnalysis(filePath, options = {}) {
     let fullFileContent;
     if (options.diffOnly && options.diffContent) {
       content = options.diffContent;
-      // For PR reviews, always read the full file content for context awareness
-      fullFileContent = await readTextFile(filePath);
+      // For PR reviews, always read the full file content for context awareness.
+      // Tolerate a missing/unreadable file (e.g. deleted in the window after the
+      // existence check) by degrading to null; downstream falls back to file.content.
+      fullFileContent = await readTextFile(filePath).catch(() => null);
       verboseLog(options, chalk.blue(`Analyzing diff only for ${path.basename(filePath)}`));
     }
     else {
@@ -873,6 +876,22 @@ ${projectArchitectureSection}`);
   return blocks;
 }
 
+/**
+ * Build the user-prompt sentence that points the model at the cached system blocks.
+ * Returns an empty string when no cached blocks were emitted, so the prompt never
+ * instructs the model to use context that was not sent.
+ *
+ * @param {string[]} cachedSystemBlocks - Cached blocks produced for this request
+ * @param {string} subject - What is being evaluated (e.g. 'this file')
+ * @returns {string} Instruction sentence, or '' when there is no cached context
+ */
+function buildCachedContextInstruction(cachedSystemBlocks, subject) {
+  if (!cachedSystemBlocks || cachedSystemBlocks.length === 0) {
+    return '';
+  }
+  return `Use the cached project context, project architecture, and custom instructions when evaluating ${subject}.`;
+}
+
 // LLM call function - sends prompt with cached system content for cost optimization
 async function sendPromptToLLM(promptConfig, llmOptions) {
   try {
@@ -1150,7 +1169,7 @@ ${reviewInstructions}
 
 ${fileSection}
 
-Use the cached project context, project architecture, and custom instructions when evaluating this file.
+${buildCachedContextInstruction(cachedSystemBlocks, 'this file')}
 
 CONTEXT A: EXPLICIT GUIDELINES FROM DOCUMENTATION
 ${formattedGuidelines}
@@ -1270,7 +1289,7 @@ ${reviewInstructions}
 ${fileSection}
 
 ## ANALYSIS CONTEXT
-Use the cached project context, project architecture, and custom instructions when evaluating this test file.
+${buildCachedContextInstruction(cachedSystemBlocks, 'this test file')}
 
 CONTEXT A: TESTING GUIDELINES AND BEST PRACTICES
 ${formattedGuidelines}
@@ -1358,23 +1377,24 @@ ${g.content}
 
   // Format PR files with their diffs
   const prFiles = file.prFiles || [];
+  const holisticContextPlans = mergeHolisticFileContextPlans(prFiles, context.options || {});
   const formattedPRFiles = prFiles
     .map((prFile, idx) => {
+      const fileContextPlan = holisticContextPlans[idx];
+      const fileContext = formatPlannedHolisticFileContext(prFile, fileContextPlan, context.options || {});
       return `
 ## FILE ${idx + 1}: ${prFile.path}
 **Language**: ${prFile.language}
 **Type**: ${prFile.isTest ? 'Test' : 'Source'} file
 **Summary**: ${prFile.summary}
+**Context Mode**: ${fileContextPlan.mode === 'full' ? 'Full file content' : 'Focused changed-line context'}
 
 ### Changes (Git Diff):
 \`\`\`diff
 ${prFile.diff}
 \`\`\`
 
-### Full File Content (For Context - line numbers shown for reference):
-\`\`\`${prFile.language}
-${addLineNumbers(prFile.fullContent)}
-\`\`\`
+${fileContext}
 `;
     })
     .join('\n');
@@ -1388,17 +1408,17 @@ ${addLineNumbers(prFile.fullContent)}
 **CRITICAL CONTEXT AWARENESS INSTRUCTIONS:**
 
 For each file in this PR, you have access to:
-1. **FULL FILE CONTENT** - The complete file for understanding context and existing code
+1. **FILE CONTEXT** - Complete file content when it fits the holistic context budget, or focused changed-line windows for very large files/PRs
 2. **GIT DIFF** - Only the changes to review
 
 **Review Rules:**
 - ONLY critique the CHANGED lines shown in each file's diff (lines with + or -)
-- USE the full file content to understand context, dependencies, and existing implementations
+- USE the file context to understand dependencies, nearby behavior, and existing implementations
 - DO NOT suggest adding code that already exists in the unchanged portions of any file
-- DO NOT flag issues about missing code if it exists elsewhere in the full file
-- Before flagging cross-file issues, verify the code doesn't already exist in unchanged portions
-- Do NOT flag functions/variables as missing if they exist elsewhere in the full file
-- The unchanged code is part of each file - always check it before making assumptions`;
+- DO NOT flag issues about missing code when the provided context already shows the code exists
+- Before flagging cross-file issues, verify the code doesn't already exist in the provided context
+- Do NOT flag functions/variables as missing if they exist elsewhere in the provided context
+- The unchanged context is part of each file - always check it before making assumptions`;
 
   let roleDefinition = buildRoleDefinition(baseRole, customDocs, 'pr');
   roleDefinition += '\nAnalyze ALL files together to identify cross-file issues, consistency problems, and overall code quality.';
@@ -1427,7 +1447,7 @@ For each file in this PR, you have access to:
 - **Test Files**: ${prFiles.filter((f) => f.isTest).length}
 
 ## UNIFIED CONTEXT FROM PROJECT
-Use the cached project context, project architecture, and custom instructions when evaluating this pull request.
+${buildCachedContextInstruction(cachedSystemBlocks, 'this pull request')}
 
 ### PROJECT CODE EXAMPLES
 ${formattedCodeExamples}

package/src/rag-analyzer.test.js

@@ -578,6 +578,70 @@ describe('rag-analyzer', () => {
       );
       expect(result.success).toBe(true);
     });
+
+    it('should use focused context for oversized holistic PR files', async () => {
+      const hugeContent = Array.from({ length: 5000 }, (_, index) => `huge line ${index + 1}`).join('\n');
+      llm.sendPromptToClaude.mockResolvedValue(createMockHolisticReviewResponse());
+
+      const result = await runAnalysis(
+        'PR_HOLISTIC_REVIEW',
+        setupHolisticReviewOptions({
+          prFiles: [
+            createMockPRFile({
+              path: 'src/small.js',
+              fullContent: 'const small = true;',
+              diff: '@@ -1,1 +1,1 @@\n-const small = false;\n+const small = true;',
+            }),
+            createMockPRFile({
+              path: 'src/huge.js',
+              fullContent: hugeContent,
+              diff: '@@ -2500,1 +2500,1 @@\n-huge line 2500\n+huge line 2500 changed',
+            }),
+          ],
+          prContext: { totalFiles: 2 },
+          maxTotalFullContentTokens: 1000,
+        })
+      );
+
+      const prompt = llm.sendPromptToClaude.mock.calls.at(-1)[0];
+      expect(result.success).toBe(true);
+      expect(prompt).toContain('**Context Mode**: Full file content');
+      expect(prompt).toContain('**Context Mode**: Focused changed-line context');
+      expect(prompt).toContain('const small = true;');
+      expect(prompt).toContain('Focused File Context');
+      expect(prompt).toContain('2500 | huge line 2500');
+      expect(prompt).not.toContain('5000 | huge line 5000');
+    });
+
+    it('should preserve carried holistic context plans for chunked reviews', async () => {
+      llm.sendPromptToClaude.mockResolvedValue(createMockHolisticReviewResponse());
+
+      await runAnalysis(
+        'PR_HOLISTIC_REVIEW',
+        setupHolisticReviewOptions({
+          prFiles: [
+            createMockPRFile({
+              path: 'src/chunked.js',
+              fullContent: 'const wouldFit = true;',
+              diff: '@@ -1,1 +1,1 @@\n-const wouldFit = false;\n+const wouldFit = true;',
+              holisticContextPlan: {
+                mode: 'focused',
+                reason: 'global budget assigned focused context before chunking',
+                contextTokens: 5,
+                totalTokens: 20,
+                contextLineRadius: 0,
+              },
+            }),
+          ],
+          prContext: { totalFiles: 1 },
+        })
+      );
+
+      const prompt = llm.sendPromptToClaude.mock.calls.at(-1)[0];
+      expect(prompt).toContain('**Context Mode**: Focused changed-line context');
+      expect(prompt).toContain('global budget assigned focused context before chunking');
+      expect(prompt).not.toContain('### Full File Content');
+    });
   });
 
   // ==========================================================================

package/src/rag-review.js

@@ -14,6 +14,7 @@ import { ensureBranchExists, findParentBranch, getChangedLinesInfo, getFileConte
 import { detectFileType, detectLanguageFromExtension } from './utils/language-detection.js';
 import { verboseLog } from './utils/logging.js';
 import { shouldChunkPR, chunkPRFiles, combineChunkResults } from './utils/pr-chunking.js';
+import { mergeHolisticFileContextPlans } from './utils/pr-file-context.js';
 
 /**
  * Review a single file using RAG approach
@@ -308,8 +309,10 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
     }
 
     // Check if PR should be chunked based on size and complexity (skip if this is already a chunk)
+    let holisticContextPlans = options.holisticContextPlans;
     if (!options.skipChunking) {
       const chunkingDecision = shouldChunkPR(prFiles, options);
+      holisticContextPlans = chunkingDecision.holisticContextPlans;
       verboseLog(verbose, chalk.blue(`PR size assessment: ${chunkingDecision.estimatedTokens} tokens, ${prFiles.length} files`));
       verboseLog(
         verbose && chunkingDecision.shouldChunk,
@@ -319,10 +322,12 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
       // If PR is too large, use chunked processing
       if (chunkingDecision.shouldChunk) {
         verboseLog(options, chalk.blue(`🔄 Using chunked processing for large PR (${chunkingDecision.estimatedTokens} tokens)`));
-        return await reviewLargePRInChunks(prFiles, options);
+        return await reviewLargePRInChunks(prFiles, { ...options, holisticContextPlans });
       }
     }
 
+    holisticContextPlans = mergeHolisticFileContextPlans(prFiles, options, holisticContextPlans);
+
     // Step 2: Gather unified context for the entire PR (for regular-sized PRs)
     verboseLog(verbose, chalk.blue(`Performing unified context retrieval for ${prFiles.length} PR files...`));
     const {
@@ -361,7 +366,7 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
     try {
       // Create a comprehensive review context with all files and their diffs
       const comprehensiveContext = {
-        prFiles: prFiles.map((file) => ({
+        prFiles: prFiles.map((file, index) => ({
           path: path.relative(workingDir, file.filePath),
           language: file.language,
           isTest: file.isTest,
@@ -369,6 +374,8 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
           summary: file.summary,
           fullContent: file.content, // Add full file content for context
           diff: file.diffContent,
+          diffInfo: file.diffInfo,
+          holisticContextPlan: file.holisticContextPlan || holisticContextPlans[index],
           baseBranch: file.baseBranch,
           targetBranch: file.targetBranch,
         })),
@@ -557,7 +564,7 @@ async function reviewLargePRInChunks(prFiles, options) {
 
   // Step 2: Split PR into manageable chunks
   // Each chunk includes both diff AND full file content, plus ~25k context overhead
-  const chunks = chunkPRFiles(prFiles, 35000); // Conservative limit accounting for context overhead
+  const chunks = chunkPRFiles(prFiles, 35000, options); // Conservative limit accounting for context overhead
   verboseLog(options, chalk.green(`✂️ Split PR into ${chunks.length} chunks`));
 
   chunks.forEach((chunk, i) => {

package/src/rag-review.test.js

@@ -270,7 +270,8 @@ describe('rag-review', () => {
       });
 
       // Setup: shouldChunkPR returns true to trigger chunked processing
-      shouldChunkPR.mockReturnValue({ shouldChunk: true, estimatedTokens: 100000, recommendedChunks: 2 });
+      const holisticContextPlans = [{ mode: 'focused', contextTokens: 10, totalTokens: 20 }];
+      shouldChunkPR.mockReturnValue({ shouldChunk: true, estimatedTokens: 100000, recommendedChunks: 2, holisticContextPlans });
 
       // Setup chunks that will be processed
       chunkPRFiles.mockReturnValue([
@@ -298,7 +299,7 @@ describe('rag-review', () => {
 
       // Verify chunking flow was triggered
       expect(shouldChunkPR).toHaveBeenCalled();
-      expect(chunkPRFiles).toHaveBeenCalled();
+      expect(chunkPRFiles).toHaveBeenCalledWith(expect.any(Array), 35000, expect.objectContaining({ holisticContextPlans }));
       expect(combineChunkResults).toHaveBeenCalled();
       expect(result.success).toBe(true);
     });