codecritique 1.2.3 → 2.0.0

package/src/project-analyzer.js

@@ -209,13 +209,20 @@ export class ProjectAnalyzer {
       // Check for existing analysis
       const existingSummary = forceAnalysis ? null : await this.loadExistingAnalysis(projectPath);
       if (existingSummary && !forceAnalysis) {
-        const currentHash = await this.calculateKeyFilesHash(existingSummary.keyFiles);
-        if (existingSummary.keyFilesHash === currentHash) {
-          verboseLog(verbose, chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
-          return existingSummary;
+        const currentEmbeddingInventoryHash = await this.calculateEmbeddingInventoryHash(projectPath);
+        if (existingSummary.embeddingInventoryHash !== currentEmbeddingInventoryHash) {
+          verboseLog(verbose, chalk.yellow('🔄 Embedding inventory changed, regenerating analysis...'));
         }
-        verboseLog(verbose, chalk.yellow('🔄 Key files changed, regenerating analysis...'));
-      } else {
+        else {
+          const currentHash = await this.calculateKeyFilesHash(existingSummary.keyFiles);
+          if (existingSummary.keyFilesHash === currentHash) {
+            verboseLog(verbose, chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
+            return existingSummary;
+          }
+          verboseLog(verbose, chalk.yellow('🔄 Key files changed, regenerating analysis...'));
+        }
+      }
+      else {
         verboseLog(
           verbose,
           chalk.cyan(
@@ -241,6 +248,7 @@ export class ProjectAnalyzer {
       const currentHash = await this.calculateKeyFilesHash(keyFiles);
       projectSummary.keyFiles = keyFiles;
       projectSummary.keyFilesHash = currentHash;
+      projectSummary.embeddingInventoryHash = await this.calculateEmbeddingInventoryHash(projectPath);
 
       await this.storeAnalysis(projectPath, projectSummary);
 
@@ -254,7 +262,8 @@ export class ProjectAnalyzer {
       verboseLog(verbose, chalk.gray(`   Key files tracked: ${keyFiles.length}`));
 
       return projectSummary;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red('Error analyzing project:'), error.message);
       return this.createFallbackSummary(projectPath);
     }
@@ -279,7 +288,8 @@ export class ProjectAnalyzer {
         return { ...summary, keyFiles };
       }
       return null;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.yellow('Warning: Could not load existing analysis:'), error.message);
       return null;
     }
@@ -293,7 +303,8 @@ export class ProjectAnalyzer {
       const embeddingsSystem = getDefaultEmbeddingsSystem();
       await embeddingsSystem.storeProjectSummary(projectPath, projectSummary);
       verboseLog({}, chalk.green('✅ Project analysis stored in database'));
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.yellow('Warning: Could not store analysis:'), error.message);
     }
   }
@@ -352,10 +363,12 @@ export class ProjectAnalyzer {
     // Optimize table to sync indices with data and prevent TakeExec panics
     try {
       await table.optimize();
-    } catch (optimizeError) {
+    }
+    catch (optimizeError) {
       if (optimizeError.message && optimizeError.message.includes('legacy format')) {
         console.warn(chalk.yellow(`Skipping optimization due to legacy index format - will be auto-upgraded during normal operations`));
-      } else {
+      }
+      else {
         console.warn(chalk.yellow(`Warning: Failed to optimize file embeddings table: ${optimizeError.message}`));
       }
     }
@@ -372,7 +385,8 @@ export class ProjectAnalyzer {
 
           if (config.whereClause) {
             query = query.where(`project_path = '${projectPath}' AND (${config.whereClause})`);
-          } else if (config.terms) {
+          }
+          else if (config.terms) {
             // For term-based searches, query ALL files and sort by depth to prioritize shallow config files
             const allFiles = await table
               .query()
@@ -400,12 +414,14 @@ export class ProjectAnalyzer {
 
               return matches;
             });
-          } else {
+          }
+          else {
             query = query.where(`project_path = '${projectPath}'`);
           }
 
           return await query.limit(config.limit || 30).toArray();
-        } catch (error) {
+        }
+        catch (error) {
           verboseLog({}, chalk.yellow(`     ⚠️ Query failed for ${config.category}: ${error.message}`));
           return [];
         }
@@ -424,7 +440,8 @@ export class ProjectAnalyzer {
           }
         });
       }
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red('Error mining embeddings:'), error.message);
       return [];
     }
