codecritique 1.2.2 → 1.2.4

package/src/rag-analyzer.test.js

@@ -77,6 +77,12 @@ vi.mock('./utils/language-detection.js', () => ({
 
 vi.mock('./utils/logging.js', () => ({
   debug: vi.fn(),
+  verboseLog: vi.fn((options, ...args) => {
+    if (typeof options === 'boolean' ? options : Boolean(options?.verbose)) {
+      console.log(...args);
+    }
+  }),
+  isVerboseEnabled: vi.fn((options) => Boolean(options?.verbose)),
 }));
 
 vi.mock('./utils/context-inference.js', () => ({
@@ -326,6 +332,29 @@ describe('rag-analyzer', () => {
       const result = await runAnalysis('/test/file.js');
       expect(result.success).toBe(true);
     });
+
+    it('should preserve successful context sources when one parallel retrieval fails', async () => {
+      mockEmbeddingsSystem.findRelevantDocs.mockResolvedValue([
+        {
+          path: '/docs/api.md',
+          content: 'API docs',
+          similarity: 0.8,
+          type: 'documentation-chunk',
+          document_title: 'API Docs',
+          heading_text: 'Usage',
+        },
+      ]);
+      mockEmbeddingsSystem.findSimilarCode.mockResolvedValue([{ path: '/similar.js', content: 'similar code', similarity: 0.9 }]);
+      findRelevantPRComments.mockRejectedValue(new Error('PR comments failed'));
+      llm.sendPromptToClaude.mockResolvedValue({ json: { summary: 'Review', issues: [] } });
+
+      const result = await runAnalysis('/test/file.js');
+
+      expect(result.success).toBe(true);
+      expect(result.context.codeExamples).toBeGreaterThan(0);
+      expect(result.context.guidelines).toBeGreaterThanOrEqual(0);
+      expect(result.context.prComments).toBe(0);
+    });
   });
 
   // ==========================================================================
@@ -797,6 +826,23 @@ describe('rag-analyzer', () => {
   // ==========================================================================
 
   describe('verbose logging paths', () => {
+    it('should suppress context dump logs when not verbose', async () => {
+      mockEmbeddingsSystem.findSimilarCode.mockResolvedValue([{ path: '/example.js', content: 'code', similarity: 0.9 }]);
+      mockEmbeddingsSystem.findRelevantDocs.mockResolvedValue([
+        { path: '/docs/api.md', content: 'docs', similarity: 0.8, type: 'documentation-chunk', document_title: 'API' },
+      ]);
+      findRelevantPRComments.mockResolvedValue([createMockPRComment()]);
+      setupSuccessfulLLMResponse();
+
+      const result = await runAnalysis('/test/file.js');
+
+      expect(result.success).toBe(true);
+      const loggedMessages = console.log.mock.calls.flat().join('\n');
+      expect(loggedMessages).not.toContain('Guidelines Sent to LLM');
+      expect(loggedMessages).not.toContain('Checking for PR comments in prompt generation');
+      expect(loggedMessages).not.toContain('Received LLM response, attempting to parse');
+    });
+
     it('should log context information when verbose', async () => {
       mockEmbeddingsSystem.findSimilarCode.mockResolvedValue([{ path: '/example.js', content: 'code', similarity: 0.9 }]);
       mockEmbeddingsSystem.findRelevantDocs.mockResolvedValue([
@@ -864,6 +910,15 @@ describe('rag-analyzer', () => {
       expect(context).toHaveProperty('codeExamples');
     });
 
+    it('should degrade gracefully when retrieval returns no context for active files', async () => {
+      mockEmbeddingsSystem.findSimilarCode.mockResolvedValue([]);
+      mockEmbeddingsSystem.findRelevantDocs.mockResolvedValue([]);
+      const prFiles = [{ filePath: '/src/file.js', content: 'code', language: 'javascript' }];
+      const context = await gatherUnifiedContextForPR(prFiles, { projectPath: '/project' });
+      expect(context.codeExamples).toEqual([]);
+      expect(context.guidelines).toEqual([]);
+    });
+
     it('should find custom document chunks', async () => {
       mockEmbeddingsSystem.getExistingCustomDocumentChunks.mockResolvedValue([{ content: 'Custom doc', document_title: 'Guidelines' }]);
       const prFiles = [{ filePath: '/src/file.js', content: 'code', language: 'javascript' }];

package/src/rag-review.js

@@ -12,6 +12,7 @@ import { runAnalysis, gatherUnifiedContextForPR } from './rag-analyzer.js';
 import { shouldProcessFile } from './utils/file-validation.js';
 import { findBaseBranch, getChangedLinesInfo, getFileContentFromGit } from './utils/git.js';
 import { detectFileType, detectLanguageFromExtension } from './utils/language-detection.js';
+import { verboseLog } from './utils/logging.js';
 import { shouldChunkPR, chunkPRFiles, combineChunkResults } from './utils/pr-chunking.js';
 
 /**
@@ -19,20 +20,37 @@ import { shouldChunkPR, chunkPRFiles, combineChunkResults } from './utils/pr-chu
  *
  * @param {string} filePath - Path to the file to review
  * @param {object} options - Review options
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @returns {Promise<object>} Review result object
  */
 async function reviewFile(filePath, options = {}) {
   try {
-    console.log(chalk.blue(`Reviewing file: ${filePath}`));
+    verboseLog(options, chalk.blue(`Reviewing file: ${filePath}`));
 
     // Analyze the file using the RAG analyzer
     const analyzeResult = await runAnalysis(filePath, options);
 
     // If analysis successful, return the result
     if (analyzeResult.success) {
+      if (analyzeResult.skipped) {
+        return {
+          success: true,
+          results: [
+            {
+              filePath: analyzeResult.filePath || filePath,
+              language: analyzeResult.language,
+              success: true,
+              skipped: true,
+              message: analyzeResult.message,
+              results: analyzeResult.results,
+            },
+          ],
+        };
+      }
+
       // Convert object results to array format expected by the output functions
       if (analyzeResult.results && !Array.isArray(analyzeResult.results)) {
-        console.log(chalk.blue('Converting results object to array format'));
+        verboseLog(options, chalk.blue('Converting results object to array format'));
 
         // Create a new array with one entry containing the object results
         const resultArray = [
@@ -70,14 +88,14 @@ async function reviewFile(filePath, options = {}) {
  *
  * @param {Array<string>} filePaths - Paths to the files to review
  * @param {Object} options - Review options (passed to each reviewFile call)
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
+ * @param {number} [options.concurrency=3] - Maximum number of files to review in parallel
  * @returns {Promise<Object>} Aggregated review results { success: boolean, results: Array<Object>, message: string, error?: string }
  */
 async function reviewFiles(filePaths, options = {}) {
   try {
     const verbose = options.verbose || false;
-    if (verbose) {
-      console.log(chalk.blue(`Reviewing ${filePaths.length} files...`));
-    }
+    verboseLog(verbose, chalk.blue(`Reviewing ${filePaths.length} files...`));
 
     // Review files concurrently
     const results = [];
@@ -87,21 +105,26 @@ async function reviewFiles(filePaths, options = {}) {
     for (let i = 0; i < filePaths.length; i += concurrency) {
       const batch = filePaths.slice(i, i + concurrency);
 
-      if (verbose) {
-        console.log(
-          chalk.blue(
-            `Processing review batch ${Math.floor(i / concurrency) + 1}/${Math.ceil(filePaths.length / concurrency)} (${
-              batch.length
-            } files)`
-          )
-        );
-      }
+      verboseLog(
+        verbose,
+        chalk.blue(
+          `Processing review batch ${Math.floor(i / concurrency) + 1}/${Math.ceil(filePaths.length / concurrency)} (${batch.length} files)`
+        )
+      );
 
       // Pass options down to reviewFile
       const batchPromises = batch.map((filePath) => reviewFile(filePath, options));
       const batchResults = await Promise.all(batchPromises);
 
-      results.push(...batchResults);
+      const flattenedBatchResults = batchResults.flatMap((batchResult) => {
+        if (batchResult?.success && Array.isArray(batchResult.results)) {
+          return batchResult.results;
+        }
+
+        return batchResult ? [batchResult] : [];
+      });
+
+      results.push(...flattenedBatchResults);
     }
 
     // Filter out potential null results if any step could return null/undefined (though analyzeFile should always return an object)
@@ -113,7 +136,7 @@ async function reviewFiles(filePaths, options = {}) {
     let finalMessage = `Review completed for ${filePaths.length} files. `;
     finalMessage += `Success: ${successCount}, Skipped: ${skippedCount}, Errors: ${errorCount}.`;
 
-    console.log(chalk.green(finalMessage));
+    verboseLog(options, chalk.green(finalMessage));
 
     return {
       success: errorCount === 0,
@@ -137,14 +160,13 @@ async function reviewFiles(filePaths, options = {}) {
  *
  * @param {Array<string>} changedFilePaths - Array of file paths changed in the PR.
  * @param {Object} options - Review options (passed to reviewFiles).
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @returns {Promise<Object>} Aggregated review results.
  */
 async function reviewPullRequest(changedFilePaths, options = {}) {
   try {
     const verbose = options.verbose || false;
-    if (verbose) {
-      console.log(chalk.blue(`Reviewing ${changedFilePaths.length} changed files from PR...`));
-    }
+    verboseLog(verbose, chalk.blue(`Reviewing ${changedFilePaths.length} changed files from PR...`));
 
     // No longer filter files here, as new files in a different branch won't exist locally.
     // The downstream functions are responsible for fetching content from git.
@@ -152,7 +174,7 @@ async function reviewPullRequest(changedFilePaths, options = {}) {
 
     if (filesToReview.length === 0) {
       const message = 'No processable files found among the changed files provided for PR review.';
-      console.log(chalk.yellow(message));
+      verboseLog(options, chalk.yellow(message));
       return {
         success: true,
         message: message,
@@ -160,9 +182,7 @@ async function reviewPullRequest(changedFilePaths, options = {}) {
       };
     }
 
-    if (verbose) {
-      console.log(chalk.green(`Reviewing ${filesToReview.length} existing and processable changed files`));
-    }
+    verboseLog(verbose, chalk.green(`Reviewing ${filesToReview.length} existing and processable changed files`));
 
     // Use enhanced PR review with cross-file context
     return await reviewPullRequestWithCrossFileContext(filesToReview, options);
@@ -183,14 +203,18 @@ async function reviewPullRequest(changedFilePaths, options = {}) {
  *
  * @param {Array<string>} filesToReview - Array of file paths to review
  * @param {Object} options - Review options
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
+ * @param {number} [options.concurrency=3] - Maximum number of fallback per-file reviews to run in parallel
+ * @param {string} [options.directory] - Working directory for git operations
+ * @param {string} [options.diffWith='HEAD'] - Branch or ref to compare against
+ * @param {string} [options.actualBranch] - Actual target branch used for content retrieval
+ * @param {boolean} [options.skipChunking=false] - Skip PR chunking, used internally for chunk review recursion
  * @returns {Promise<Object>} Aggregated review results
  */
 async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}) {
   try {
     const verbose = options.verbose || false;
-    if (verbose) {
-      console.log(chalk.blue(`Starting enhanced PR review with cross-file context for ${filesToReview.length} files...`));
-    }
+    verboseLog(verbose, chalk.blue(`Starting enhanced PR review with cross-file context for ${filesToReview.length} files...`));
 
     // Step 1: Get the base branch and collect diff info for all files in the PR
     const workingDir = options.directory ? path.resolve(options.directory) : process.cwd();
@@ -200,18 +224,14 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
     // Get the actual branch name from options passed from index.js
     const actualTargetBranch = options.actualBranch || targetBranch;
 
-    if (verbose) {
-      console.log(chalk.gray(`Base branch: ${baseBranch}, Target branch: ${targetBranch}`));
-    }
+    verboseLog(verbose, chalk.gray(`Base branch: ${baseBranch}, Target branch: ${targetBranch}`));
 
     const prFiles = [];
     for (const filePath of filesToReview) {
       try {
         // Check if the file should be processed before fetching its content from git
         if (!shouldProcessFile(filePath, '', options)) {
-          if (verbose) {
-            console.log(chalk.yellow(`Skipping file due to exclusion rules: ${path.basename(filePath)}`));
-          }
+          verboseLog(verbose, chalk.yellow(`Skipping file due to exclusion rules: ${path.basename(filePath)}`));
           continue;
         }
 
@@ -223,9 +243,7 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
         const diffInfo = getChangedLinesInfo(filePath, baseBranch, actualTargetBranch, workingDir);
 
         if (!diffInfo.hasChanges) {
-          if (verbose) {
-            console.log(chalk.yellow(`No changes detected in ${path.basename(filePath)}, skipping`));
-          }
+          verboseLog(verbose, chalk.yellow(`No changes detected in ${path.basename(filePath)}, skipping`));
           continue;
         }
 
@@ -251,7 +269,7 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
     }
 
     if (prFiles.length === 0) {
-      console.log(chalk.yellow('No files with changes found for review'));
+      verboseLog(options, chalk.yellow('No files with changes found for review'));
       return {
         success: true,
         results: [],
@@ -261,25 +279,22 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
 
     // Check if PR should be chunked based on size and complexity (skip if this is already a chunk)
     if (!options.skipChunking) {
-      const chunkingDecision = shouldChunkPR(prFiles);
-      if (verbose) {
-        console.log(chalk.blue(`PR size assessment: ${chunkingDecision.estimatedTokens} tokens, ${prFiles.length} files`));
-        if (chunkingDecision.shouldChunk) {
-          console.log(chalk.yellow(`Large PR detected - will chunk into ~${chunkingDecision.recommendedChunks} chunks`));
-        }
-      }
+      const chunkingDecision = shouldChunkPR(prFiles, options);
+      verboseLog(verbose, chalk.blue(`PR size assessment: ${chunkingDecision.estimatedTokens} tokens, ${prFiles.length} files`));
+      verboseLog(
+        verbose && chunkingDecision.shouldChunk,
+        chalk.yellow(`Large PR detected - will chunk into ~${chunkingDecision.recommendedChunks} chunks`)
+      );
 
       // If PR is too large, use chunked processing
       if (chunkingDecision.shouldChunk) {
-        console.log(chalk.blue(`🔄 Using chunked processing for large PR (${chunkingDecision.estimatedTokens} tokens)`));
+        verboseLog(options, chalk.blue(`🔄 Using chunked processing for large PR (${chunkingDecision.estimatedTokens} tokens)`));
         return await reviewLargePRInChunks(prFiles, options);
       }
     }
 
     // Step 2: Gather unified context for the entire PR (for regular-sized PRs)
-    if (verbose) {
-      console.log(chalk.blue(`Performing unified context retrieval for ${prFiles.length} PR files...`));
-    }
+    verboseLog(verbose, chalk.blue(`Performing unified context retrieval for ${prFiles.length} PR files...`));
     const {
       codeExamples: deduplicatedCodeExamples,
       guidelines: deduplicatedGuidelines,
@@ -287,13 +302,12 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
       customDocChunks: deduplicatedCustomDocChunks,
     } = await gatherUnifiedContextForPR(prFiles, options);
 
-    if (verbose) {
-      console.log(
-        chalk.green(
-          `De-duplicated context: ${deduplicatedCodeExamples.length} code examples, ${deduplicatedGuidelines.length} guidelines, ${deduplicatedPRComments.length} PR comments, ${deduplicatedCustomDocChunks.length} custom doc chunks`
-        )
-      );
-    }
+    verboseLog(
+      verbose,
+      chalk.green(
+        `De-duplicated context: ${deduplicatedCodeExamples.length} code examples, ${deduplicatedGuidelines.length} guidelines, ${deduplicatedPRComments.length} PR comments, ${deduplicatedCustomDocChunks.length} custom doc chunks`
+      )
+    );
 
     // Step 3: Create PR context summary for LLM
     const prContext = {
@@ -310,9 +324,7 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
     };
 
     // Step 4: Perform holistic PR review with all files and unified context
-    if (verbose) {
-      console.log(chalk.blue(`Performing holistic PR review for all ${prFiles.length} files...`));
-    }
+    verboseLog(verbose, chalk.blue(`Performing holistic PR review for all ${prFiles.length} files...`));
 
     try {
       // Create a comprehensive review context with all files and their diffs
@@ -367,15 +379,15 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
         for (const key of possibleKeys) {
           if (holisticResult?.results?.fileSpecificIssues?.[key]) {
             fileIssues = holisticResult.results.fileSpecificIssues[key];
-            console.log(chalk.green(`✅ Found ${fileIssues.length} issues for ${baseName} using key: "${key}"`));
+            verboseLog(options, chalk.green(`✅ Found ${fileIssues.length} issues for ${baseName} using key: "${key}"`));
             break;
           }
         }
 
-        console.log(chalk.gray(`🔍 Mapping issues for ${file.filePath}:`));
-        console.log(chalk.gray(`  - Relative path: "${relativePath}"`));
-        console.log(chalk.gray(`  - Tried keys: ${possibleKeys.map((k) => `"${k}"`).join(', ')}`));
-        console.log(chalk.gray(`  - Final issues: ${fileIssues.length}`));
+        verboseLog(options, chalk.gray(`🔍 Mapping issues for ${file.filePath}:`));
+        verboseLog(options, chalk.gray(`  - Relative path: "${relativePath}"`));
+        verboseLog(options, chalk.gray(`  - Tried keys: ${possibleKeys.map((k) => `"${k}"`).join(', ')}`));
+        verboseLog(options, chalk.gray(`  - Final issues: ${fileIssues.length}`));
 
         return {
           success: true,
@@ -421,9 +433,7 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
       console.error(chalk.red(`Error in holistic PR review: ${error.message}`));
 
       // Fallback to individual file review if holistic review fails
-      if (verbose) {
-        console.log(chalk.yellow(`Falling back to individual file reviews...`));
-      }
+      verboseLog(verbose, chalk.yellow(`Falling back to individual file reviews...`));
 
       const results = [];
       const concurrency = options.concurrency || 3;
@@ -500,33 +510,53 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
  * Reviews a large PR by splitting it into manageable chunks and processing them in parallel
  * @param {Array} prFiles - Array of PR files with diff content
  * @param {Object} options - Review options
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @returns {Promise<Object>} Combined review results
  */
 async function reviewLargePRInChunks(prFiles, options) {
-  console.log(chalk.blue(`🔄 Large PR detected: ${prFiles.length} files. Splitting into chunks...`));
+  verboseLog(options, chalk.blue(`🔄 Large PR detected: ${prFiles.length} files. Splitting into chunks...`));
 
   // Step 1: Gather shared context once for all chunks
-  console.log(chalk.cyan('📚 Gathering shared context for entire PR...'));
+  verboseLog(options, chalk.cyan('📚 Gathering shared context for entire PR...'));
   const sharedContext = await gatherUnifiedContextForPR(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
-  console.log(chalk.green(`✂️ Split PR into ${chunks.length} chunks`));
+  verboseLog(options, chalk.green(`✂️ Split PR into ${chunks.length} chunks`));
 
   chunks.forEach((chunk, i) => {
-    console.log(chalk.gray(`  Chunk ${i + 1}: ${chunk.files.length} files (~${chunk.totalTokens} tokens)`));
+    verboseLog(options, chalk.gray(`  Chunk ${i + 1}: ${chunk.files.length} files (~${chunk.totalTokens} tokens)`));
   });
 
   // Step 3: Process chunks in parallel
-  console.log(chalk.blue('🔄 Processing chunks in parallel...'));
-  const chunkResults = await Promise.all(
+  verboseLog(options, chalk.blue('🔄 Processing chunks in parallel...'));
+  const settledChunkResults = await Promise.allSettled(
     chunks.map((chunk, index) => reviewPRChunk(chunk, sharedContext, options, index + 1, chunks.length))
   );
 
+  const chunkResults = settledChunkResults.map((result, index) => {
+    if (result.status === 'fulfilled') {
+      return {
+        chunkId: index + 1,
+        ...result.value,
+      };
+    }
+
+    const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    console.warn(chalk.yellow(`Chunk ${index + 1}/${chunks.length} failed: ${errorMessage}`));
+
+    return {
+      chunkId: index + 1,
+      success: false,
+      error: errorMessage,
+      results: [],
+    };
+  });
+
   // Step 4: Combine results
-  console.log(chalk.blue('🔗 Combining chunk results...'));
-  return combineChunkResults(chunkResults, prFiles.length);
+  verboseLog(options, chalk.blue('🔗 Combining chunk results...'));
+  return combineChunkResults(chunkResults, prFiles.length, options);
 }
 
 /**
@@ -534,12 +564,13 @@ async function reviewLargePRInChunks(prFiles, options) {
  * @param {Object} chunk - Chunk object with files array
  * @param {Object} sharedContext - Pre-gathered shared context
  * @param {Object} options - Review options
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @param {number} chunkNumber - Current chunk number
  * @param {number} totalChunks - Total number of chunks
  * @returns {Promise<Object>} Chunk review results
  */
 async function reviewPRChunk(chunk, sharedContext, options, chunkNumber, totalChunks) {
-  console.log(chalk.cyan(`📝 Reviewing chunk ${chunkNumber}/${totalChunks} (${chunk.files.length} files)...`));
+  verboseLog(options, chalk.cyan(`📝 Reviewing chunk ${chunkNumber}/${totalChunks} (${chunk.files.length} files)...`));
 
   // Create chunk-specific options
   const chunkOptions = {

package/src/rag-review.test.js

@@ -94,16 +94,62 @@ describe('rag-review', () => {
 
       expect(runAnalysis).toHaveBeenCalledWith('/test/file.js', { verbose: true, maxExamples: 10 });
     });
+
+    it('should wrap skipped files with file metadata', async () => {
+      runAnalysis.mockResolvedValue({
+        success: true,
+        skipped: true,
+        message: 'File skipped based on exclusion patterns',
+      });
+
+      const result = await reviewFile('/test/skipped.js');
+
+      expect(result.success).toBe(true);
+      expect(result.results).toEqual([
+        expect.objectContaining({
+          filePath: '/test/skipped.js',
+          success: true,
+          skipped: true,
+          message: 'File skipped based on exclusion patterns',
+        }),
+      ]);
+    });
   });
 
   describe('reviewFiles', () => {
     it('should review multiple files', async () => {
-      runAnalysis.mockResolvedValue({ success: true, results: [] });
+      runAnalysis
+        .mockResolvedValueOnce({
+          success: true,
+          filePath: '/test/file1.js',
+          language: 'javascript',
+          results: { issues: [] },
+        })
+        .mockResolvedValueOnce({
+          success: true,
+          filePath: '/test/file2.js',
+          language: 'javascript',
+          results: { issues: [] },
+        });
 
       const result = await reviewFiles(['/test/file1.js', '/test/file2.js']);
 
       expect(result.success).toBe(true);
       expect(result.results.length).toBe(2);
+      expect(result.results[0]).toEqual(
+        expect.objectContaining({
+          filePath: '/test/file1.js',
+          success: true,
+          results: { issues: [] },
+        })
+      );
+      expect(result.results[1]).toEqual(
+        expect.objectContaining({
+          filePath: '/test/file2.js',
+          success: true,
+          results: { issues: [] },
+        })
+      );
     });
 
     it('should process files in batches based on concurrency', async () => {
@@ -116,8 +162,13 @@ describe('rag-review', () => {
 
     it('should count successes, skips, and errors', async () => {
       runAnalysis
-        .mockResolvedValueOnce({ success: true, results: [] })
-        .mockResolvedValueOnce({ success: true, skipped: true, results: [] })
+        .mockResolvedValueOnce({
+          success: true,
+          filePath: '/file1.js',
+          language: 'javascript',
+          results: { issues: [] },
+        })
+        .mockResolvedValueOnce({ success: true, skipped: true, message: 'Skipped' })
         .mockResolvedValueOnce({ success: false, error: 'Error' });
 
       const result = await reviewFiles(['/file1.js', '/file2.js', '/file3.js']);
@@ -219,6 +270,67 @@ describe('rag-review', () => {
       expect(result.success).toBe(true);
     });
 
+    it('should preserve successful chunk results when one chunk fails', async () => {
+      shouldProcessFile.mockReturnValue(true);
+      getChangedLinesInfo.mockReturnValue({
+        hasChanges: true,
+        addedLines: [1, 2, 3],
+        removedLines: [],
+        fullDiff: '+ new code',
+      });
+
+      shouldChunkPR.mockReturnValue({ shouldChunk: true, estimatedTokens: 100000, recommendedChunks: 2 });
+      chunkPRFiles.mockReturnValue([
+        { files: [{ filePath: '/file1.js' }], totalTokens: 30000 },
+        { files: [{ filePath: '/file2.js' }], totalTokens: 30000 },
+      ]);
+
+      const allSettledSpy = vi.spyOn(Promise, 'allSettled').mockResolvedValue([
+        {
+          status: 'fulfilled',
+          value: {
+            success: true,
+            results: [{ filePath: '/file1.js', success: true }],
+          },
+        },
+        {
+          status: 'rejected',
+          reason: new Error('Chunk LLM failed'),
+        },
+      ]);
+
+      combineChunkResults.mockImplementation((chunkResults) => ({
+        success: true,
+        results: chunkResults.filter((chunk) => chunk.success).flatMap((chunk) => chunk.results || []),
+        chunkResults,
+      }));
+
+      runAnalysis.mockResolvedValueOnce({
+        success: true,
+        results: { fileSpecificIssues: {}, crossFileIssues: [], summary: 'OK' },
+      });
+
+      const result = await reviewPullRequest(['/file1.js', '/file2.js'], { verbose: true });
+
+      expect(combineChunkResults).toHaveBeenCalledWith(
+        expect.arrayContaining([
+          expect.objectContaining({ chunkId: 1, success: true }),
+          expect.objectContaining({
+            chunkId: 2,
+            success: false,
+            error: 'Chunk LLM failed',
+            results: [],
+          }),
+        ]),
+        2,
+        expect.objectContaining({ verbose: true })
+      );
+      expect(allSettledSpy).toHaveBeenCalled();
+      expect(result.success).toBe(true);
+      expect(result.results).toHaveLength(1);
+      expect(result.chunkResults).toHaveLength(2);
+    });
+
     it('should gather unified context for PR files', async () => {
       // Setup analysis to return valid holistic result
       runAnalysis.mockResolvedValue({

package/src/zero-shot-classifier-open.js

@@ -10,6 +10,7 @@ import * as linguistLanguages from 'linguist-languages';
 import { LRUCache } from 'lru-cache';
 import stopwords from 'stopwords-iso/stopwords-iso.json' with { type: 'json' };
 import techKeywords from './technology-keywords.json' with { type: 'json' };
+import { verboseLog } from './utils/logging.js';
 import { truncateToTokenLimit } from './utils/mobilebert-tokenizer.js';
 
 // Configure Transformers.js environment
@@ -124,14 +125,14 @@ class OpenZeroShotClassifier {
 
   async _doInitialize() {
     try {
-      console.log('Initializing open-ended zero-shot classifier...');
+      verboseLog({}, 'Initializing open-ended zero-shot classifier...');
 
       this.classifier = await pipeline('zero-shot-classification', 'Xenova/mobilebert-uncased-mnli', {
         quantized: true,
       });
 
       this.isInitialized = true;
-      console.log('✓ Open-ended zero-shot classifier initialized successfully');
+      verboseLog({}, '✓ Open-ended zero-shot classifier initialized successfully');
     } catch (error) {
       console.error('Error initializing classifier:', error);
       this.isInitialized = false;