codecritique 1.2.3 → 2.0.0

package/src/custom-documents.js

@@ -70,7 +70,8 @@ export class CustomDocumentProcessor {
       const headerMatch = content.match(/^#\s+(.+)$/m);
       if (headerMatch) {
         documentTitle = headerMatch[1].trim();
-      } else {
+      }
+      else {
         // If no header found, try to extract filename from title like "instruction:./FILENAME.md"
         const filePathMatch = title.match(/:\.\/([^/]+)\.([a-zA-Z]+)$/);
         if (filePathMatch) {
@@ -88,7 +89,9 @@ export class CustomDocumentProcessor {
 
       for (let i = 0; i < sections.length; i++) {
         const section = sections[i].trim();
-        if (!section) continue;
+        if (!section) {
+          continue;
+        }
 
         // Check if adding this section would exceed max chunk size
         if (currentChunk.length + section.length > maxChunkSize && currentChunk.length > minChunkSize) {
@@ -108,7 +111,8 @@ export class CustomDocumentProcessor {
 
           chunkIndex++;
           currentChunk = section;
-        } else {
+        }
+        else {
           // Add section to current chunk
           currentChunk += (currentChunk ? '\n\n' : '') + section;
         }
@@ -142,7 +146,8 @@ export class CustomDocumentProcessor {
 
       verboseLog({}, chalk.gray(`  Chunked document "${documentTitle}" into ${chunks.length} chunks`));
       return chunks;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error chunking document: ${error.message}`));
       throw new EmbeddingError(`Document chunking failed: ${error.message}`);
     }
@@ -195,7 +200,8 @@ export class CustomDocumentProcessor {
                 project_path: path.resolve(projectPath),
                 created_at: new Date().toISOString(),
               };
-            } else {
+            }
+            else {
               console.error(chalk.red(`Error generating embedding for chunk ${chunk.id}: batch processing failed`));
               return null;
             }
@@ -207,7 +213,8 @@ export class CustomDocumentProcessor {
 
           verboseLog({}, chalk.gray(`    Generated embeddings for ${validChunks.length}/${chunks.length} chunks`));
           this.performanceMetrics.embeddingsCalculated += validChunks.length;
-        } catch (error) {
+        }
+        catch (error) {
           console.error(chalk.red(`Error in batch embedding generation for document ${doc.title}: ${error.message}`));
           // Fallback to individual processing for this document
           verboseLog({}, chalk.yellow(`    Falling back to individual processing for ${doc.title}`));
@@ -225,7 +232,8 @@ export class CustomDocumentProcessor {
                   project_path: path.resolve(projectPath),
                   created_at: new Date().toISOString(),
                 };
-              } catch (error) {
+              }
+              catch (error) {
                 console.error(chalk.red(`Error generating embedding for chunk ${chunk.id}: ${error.message}`));
                 return null;
               }
@@ -254,7 +262,8 @@ export class CustomDocumentProcessor {
 
       verboseLog({}, chalk.green(`Successfully processed ${allChunks.length} custom document chunks (${Date.now() - startTime}ms)`));
       return allChunks;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error processing custom documents: ${error.message}`));
       throw new EmbeddingError(`Custom document processing failed: ${error.message}`);
     }
@@ -327,7 +336,8 @@ export class CustomDocumentProcessor {
       }
 
       return filteredResults;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error searching custom document chunks: ${error.message}`));
       throw new EmbeddingError(`Custom document search failed: ${error.message}`);
     }
@@ -360,7 +370,8 @@ export class CustomDocumentProcessor {
 
       debug(`[getExistingChunks] No existing chunks found for project: ${resolvedProjectPath}`);
       return [];
-    } catch (error) {
+    }
+    catch (error) {
       debug(`[getExistingChunks] Error checking existing chunks: ${error.message}`);
       return [];
     }
@@ -419,7 +430,8 @@ export class CustomDocumentProcessor {
               contextMatchBonus += MODERATE_BOOST_TECH_MATCH;
             }
           }
-        } else if (queryArea !== 'GeneralJS_TS') {
+        }
+        else if (queryArea !== 'GeneralJS_TS') {
           contextMatchBonus += HEAVY_PENALTY_AREA_MISMATCH;
         }
       }
@@ -505,7 +517,8 @@ export class CustomDocumentProcessor {
             this.h1EmbeddingCache.set(docTitlesToCalculate[i], titleEmbeddings[i]);
           }
         }
-      } catch (error) {
+      }
+      catch (error) {
         debug(`[OPTIMIZATION] Error in batch title embedding calculation: ${error.message}`);
         // Continue without title embeddings
       }
@@ -522,7 +535,8 @@ export class CustomDocumentProcessor {
       this.customDocumentChunks.delete(resolvedProjectPath);
       this.cacheManager.customDocumentChunks.delete(resolvedProjectPath);
       verboseLog({}, chalk.green(`Cleared custom document chunks for project: ${resolvedProjectPath}`));
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error clearing project chunks: ${error.message}`));
     }
   }
@@ -590,7 +604,8 @@ export class CustomDocumentProcessor {
       };
 
       verboseLog({}, chalk.green('CustomDocumentProcessor cleanup complete'));
-    } finally {
+    }
+    finally {
       this.cleaningUp = false;
     }
   }