@@ -438,11 +455,17 @@ export class ProjectAnalyzer {
    * Unified file type matching using consolidated patterns
    */
   matchesFileType(filePath, fileName, type) {
-    if (type === 'docs') return isDocumentationFile(filePath);
-    if (type === 'tests') return isTestFile(filePath);
+    if (type === 'docs') {
+      return isDocumentationFile(filePath);
+    }
+    if (type === 'tests') {
+      return isTestFile(filePath);
+    }
 
     const config = FILE_PATTERNS[type];
-    if (!config) return false;
+    if (!config) {
+      return false;
+    }
 
     const fileNameLower = fileName.toLowerCase();
     const filePathLower = filePath.toLowerCase();
@@ -540,10 +563,12 @@ Select files following the criteria in the system instructions.`;
 
         verboseLog({}, chalk.cyan(`🎯 LLM selected ${keyFiles.length} final key files`));
         return keyFiles;
-      } else {
+      }
+      else {
         throw new Error(`Failed to extract valid JSON array from LLM response`);
       }
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red('Error in LLM selection:'), error.message);
       verboseLog({}, chalk.yellow('   🔄 Falling back to automatic selection...'));
       return this.fallbackFileSelection(candidates, projectPath);
@@ -605,7 +630,8 @@ Select files following the criteria in the system instructions.`;
           const content = fs.readFileSync(fullPath, 'utf8');
           hash.update(content.substring(0, 1000));
         }
-      } catch {
+      }
+      catch {
         hash.update(file.relativePath || file.path || '');
       }
     }
@@ -613,6 +639,40 @@ Select files following the criteria in the system instructions.`;
     return hash.digest('hex');
   }
 
+  /**
+   * Calculate a project-scoped hash of the current embedding inventory.
+   */
+  async calculateEmbeddingInventoryHash(projectPath) {
+    try {
+      const embeddingsSystem = getDefaultEmbeddingsSystem();
+      await embeddingsSystem.initialize();
+      const table = await embeddingsSystem.databaseManager.getTable(embeddingsSystem.databaseManager.fileEmbeddingsTable);
+
+      if (!table) {
+        return 'no-file-embeddings-table';
+      }
+
+      const records = await table
+        .query()
+        .select(['type', 'path', 'content_hash', 'project_path'])
+        .where(`project_path = '${projectPath.replace(/'/g, "''")}'`)
+        .toArray();
+
+      const hash = crypto.createHash('sha256');
+      const normalizedRows = records.map((record) => `${record.type || 'file'}:${record.path || ''}:${record.content_hash || ''}`).sort();
+
+      for (const row of normalizedRows) {
+        hash.update(row);
+      }
+
+      return hash.digest('hex');
+    }
+    catch (error) {
+      verboseLog({}, chalk.yellow(`Warning: Could not calculate embedding inventory hash: ${error.message}`));
+      return 'embedding-inventory-unavailable';
+    }
+  }
+
   /**
    * Generate comprehensive project summary using LLM analysis (SINGLE CALL)
    */
@@ -777,12 +837,14 @@ Follow the analysis guidelines from the system instructions to identify custom i
         validatedSummary.projectPath = projectPath;
         validatedSummary.keyFilesCount = keyFiles.length;
         return validatedSummary;
-      } else {
+      }
+      else {
         console.error(chalk.red('Failed to parse LLM response as JSON'));
         console.error(chalk.gray('Response content preview:'), response.content.substring(0, 500));
         throw new Error('Failed to parse LLM response as JSON');
       }
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red('Error generating project summary:'), error.message);
       const fallback = this.createFallbackSummary(projectPath, keyFiles);
       verboseLog({}, chalk.yellow('Using fallback summary with technologies:'), fallback.technologies);
