codecritique 2.0.7 → 2.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "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

@@ -471,8 +471,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 +875,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 +1168,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 +1288,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}
@@ -1427,7 +1445,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}