package/src/feedback-loader.js

@@ -68,7 +68,8 @@ export async function loadFeedbackData(feedbackPath, options = {}) {
           totalItems += itemCount;
           verboseLog(verbose, chalk.cyan(`📋 Loaded feedback from ${file}: ${itemCount} items`));
         }
-      } catch (parseError) {
+      }
+      catch (parseError) {
         console.warn(chalk.yellow(`⚠️ Error parsing feedback file ${file}: ${parseError.message}`));
       }
     }
@@ -79,7 +80,8 @@ export async function loadFeedbackData(feedbackPath, options = {}) {
     }
 
     return {};
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`❌ Error loading feedback data: ${error.message}`));
     return {};
   }
@@ -112,7 +114,8 @@ export async function initializeSemanticSimilarity() {
     semanticSimilarityInitialized = true;
     semanticSimilarityAvailable = true;
     verboseLog({}, chalk.green('[FeedbackLoader] Semantic similarity initialized using embeddings system'));
-  } catch (error) {
+  }
+  catch (error) {
     console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity initialization failed: ${error.message}`));
     semanticSimilarityAvailable = false;
   }
@@ -154,7 +157,8 @@ async function calculateSemanticSimilarity(text1, text2) {
     const similarity = calculateCosineSimilarity(embedding1, embedding2);
     // Cosine similarity ranges from -1 to 1, normalize to 0-1
     return (similarity + 1) / 2;
-  } catch (error) {
+  }
+  catch (error) {
     console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity calculation failed: ${error.message}`));
     return null;
   }
@@ -207,7 +211,9 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
 
   // Check similarity with dismissed issues
   for (const dismissed of dismissedIssues) {
-    if (!dismissed.originalIssue) continue;
+    if (!dismissed.originalIssue) {
+      continue;
+    }
 
     let similarity;
     let similarityMethod;
@@ -222,7 +228,8 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
         similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
         similarityMethod = 'word-based';
       }