@@ -800,7 +862,9 @@ Follow the analysis guidelines from the system instructions to identify custom i
 
     for (const file of keyFiles.slice(0, 25)) {
       // Max 25 files
-      if (totalSize >= maxTotalSize) break;
+      if (totalSize >= maxTotalSize) {
+        break;
+      }
 
       try {
         const fileContent = fs.readFileSync(file.fullPath, 'utf8');
@@ -809,7 +873,8 @@ Follow the analysis guidelines from the system instructions to identify custom i
 
         content += `\n\n=== ${file.relativePath} (${file.category}) ===\n${contentToAdd}`;
         totalSize += contentToAdd.length;
-      } catch (error) {
+      }
+      catch (error) {
         content += `\n\n=== ${file.relativePath} (${file.category}) ===\n[Could not read file: ${error.message}]`;
       }
     }
@@ -873,7 +938,8 @@ Follow the analysis guidelines from the system instructions to identify custom i
         projectName = packageJson.name || projectName;
         const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
         technologies = Object.keys(deps).slice(0, 10);
-      } catch {
+      }
+      catch {
         // Continue with defaults
       }
     }

package/src/rag-analyzer.js

@@ -55,7 +55,8 @@ async function ensureSemanticSimilarityInitialized() {
     // Initialize semantic similarity using the shared embeddings system
     await initializeSemanticSimilarity();
     semanticSimilarityInitialized = true;
-  } catch (error) {
+  }
+  catch (error) {
     console.warn(chalk.yellow(`⚠️ Could not initialize semantic similarity: ${error.message}`));
     // Continue without semantic similarity - word-based fallback will be used
   }
@@ -228,7 +229,8 @@ async function getProjectSummary(projectPath, options = {}) {
     }
 
     return summary;
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error retrieving project summary: ${error.message}`));
     return null;
   }
@@ -240,7 +242,9 @@ async function getProjectSummary(projectPath, options = {}) {
  * @returns {string} Formatted context string
  */
 function formatProjectSummaryForLLM(summary) {
-  if (!summary) return '';
+  if (!summary) {
+    return '';
+  }
 
   let context = `\n## PROJECT ARCHITECTURE CONTEXT\n\n`;
 
@@ -456,7 +460,8 @@ async function runAnalysis(filePath, options = {}) {
       // For PR reviews, always read the full file content for context awareness
       fullFileContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
       verboseLog(options, chalk.blue(`Analyzing diff only for ${path.basename(filePath)}`));
-    } else {
+    }
+    else {
       content = fs.readFileSync(filePath, 'utf8');
       fullFileContent = content;
       verboseLog(options, chalk.blue(`Analyzing full file ${path.basename(filePath)}`));
@@ -503,7 +508,8 @@ async function runAnalysis(filePath, options = {}) {
         verboseLog(options, chalk.magenta(`  [${i + 1}] Path: ${g.path} ${g.headingText ? `(Heading: "${g.headingText}")` : ''}`));
         verboseLog(options, chalk.gray(`      Content: ${g.content.substring(0, 100).replace(/\\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
 
@@ -513,7 +519,8 @@ async function runAnalysis(filePath, options = {}) {
         verboseLog(options, chalk.magenta(`  [${i + 1}] Path: ${ex.path} (Similarity: ${ex.similarity?.toFixed(3) || 'N/A'})`));
         verboseLog(options, chalk.gray(`      Content: ${ex.content.substring(0, 100).replace(/\\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
 
@@ -524,7 +531,8 @@ async function runAnalysis(filePath, options = {}) {
         verboseLog(options, chalk.magenta(`      Similarity: ${chunk.similarity?.toFixed(3) || 'N/A'}`));
         verboseLog(options, chalk.gray(`      Content: ${chunk.content.substring(0, 100).replace(/\\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
     verboseLog(options, chalk.magenta('---------------------------------'));
@@ -593,7 +601,8 @@ async function runAnalysis(filePath, options = {}) {
         ...(filteredResults.metadata || {}),
       },
     };
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error analyzing file: ${error.message}`));
     return {
       success: false,
@@ -745,7 +754,8 @@ async function callLLMForAnalysis(context, options = {}) {
 
     if (options.isHolisticPRReview) {
       prompt = generateHolisticPRAnalysisPrompt(context);
-    } else {
+    }
+    else {
       prompt = options.isTestFile ? generateTestFileAnalysisPrompt(context) : generateAnalysisPrompt(context);
     }
 
@@ -781,7 +791,8 @@ async function callLLMForAnalysis(context, options = {}) {
 
     verboseLog(options, chalk.green('Successfully parsed LLM response with expected structure'));
     return analysisResponse;
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error calling LLM for analysis: ${error.message}`));
     console.error(error.stack);
     throw error;
@@ -945,7 +956,8 @@ async function sendPromptToLLM(promptConfig, llmOptions) {
     });
 
     return response;
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error in LLM call: ${error.message}`));
     throw error;
   }
@@ -1013,10 +1025,12 @@ Similar code patterns and issues identified by human reviewers in past PRs
       prHistorySection += `Only report issues that EXACTLY match historical patterns with SPECIFIC code fixes.\n\n`;
 
       verboseLog(context.options, chalk.blue(`PR History section preview: ${prHistorySection.substring(0, 200)}...`));
-    } else {
+    }
+    else {
       verboseLog(context.options, chalk.yellow(`❌ No PR comments section found in context`));
     }
-  } else {
+  }
+  else {
     verboseLog(context.options, chalk.yellow(`❌ No context sections available for PR comments`));
   }
 
@@ -1476,7 +1490,8 @@ async function getPRCommentContext(filePath, options = {}) {
         fileContent = fs.readFileSync(filePath, 'utf8');
         const maxEmbeddingLength = 8000; // Keep consistent with original truncation
         contentForSearch = fileContent.length > maxEmbeddingLength ? fileContent.substring(0, maxEmbeddingLength) : fileContent;
-      } catch (readError) {
+      }
+      catch (readError) {
         debug(`[getPRCommentContext] Could not read file ${filePath}: ${readError.message}`);
         return {
           success: false,
@@ -1486,11 +1501,13 @@ async function getPRCommentContext(filePath, options = {}) {
           summary: 'Failed to read file for context analysis',
         };
       }
-    } else {
+    }
+    else {
       // Fallback to original behavior if no pre-computed embedding provided
       try {
         fileContent = fs.readFileSync(filePath, 'utf8');
-      } catch (readError) {
+      }
+      catch (readError) {
         debug(`[getPRCommentContext] Could not read file ${filePath}: ${readError.message}`);
         return {
           success: false,
@@ -1537,7 +1554,8 @@ async function getPRCommentContext(filePath, options = {}) {
           );
         });
       }
-    } catch (dbError) {
+    }
+    catch (dbError) {
       console.warn(chalk.yellow(`⚠️ Hybrid search failed: ${dbError.message}`));
       debug(`[getPRCommentContext] Hybrid search failed: ${dbError.message}`);
       // No fallback needed - if hybrid search fails, we just return empty results
@@ -1568,7 +1586,8 @@ async function getPRCommentContext(filePath, options = {}) {
           relevantComments.length > 0 && relevantComments[0].similarity_score !== 0.5 ? 'semantic_embedding' : 'file_path_fallback',
       },
     };
-  } catch (error) {
+  }
+  catch (error) {
     debug(`[getPRCommentContext] Error getting PR comment context: ${error.message}`);
     return {
       success: false,
@@ -1737,7 +1756,8 @@ async function performHolisticPRAnalysis(options) {
         );
         verboseLog(options, chalk.gray(`      Content: ${g.content.substring(0, 100).replace(/\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
 
@@ -1747,7 +1767,8 @@ async function performHolisticPRAnalysis(options) {
         verboseLog(options, chalk.magenta(`  [${i + 1}] Path: ${ex.path} (Similarity: ${ex.similarity?.toFixed(3) || 'N/A'})`));
         verboseLog(options, chalk.gray(`      Content: ${ex.content.substring(0, 100).replace(/\\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
 
@@ -1763,7 +1784,8 @@ async function performHolisticPRAnalysis(options) {
         verboseLog(options, chalk.gray(`      File: ${comment.filePath}`));
         verboseLog(options, chalk.gray(`      Comment: ${comment.body.substring(0, 100).replace(/\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
 
@@ -1774,7 +1796,8 @@ async function performHolisticPRAnalysis(options) {
         verboseLog(options, chalk.gray(`      Similarity: ${chunk.similarity?.toFixed(3) || 'N/A'}`));
         verboseLog(options, chalk.gray(`      Content: ${chunk.content.substring(0, 100).replace(/\n/g, ' ')}...`));
       });
-    } else {
+    }
+    else {
       verboseLog(options, chalk.magenta('  (None)'));
     }
     verboseLog(options, chalk.magenta('--- Sending Holistic PR Analysis Prompt to LLM ---'));
@@ -1821,7 +1844,8 @@ async function performHolisticPRAnalysis(options) {
         },
       },
     };
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error in holistic PR analysis: ${error.message}`));
     return {
       success: false,
@@ -1852,7 +1876,8 @@ async function getContextForFile(filePath, content, options = {}) {
   // Note: This may be called concurrently. `initializeTables` should be idempotent.
   try {
     await embeddingsSystem.initialize();
-  } catch (initError) {
+  }
+  catch (initError) {
     console.warn(chalk.yellow(`Database initialization warning: ${initError.message}`));
   }
 
@@ -1932,7 +1957,8 @@ async function getContextForFile(filePath, content, options = {}) {
         verboseLog(options, chalk.cyan('📄 Custom documents not yet processed for this project, processing now...'));
         // Process custom documents into chunks (only if not already processed)
         processedChunks = await embeddingsSystem.processCustomDocumentsInMemory(options.customDocs, projectPath);
-      } else {
+      }
+      else {
         verboseLog(options, chalk.green(`📄 Reusing ${processedChunks.length} already processed custom document chunks`));
       }
 
@@ -1961,7 +1987,8 @@ async function getContextForFile(filePath, content, options = {}) {
 
         return relevantChunks;
       }
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error processing custom documents: ${error.message}`));
     }
 
@@ -1973,7 +2000,8 @@ async function getContextForFile(filePath, content, options = {}) {
     try {
       // Use the statically imported function
       return await embeddingsSystem.getExistingCustomDocumentChunks(projectPath);
-    } catch {
+    }
+    catch {
       verboseLog(options, chalk.gray('No existing custom document chunks found, will process from scratch'));
       return [];
     }
@@ -1982,7 +2010,8 @@ async function getContextForFile(filePath, content, options = {}) {
   const withContextFallback = async (promise, fallbackValue, label) => {
     try {
       return await promise;
-    } catch (error) {
+    }
+    catch (error) {
       console.warn(chalk.yellow(`${label} failed: ${error.message}`));
       return fallbackValue;
     }
@@ -2055,11 +2084,14 @@ async function getContextForFile(filePath, content, options = {}) {
     if (isGenericDocument(docPath, docH1)) {
       candidateDocFullContext = getGenericDocumentContext(docPath, docH1);
       debug(`[FAST-PATH] Using pre-computed context for generic document in RAG: ${docPath}`);
-    } else {
+    }
+    else {
       candidateDocFullContext = await inferContextFromDocumentContent(docPath, docH1, docChunks, language);
     }
     const relevantChunksForDoc = docChunks.filter((c) => c.similarity >= RELEVANT_CHUNK_THRESHOLD);
-    if (relevantChunksForDoc.length === 0) continue;
+    if (relevantChunksForDoc.length === 0) {
+      continue;
+    }
 
     const maxChunkScoreInDoc = Math.max(...relevantChunksForDoc.map((c) => c.similarity));
     const avgChunkScoreInDoc = relevantChunksForDoc.reduce((sum, c) => sum + c.similarity, 0) / relevantChunksForDoc.length;
@@ -2080,7 +2112,8 @@ async function getContextForFile(filePath, content, options = {}) {
             break;
           }
         }
-      } else if (reviewedSnippetContext.area !== 'GeneralJS_TS') {
+      }
+      else if (reviewedSnippetContext.area !== 'GeneralJS_TS') {
         docLevelContextMatchScore -= 0.2;
       }
     }
@@ -2205,13 +2238,15 @@ async function gatherUnifiedContextForPR(prFiles, options = {}) {
       if (!processedChunks || processedChunks.length === 0) {
         verboseLog(options, chalk.cyan('📄 Custom documents not yet processed for this project, processing now...'));
         processedChunks = await embeddingsSystem.processCustomDocumentsInMemory(options.customDocs, projectPath);
-      } else {
+      }
+      else {
         verboseLog(options, chalk.green(`📄 Reusing ${processedChunks.length} already processed custom document chunks`));
       }
 
       globalCustomDocChunks = processedChunks;
       verboseLog(options, chalk.green(`📄 Custom documents processed: ${globalCustomDocChunks.length} chunks available for PR analysis`));
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error processing custom documents for PR: ${error.message}`));
     }
   }
@@ -2231,7 +2266,8 @@ async function gatherUnifiedContextForPR(prFiles, options = {}) {
         ...context,
         filePath,
       };
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error gathering context for file ${file.filePath}: ${error.message}`));
       return null; // Return null on error for this file
     }

package/src/rag-analyzer.test.js

@@ -910,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' }];
@@ -933,7 +942,9 @@ describe('rag-analyzer', () => {
   describe('gatherUnifiedContextForPR error handling', () => {
     it('should handle file context gathering errors', async () => {
       fs.readFileSync.mockImplementation((path) => {
-        if (path.includes('error-file')) throw new Error('Read error');
+        if (path.includes('error-file')) {
+          throw new Error('Read error');
+        }
         return 'const x = 1;';
       });
       const prFiles = [

package/src/rag-review.js

@@ -73,7 +73,8 @@ async function reviewFile(filePath, options = {}) {
 
     // If analysis failed, return the error
     return analyzeResult;
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error reviewing file ${filePath}:`), error.message);
     return {
       success: false,
@@ -143,7 +144,8 @@ async function reviewFiles(filePaths, options = {}) {
       results: validResults, // Return array of individual file results
       message: finalMessage,
     };
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error reviewing multiple files: ${error.message}`));
     console.error(error.stack);
     return {
@@ -186,7 +188,8 @@ async function reviewPullRequest(changedFilePaths, options = {}) {
 
     // Use enhanced PR review with cross-file context
     return await reviewPullRequestWithCrossFileContext(filesToReview, options);
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error reviewing pull request files: ${error.message}`));
     console.error(error.stack);
     return {
@@ -263,7 +266,8 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
           baseBranch,
           targetBranch,
         });
-      } catch (error) {
+      }
+      catch (error) {
         console.warn(chalk.yellow(`Error processing file ${filePath}: ${error.message}`));
       }
     }
@@ -429,7 +433,8 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
           },
         },
       };
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error in holistic PR review: ${error.message}`));
 
       // Fallback to individual file review if holistic review fails
@@ -469,7 +474,8 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
 
             const result = await runAnalysis(file.filePath, enhancedOptions);
             return result;
-          } catch (error) {
+          }
+          catch (error) {
             console.error(chalk.red(`Error reviewing ${file.filePath}: ${error.message}`));
             return {
               filePath: file.filePath,
@@ -496,7 +502,8 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
         },
       };
     }
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error in enhanced PR review: ${error.message}`));
     return {
       success: false,