-    } else {
+    }
+    else {
       // Use word-based similarity
       similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
       similarityMethod = 'word-based';
@@ -297,7 +304,9 @@ export async function calculateIssueSimilarity(text1, text2, options = {}) {
  * @returns {number} Similarity score (0-1)
  */
 export function calculateWordSimilarity(text1, text2) {
-  if (!text1 || !text2) return 0;
+  if (!text1 || !text2) {
+    return 0;
+  }
 
   // Normalize and tokenize
   const normalize = (text) =>
@@ -310,7 +319,9 @@ export function calculateWordSimilarity(text1, text2) {
   const words1 = new Set(normalize(text1));
   const words2 = new Set(normalize(text2));
 
-  if (words1.size === 0 || words2.size === 0) return 0;
+  if (words1.size === 0 || words2.size === 0) {
+    return 0;
+  }
 
   // Calculate Jaccard similarity (intersection over union)
   const intersection = [...words1].filter((word) => words2.has(word)).length;

package/src/index.js

@@ -103,11 +103,13 @@ program
       await embeddingsSystem.clearAllEmbeddings();
       console.log(chalk.green('All embeddings have been cleared.'));
       await embeddingsSystem.databaseManager.cleanup();
-    } catch (err) {
+    }
+    catch (err) {
       console.error(chalk.red('Error clearing all embeddings:'), err.message);
       try {
         await embeddingsSystem.databaseManager.cleanup();
-      } catch (cleanupErr) {
+      }
+      catch (cleanupErr) {
         console.error(chalk.red('Error during cleanup:'), cleanupErr.message);
       }
       process.exit(1);
@@ -203,7 +205,8 @@ const hasCommand = process.argv
 if (!hasCommand && process.argv.length > 2) {
   // If no command is specified but there are arguments, default to 'analyze'
   program.parse(['node', 'index.js', 'analyze', ...process.argv.slice(2)]);
-} else {
+}
+else {
   program.parse();
 }
 
@@ -223,7 +226,8 @@ process.on('SIGINT', async () => {
     clearTimeout(forceExitTimeout); // Cleanup finished, clear the timeout
     console.log(chalk.cyan('SIGINT handler: Exiting normally (code 0).'));
     process.exit(0); // Exit normally
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error during embeddingsSystem.cleanup():'), err.message);
     clearTimeout(forceExitTimeout);
     console.log(chalk.cyan('SIGINT handler: Exiting after error (code 1).'));
@@ -246,7 +250,8 @@ process.on('SIGTERM', async () => {
     clearTimeout(forceExitTimeout); // Cleanup finished, clear the timeout
     console.log(chalk.cyan('SIGTERM handler: Exiting normally (code 0).'));
     process.exit(0); // Exit normally
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error during embeddingsSystem.cleanup():'), err.message);
     clearTimeout(forceExitTimeout);
     console.log(chalk.cyan('SIGTERM handler: Exiting after error (code 1).'));
@@ -366,13 +371,15 @@ async function runCodeReview(options) {
         diffWith: options.diffWith,
       };
       reviewTask = reviewPullRequest(changedFiles, enhancedReviewOptions);
-    } else if (options.file) {
+    }
+    else if (options.file) {
       operationDescription = `single file: ${options.file}`;
       if (!fs.existsSync(options.file)) {
         throw new Error(`File not found: ${options.file}`);
       }
       reviewTask = reviewFile(options.file, reviewOptions);
-    } else if (options.files && options.files.length > 0) {
+    }
+    else if (options.files && options.files.length > 0) {
       const filesToAnalyze = await expandFilePatterns(options.files);
       if (filesToAnalyze.length === 0) {
         console.log(chalk.yellow('No files found matching the specified patterns. Exiting.'));
@@ -380,7 +387,8 @@ async function runCodeReview(options) {
       }
       operationDescription = `${filesToAnalyze.length} specific files/patterns`;
       reviewTask = reviewFiles(filesToAnalyze, reviewOptions);
-    } else {
+    }
+    else {
       // No valid options provided - show error and exit
       console.error(chalk.red('Error: You must specify one of the following:'));
       console.error(chalk.yellow('  --file <file>                    Analyze a single file'));
@@ -418,7 +426,8 @@ async function runCodeReview(options) {
         // Pass the detailed results array to the output function
         outputFn(reviewResult.results, options);
         console.log(chalk.bold.green(`\nAnalysis complete for ${operationDescription}! (${duration}s)`));
-      } else {
+      }
+      else {
         // No results to display (e.g., all files were excluded/skipped)
         const message = reviewResult.message || 'All files were excluded from review (e.g., config files, lock files).';
         console.log(chalk.yellow(message));
@@ -432,7 +441,8 @@ async function runCodeReview(options) {
 
         console.log(chalk.bold.yellow(`\nReview complete for ${operationDescription} - no reviewable files found (${duration}s)`));
       }
-    } else {
+    }
+    else {
       console.error(chalk.red('\nCode review process failed.'));
       if (reviewResult && reviewResult.error) {
         console.error(chalk.red(`Error: ${reviewResult.error}`));
@@ -445,11 +455,13 @@ async function runCodeReview(options) {
       await embeddingsSystem.cleanup();
       await cleanupClassifier();
       console.log(chalk.green('All resources cleaned up successfully'));
-    } catch (cleanupErr) {
+    }
+    catch (cleanupErr) {
       console.error(chalk.yellow('Error during cleanup:'), cleanupErr.message);
       process.exit(1);
     }
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red(`\nError during code review (${operationDescription}):`), err.message);
     console.error(err.stack);
     // Clean up resources even on error
@@ -457,7 +469,8 @@ async function runCodeReview(options) {
       await embeddingsSystem.cleanup();
       await cleanupClassifier();
       console.log(chalk.green('All resources cleaned up successfully'));
-    } catch (cleanupErr) {
+    }
+    catch (cleanupErr) {
       console.error(chalk.red('Error during cleanup:'), cleanupErr.message);
     }
     process.exit(1);
@@ -500,7 +513,8 @@ async function generateEmbeddings(options) {
           .map((line) => line.trim())
           .filter((line) => line && !line.startsWith('#'));
         excludePatterns = [...excludePatterns, ...filePatterns];
-      } else {
+      }
+      else {
         console.warn(chalk.yellow(`Exclude file not found: ${excludeFilePath}`));
       }
     }
@@ -512,19 +526,22 @@ async function generateEmbeddings(options) {
     // Log gitignore status
     if (options.gitignore === false) {
       console.log(chalk.yellow('Automatic .gitignore exclusion is disabled.'));
-    } else {
+    }
+    else {
       console.log(chalk.cyan('Respecting .gitignore patterns (if present).'));
     }
     console.log(chalk.green('Exclusion pattern processing complete.'));
 
     // Get files to process
     let filesToProcess = [];
+    const runMode = options.files && options.files.length > 0 ? 'partial' : 'full';
 
     if (options.files && options.files.length > 0) {
       console.log(chalk.cyan('Processing specified files/patterns...'));
       filesToProcess = await expandFilePatterns(options.files, baseDir);
       console.log(chalk.green(`Expanded specified files/patterns to ${filesToProcess.length} files.`));
-    } else {
+    }
+    else {
       console.log(chalk.cyan(`Scanning directory for supported files: ${baseDir}`));
       // Show spinner during file discovery
       const scanSpinner = new Spinner('Scanning files... %s');
@@ -585,15 +602,19 @@ async function generateEmbeddings(options) {
         baseDir: baseDir,
         batchSize: 100, // Set a reasonable batch size
         maxLines: parseInt(options.maxLines || '1000', 10),
+        runMode,
         onProgress: (status) => {
           // Update counters based on status
           if (status === 'processed') {
             processedCount++;
-          } else if (status === 'skipped') {
+          }
+          else if (status === 'skipped') {
             skippedCount++;
-          } else if (status === 'failed') {
+          }
+          else if (status === 'failed') {
             failedCount++;
-          } else if (status === 'excluded') {
+          }
+          else if (status === 'excluded') {
             excludedCount++;
           }
 
@@ -601,7 +622,8 @@ async function generateEmbeddings(options) {
           updateSpinner();
         },
       });
-    } finally {
+    }
+    finally {
       // Clean up the progress display even if embedding generation fails.
       clearInterval(progressInterval);
       spinner.stop(true);
@@ -625,9 +647,6 @@ async function generateEmbeddings(options) {
         forceAnalysis: options.forceAnalysis,
       });
 
-      // Store project summary in embeddings system for later use
-      await embeddingsSystem.storeProjectSummary(projectDir, projectSummary);
-
       console.log(chalk.green('✅ Project analysis complete and stored'));
       verboseLog(options, chalk.gray(`   Project: ${projectSummary.projectName}`));
       verboseLog(
@@ -637,7 +656,8 @@ async function generateEmbeddings(options) {
         )
       );
       verboseLog(options, chalk.gray(`   Key patterns: ${projectSummary.keyPatterns.length}`));
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red('⚠️ Project analysis failed but continuing:'), error.message);
     }
 
@@ -645,7 +665,8 @@ async function generateEmbeddings(options) {
     console.log(chalk.cyan('Cleaning up resources...'));
     await embeddingsSystem.cleanup();
     console.log(chalk.green('Cleanup successful.'));
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error generating embeddings:'), err.message);
     console.error(err.stack);
     // Clean up resources even on error
@@ -653,7 +674,8 @@ async function generateEmbeddings(options) {
       console.log(chalk.cyan('Cleaning up resources after error...'));
       await embeddingsSystem.cleanup();
       console.log(chalk.green('Cleanup successful.'));
-    } catch (cleanupErr) {
+    }
+    catch (cleanupErr) {
       console.error(chalk.red('Error during cleanup:'), cleanupErr.message);
     }
     process.exit(1);
@@ -679,13 +701,15 @@ async function clearEmbeddings(options) {
     // Clean up resources (only database connection since we skipped full initialization)
     console.log(chalk.cyan('Cleaning up resources...'));
     await embeddingsSystem.databaseManager.cleanup();
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error clearing embeddings:'), err.message);
     console.error(err.stack);
     // Clean up resources even on error (only database connection)
     try {
       await embeddingsSystem.databaseManager.cleanup();
-    } catch (cleanupErr) {
+    }
+    catch (cleanupErr) {
       console.error(chalk.red('Error during cleanup:'), cleanupErr.message);
     }
     process.exit(1);
@@ -704,7 +728,8 @@ async function showEmbeddingStats(options) {
 
     if (options.directory) {
       console.log(chalk.cyan(`Fetching embedding statistics for project: ${projectDir}`));
-    } else {
+    }
+    else {
       console.log(chalk.cyan('Fetching embedding statistics for all projects...'));
     }
 
@@ -715,7 +740,8 @@ async function showEmbeddingStats(options) {
 
     if (!stats || Object.keys(stats).length === 0 || stats.totalCount === 0) {
       console.log(chalk.yellow('No embeddings found or database is empty.'));
-    } else {
+    }
+    else {
       console.log(` ${chalk.cyan('Total Embeddings:')} ${chalk.green(stats.totalCount)}`);
       if (stats.dimensions) {
         console.log(` ${chalk.cyan('Vector Dimensions:')} ${chalk.green(stats.dimensions)}`);
@@ -734,7 +760,8 @@ async function showEmbeddingStats(options) {
     // Clean up resources
     // console.log(chalk.cyan('Cleaning up resources...'));
     // await embeddingsSystem.cleanup();
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error fetching embedding statistics:'), err.message);
     console.error(err.stack);
     // Clean up resources even on error
@@ -870,10 +897,12 @@ async function findSupportedFiles(directory, options = {}) {
     // Add log after the filtering loop (now just assignment)
     verboseLog(options, chalk.green(`Finished filtering glob results. ${finalFiles.length} files remain.`));
     return finalFiles;
-  } catch (err) {
+  }
+  catch (err) {
     if (err.name === 'AbortError') {
       console.error(chalk.red('Glob operation timed out. The directory might be too large or complex.'));
-    } else {
+    }
+    else {
       console.error(chalk.red(`Error during glob file search: ${err.message}`));
     }
     console.error(err.stack); // Log stack for debugging
@@ -898,7 +927,8 @@ async function expandFilePatterns(patterns, baseDir = process.cwd()) {
       // Check if it's a direct file path first
       if (fs.existsSync(absolutePattern) && fs.statSync(absolutePattern).isFile()) {
         files.add(absolutePattern);
-      } else {
+      }
+      else {
         // Treat as a glob pattern
         // Use the original pattern with baseDir as cwd for correct globbing
         const matchedFiles = await glob.glob(pattern, { cwd: baseDir, absolute: true, nodir: true });
@@ -911,7 +941,8 @@ async function expandFilePatterns(patterns, baseDir = process.cwd()) {
       }
     }
     return Array.from(files);
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error expanding file patterns:'), err.message);
     return [];
   }
@@ -940,7 +971,8 @@ function getChangedFiles(branch, workingDir = process.cwd()) {
     // Ensure the base branch exists locally as well (crucial for diff operations)
     try {
       ensureBranchExists(baseBranch, workingDir);
-    } catch (error) {
+    }
+    catch (error) {
       console.warn(chalk.yellow(`Warning: Could not ensure base branch '${baseBranch}' exists locally: ${error.message}`));
       // Continue with the original baseBranch name, it might work with remote refs
     }
@@ -963,7 +995,8 @@ function getChangedFiles(branch, workingDir = process.cwd()) {
     }
 
     return changedFiles;
-  } catch (err) {
+  }
+  catch (err) {
     console.error(chalk.red('Error getting git diff:'), err.message);
     return [];
   }
@@ -989,7 +1022,9 @@ function outputJson(reviewResults, options) {
       filesWithIssues: reviewResults.filter((r) => r.success && !r.skipped && r.results?.issues?.length > 0).length,
       totalIssues: reviewResults.reduce((sum, r) => sum + (r.results?.issues?.length || 0), 0),
       issuesWithCodeSuggestions: reviewResults.reduce((sum, r) => {
-        if (!r.success || r.skipped || !r.results?.issues) return sum;
+        if (!r.success || r.skipped || !r.results?.issues) {
+          return sum;
+        }
         return sum + r.results.issues.filter((issue) => issue.codeSuggestion).length;
       }, 0),
       skippedFiles: reviewResults.filter((r) => r.skipped).length,
@@ -1020,7 +1055,8 @@ function outputJson(reviewResults, options) {
   if (options && options.outputFile) {
     fs.writeFileSync(options.outputFile, jsonOutput, 'utf8');
     console.log(chalk.green(`JSON output saved to: ${options.outputFile}`));
-  } else {
+  }
+  else {
     // Write JSON output to stdout (process.stdout is not buffered)
     process.stdout.write(jsonOutput);
   }
@@ -1049,8 +1085,12 @@ function outputMarkdown(reviewResults, options) {
     `- **Total Issues Found:** ${totalIssues}`,
   ];
 
-  if (skippedFiles > 0) lines.push(`- **Files Skipped:** ${skippedFiles}`);
-  if (errorFiles > 0) lines.push(`- **Errors:** ${errorFiles}`);
+  if (skippedFiles > 0) {
+    lines.push(`- **Files Skipped:** ${skippedFiles}`);
+  }
+  if (errorFiles > 0) {
+    lines.push(`- **Errors:** ${errorFiles}`);
+  }
 
   lines.push('', '## Detailed Review per File', '');
 
@@ -1129,8 +1169,12 @@ function outputText(reviewResults, cliOptions) {
   console.log(`Files Analyzed: ${chalk.bold(totalFiles)}`);
   console.log(`Files with Issues: ${chalk.bold(filesWithIssues)}`);
   console.log(`Total Issues Found: ${chalk.bold(totalIssues)}`);
-  if (skippedFiles > 0) console.log(`Files Skipped: ${chalk.yellow(skippedFiles)}`);
-  if (errorFiles > 0) console.log(`Errors: ${chalk.red(errorFiles)}`);
+  if (skippedFiles > 0) {
+    console.log(`Files Skipped: ${chalk.yellow(skippedFiles)}`);
+  }
+  if (errorFiles > 0) {
+    console.log(`Errors: ${chalk.red(errorFiles)}`);
+  }
   console.log(chalk.bold.blue('================================================'));
 
   reviewResults.forEach((fileResult) => {
@@ -1290,7 +1334,8 @@ async function analyzePRHistory(options) {
     // Display results using utility function
     displayAnalysisResults(results, duration);
     console.log(chalk.bold.green(`\nPR history analysis complete for ${repository}!`));
-  } catch (error) {
+  }
+  catch (error) {
     const endTime = Date.now();
     const duration = ((endTime - startTime) / 1000).toFixed(2);
     console.error(chalk.red(`\nError during PR history analysis (${duration}s):`), error.message);
@@ -1324,10 +1369,12 @@ async function getPRHistoryStatus(options) {
     if (hasComments) {
       const stats = await getPRCommentsStats(repository, projectPath);
       displayDatabaseStats(stats, hasComments);
-    } else {
+    }
+    else {
       displayDatabaseStats(null, hasComments);
     }
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red('Error getting PR history status:'), error.message);
     process.exit(1);
   }
@@ -1388,10 +1435,12 @@ async function clearPRHistory(options) {
 
     if (cleared) {
       console.log(chalk.bold.green(`\nPR analysis data cleared successfully for ${repository}`));
-    } else {
+    }
+    else {
       console.log(chalk.yellow('No data was found to clear.'));
     }
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red('Error clearing PR history data:'), error.message);
     verboseLog(options, error.stack);
     process.exit(1);

package/src/llm.js

@@ -27,7 +27,9 @@ let anthropic = null;
  * @returns {Anthropic} The Anthropic client
  */
 function getAnthropicClient() {
-  if (anthropic) return anthropic;
+  if (anthropic) {
+    return anthropic;
+  }
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
     throw new Error('ANTHROPIC_API_KEY is required for analysis. Set it in env or .env before running analyze.');
@@ -127,14 +129,16 @@ async function sendPromptToClaude(prompt, options = {}) {
         usage: response.usage,
         json: toolUse.input,
       };
-    } else {
+    }
+    else {
       return {
         content: response.content[0]?.text || '',
         model: response.model,
         usage: response.usage,
       };
     }
-  } catch (error) {
+  }
+  catch (error) {
     console.error(chalk.red(`Error sending prompt to Claude: ${error.message}`));
     throw error;
   }