codecritique 1.2.2 → 1.2.4

package/src/feedback-loader.js

@@ -15,39 +15,41 @@ import path from 'path';
 import chalk from 'chalk';
 import { getDefaultEmbeddingsSystem } from './embeddings/factory.js';
 import { calculateCosineSimilarity } from './embeddings/similarity-calculator.js';
+import { verboseLog } from './utils/logging.js';
 
 /**
  * Load feedback data from artifacts directory
  *
  * @param {string} feedbackPath - Path to feedback artifacts directory
  * @param {Object} options - Loading options
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @returns {Promise<Object>} Loaded feedback data
  */
 export async function loadFeedbackData(feedbackPath, options = {}) {
   const { verbose = false } = options;
 
   if (!feedbackPath) {
-    if (verbose) console.log(chalk.gray('No feedback path provided'));
+    verboseLog(verbose, chalk.gray('No feedback path provided'));
     return {};
   }
 
   try {
     if (!fs.existsSync(feedbackPath)) {
-      if (verbose) console.log(chalk.gray(`Feedback directory not found: ${feedbackPath}`));
+      verboseLog(verbose, chalk.gray(`Feedback directory not found: ${feedbackPath}`));
       return {};
     }
 
-    if (verbose) console.log(chalk.cyan(`📁 Loading feedback from: ${feedbackPath}`));
+    verboseLog(verbose, chalk.cyan(`📁 Loading feedback from: ${feedbackPath}`));
 
     // Look for feedback files in the directory
     const feedbackFiles = fs.readdirSync(feedbackPath).filter((file) => file.startsWith('feedback-') && file.endsWith('.json'));
 
     if (feedbackFiles.length === 0) {
-      if (verbose) console.log(chalk.gray('No feedback files found'));
+      verboseLog(verbose, chalk.gray('No feedback files found'));
       return {};
     }
 
-    if (verbose) console.log(chalk.cyan(`📥 Found ${feedbackFiles.length} feedback file(s)`));
+    verboseLog(verbose, chalk.cyan(`📥 Found ${feedbackFiles.length} feedback file(s)`));
 
     // Load and merge all feedback files
     const allFeedback = {};
@@ -64,25 +66,21 @@ export async function loadFeedbackData(feedbackPath, options = {}) {
           Object.assign(allFeedback, feedbackData.feedback);
           const itemCount = Object.keys(feedbackData.feedback).length;
           totalItems += itemCount;
-          if (verbose) {
-            console.log(chalk.cyan(`📋 Loaded feedback from ${file}: ${itemCount} items`));
-          }
+          verboseLog(verbose, chalk.cyan(`📋 Loaded feedback from ${file}: ${itemCount} items`));
         }
       } catch (parseError) {
-        console.log(chalk.yellow(`⚠️ Error parsing feedback file ${file}: ${parseError.message}`));
+        console.warn(chalk.yellow(`⚠️ Error parsing feedback file ${file}: ${parseError.message}`));
       }
     }
 
     if (totalItems > 0) {
-      if (verbose) {
-        console.log(chalk.green(`✅ Successfully loaded ${totalItems} feedback items total`));
-      }
+      verboseLog(verbose, chalk.green(`✅ Successfully loaded ${totalItems} feedback items total`));
       return allFeedback;
     }
 
     return {};
   } catch (error) {
-    console.log(chalk.red(`❌ Error loading feedback data: ${error.message}`));
+    console.error(chalk.red(`❌ Error loading feedback data: ${error.message}`));
     return {};
   }
 }
@@ -113,9 +111,9 @@ export async function initializeSemanticSimilarity() {
     await embeddingsSystem.initialize();
     semanticSimilarityInitialized = true;
     semanticSimilarityAvailable = true;
-    console.log(chalk.green('[FeedbackLoader] Semantic similarity initialized using embeddings system'));
+    verboseLog({}, chalk.green('[FeedbackLoader] Semantic similarity initialized using embeddings system'));
   } catch (error) {
-    console.log(chalk.yellow(`[FeedbackLoader] Semantic similarity initialization failed: ${error.message}`));
+    console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity initialization failed: ${error.message}`));
     semanticSimilarityAvailable = false;
   }
 }
@@ -157,7 +155,7 @@ async function calculateSemanticSimilarity(text1, text2) {
     // Cosine similarity ranges from -1 to 1, normalize to 0-1
     return (similarity + 1) / 2;
   } catch (error) {
-    console.log(chalk.yellow(`[FeedbackLoader] Semantic similarity calculation failed: ${error.message}`));
+    console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity calculation failed: ${error.message}`));
     return null;
   }
 }
@@ -173,9 +171,9 @@ async function calculateSemanticSimilarity(text1, text2) {
  * @param {string} issueDescription - Description of the current issue
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Filtering options
- * @param {number} options.similarityThreshold - Threshold for considering issues similar (default: 0.7)
- * @param {boolean} options.verbose - Enable verbose logging
- * @param {boolean} options.useSemanticSimilarity - Use semantic similarity when available (default: true)
+ * @param {number} [options.similarityThreshold=0.7] - Threshold for considering issues similar
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
+ * @param {boolean} [options.useSemanticSimilarity=true] - Use semantic similarity when available
  * @returns {Promise<boolean>} True if issue should be skipped
  */
 export async function shouldSkipSimilarIssue(issueDescription, feedbackData, options = {}) {
@@ -205,9 +203,7 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
   // Determine if we should use semantic similarity
   const canUseSemanticSimilarity = useSemanticSimilarity && isSemanticSimilarityAvailable();
 
-  if (verbose && canUseSemanticSimilarity) {
-    console.log(chalk.cyan('🔍 Using semantic similarity for issue comparison'));
-  }
+  verboseLog(verbose && canUseSemanticSimilarity, chalk.cyan('🔍 Using semantic similarity for issue comparison'));
 
   // Check similarity with dismissed issues
   for (const dismissed of dismissedIssues) {
@@ -233,11 +229,12 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
     }
 
     if (similarity > similarityThreshold) {
-      if (verbose) {
-        console.log(chalk.yellow(`⏭️ Skipping similar dismissed issue (${(similarity * 100).toFixed(1)}% ${similarityMethod} similarity)`));
-        console.log(chalk.gray(`   Current: ${issueDescription.substring(0, 80)}...`));
-        console.log(chalk.gray(`   Previous: ${dismissed.originalIssue.substring(0, 80)}...`));
-      }
+      verboseLog(
+        verbose,
+        chalk.yellow(`⏭️ Skipping similar dismissed issue (${(similarity * 100).toFixed(1)}% ${similarityMethod} similarity)`)
+      );
+      verboseLog(verbose, chalk.gray(`   Current: ${issueDescription.substring(0, 80)}...`));
+      verboseLog(verbose, chalk.gray(`   Previous: ${dismissed.originalIssue.substring(0, 80)}...`));
       return true;
     }
   }
@@ -252,7 +249,7 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
  * @param {string} text1 - First text
  * @param {string} text2 - Second text
  * @param {Object} options - Options
- * @param {boolean} options.useSemanticSimilarity - Use semantic similarity when available (default: true)
+ * @param {boolean} [options.useSemanticSimilarity=true] - Use semantic similarity when available
  * @returns {Promise<{similarity: number, method: string}>} Similarity result with method used
  */
 export async function calculateIssueSimilarity(text1, text2, options = {}) {
@@ -327,6 +324,8 @@ export function calculateWordSimilarity(text1, text2) {
  *
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Extraction options
+ * @param {number} [options.maxPatterns=10] - Maximum number of dismissed patterns to include
+ * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @returns {Array} Array of dismissed issue patterns
  */
 export function extractDismissedPatterns(feedbackData, options = {}) {
@@ -355,9 +354,10 @@ export function extractDismissedPatterns(feedbackData, options = {}) {
     }))
     .slice(0, maxPatterns);
 
-  if (verbose && dismissedIssues.length > 0) {
-    console.log(chalk.cyan(`📋 Extracted ${dismissedIssues.length} dismissed issue patterns for LLM context`));
-  }
+  verboseLog(
+    verbose && dismissedIssues.length > 0,
+    chalk.cyan(`📋 Extracted ${dismissedIssues.length} dismissed issue patterns for LLM context`)
+  );
 
   return dismissedIssues;
 }

package/src/index.js

@@ -30,6 +30,7 @@ import { ProjectAnalyzer } from './project-analyzer.js';
 import { reviewFile, reviewFiles, reviewPullRequest } from './rag-review.js';
 import { execGitSafe } from './utils/command.js';
 import { ensureBranchExists, findBaseBranch } from './utils/git.js';
+import { verboseLog } from './utils/logging.js';
 
 // Create a default embeddings system instance
 const embeddingsSystem = getDefaultEmbeddingsSystem();
@@ -406,9 +407,7 @@ async function runCodeReview(options) {
     const endTime = Date.now();
     const duration = ((endTime - startTime) / 1000).toFixed(2);
 
-    if (options.verbose) {
-      console.log(chalk.blue(`Review process took ${duration} seconds.`));
-    }
+    verboseLog(options, chalk.blue(`Review process took ${duration} seconds.`));
 
     // Process and output results
     if (reviewResult && reviewResult.success) {
@@ -520,6 +519,7 @@ async function generateEmbeddings(options) {
 
     // 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...'));
@@ -586,6 +586,7 @@ 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') {
@@ -626,19 +627,15 @@ 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'));
-      if (options.verbose) {
-        console.log(chalk.gray(`   Project: ${projectSummary.projectName}`));
-        console.log(
-          chalk.gray(
-            `   Technologies: ${projectSummary.technologies.slice(0, 5).join(', ')}${projectSummary.technologies.length > 5 ? '...' : ''}`
-          )
-        );
-        console.log(chalk.gray(`   Key patterns: ${projectSummary.keyPatterns.length}`));
-      }
+      verboseLog(options, chalk.gray(`   Project: ${projectSummary.projectName}`));
+      verboseLog(
+        options,
+        chalk.gray(
+          `   Technologies: ${projectSummary.technologies.slice(0, 5).join(', ')}${projectSummary.technologies.length > 5 ? '...' : ''}`
+        )
+      );
+      verboseLog(options, chalk.gray(`   Key patterns: ${projectSummary.keyPatterns.length}`));
     } catch (error) {
       console.error(chalk.red('⚠️ Project analysis failed but continuing:'), error.message);
     }
@@ -756,10 +753,12 @@ async function showEmbeddingStats(options) {
  *
  * @param {string} directory - Directory to search
  * @param {object} options - Options from generateEmbeddings command
+ * @param {boolean} [options.verbose=false] - Enable verbose glob and filtering logs
+ * @param {string} [options.filePattern] - Optional override pattern instead of the default supported-file patterns
+ * @param {string[]} [options.excludePatterns] - Additional glob exclusion patterns
  * @returns {Promise<Array<string>>} Array of file paths
  */
 async function findSupportedFiles(directory, options = {}) {
-  const verbose = options.verbose || false;
   const baseDir = path.resolve(directory);
 
   // Default patterns match common code files - adjust as needed
@@ -835,19 +834,15 @@ async function findSupportedFiles(directory, options = {}) {
   // Instead, we rely on the shouldProcessFile check in embeddings.js which uses git check-ignore
   globOptions.ignore = [...excludePatterns]; // Use only explicit excludes
 
-  if (verbose) {
-    console.log(chalk.cyan('Using async glob to find files...'));
-    console.log(chalk.gray(`  Patterns: ${patternsToUse.join(', ')}`));
-    console.log(chalk.gray(`  Options:`), globOptions);
-  }
+  verboseLog(options, chalk.cyan('Using async glob to find files...'));
+  verboseLog(options, chalk.gray(`  Patterns: ${patternsToUse.join(', ')}`));
+  verboseLog(options, chalk.gray(`  Options:`), globOptions);
 
   try {
     // Use asynchronous glob
     const files = await glob.glob(patternsToUse, globOptions);
 
-    if (verbose) {
-      console.log(chalk.green(`Glob found ${files.length} potential files.`));
-    }
+    verboseLog(options, chalk.green(`Glob found ${files.length} potential files.`));
 
     // Filter results to ensure they are actual files (glob with stat should mostly handle this)
     // And apply the final utilsShouldProcessFile check (e.g., for binary content if needed)
@@ -864,9 +859,7 @@ async function findSupportedFiles(directory, options = {}) {
     //       finalFiles.push(file);
     //     }
     //   } catch (statError) {
-    //      if (verbose) {
-    //          console.warn(chalk.yellow(`Skipping file due to stat error ${path.relative(baseDir, file)}: ${statError.message}`));
-    //      }
+    //      console.warn(chalk.yellow(`Skipping file due to stat error ${path.relative(baseDir, file)}: ${statError.message}`));
     //   }
     // }
 
@@ -874,9 +867,7 @@ async function findSupportedFiles(directory, options = {}) {
     const finalFiles = files;
 
     // Add log after the filtering loop (now just assignment)
-    if (verbose) {
-      console.log(chalk.green(`Finished filtering glob results. ${finalFiles.length} files remain.`));
-    }
+    verboseLog(options, chalk.green(`Finished filtering glob results. ${finalFiles.length} files remain.`));
     return finalFiles;
   } catch (err) {
     if (err.name === 'AbortError') {
@@ -981,13 +972,13 @@ function getChangedFiles(branch, workingDir = process.cwd()) {
 // REMOVED: checkBranchExists function - Moved to utils.js
 
 // --- Output Formatting Functions --- //
-// These need to be adapted to the structure returned by cag-review.js functions
+// These consume the normalized results returned by the RAG review pipeline
 
 /**
  * Output results in JSON format
  *
- * @param {Array<Object>} reviewResults - Array of individual file review results from cag-review
- * @param {Object} cliOptions - Command line options
+ * @param {Array<Object>} reviewResults - Array of individual file review results
+ * @param {Object} options - Command line options
  */
 function outputJson(reviewResults, options) {
   // Structure the output to be informative
@@ -1015,7 +1006,7 @@ function outputJson(reviewResults, options) {
         filePath: r.filePath,
         success: true,
         language: r.language,
-        review: r.results, // Contains summary, issues (with optional codeSuggestion), positives from LLM
+        review: r.results, // Contains summary and actionable issues (with optional codeSuggestion)
         // Optionally include similar examples if needed
         // similarExamplesUsed: r.similarExamples
       };
@@ -1038,86 +1029,86 @@ function outputJson(reviewResults, options) {
  * Output results in Markdown format
  *
  * @param {Array<Object>} reviewResults - Array of individual file review results
- * @param {Object} cliOptions - Command line options
+ * @param {Object} options - Command line options
  */
-function outputMarkdown(reviewResults) {
-  console.log('# AI Code Review Results (RAG Approach)\n');
-
+function outputMarkdown(reviewResults, options) {
   const totalFiles = reviewResults.length;
   const filesWithIssues = reviewResults.filter((r) => r.success && !r.skipped && r.results?.issues?.length > 0).length;
   const totalIssues = reviewResults.reduce((sum, r) => sum + (r.results?.issues?.length || 0), 0);
   const skippedFiles = reviewResults.filter((r) => r.skipped).length;
   const errorFiles = reviewResults.filter((r) => !r.success).length;
 
-  console.log('## Summary\n');
-  console.log(`- **Files Analyzed:** ${totalFiles}`);
-  console.log(`- **Files with Issues:** ${filesWithIssues}`);
-  console.log(`- **Total Issues Found:** ${totalIssues}`);
-  if (skippedFiles > 0) console.log(`- **Files Skipped:** ${skippedFiles}`);
-  if (errorFiles > 0) console.log(`- **Errors:** ${errorFiles}`);
-  console.log('\n');
+  const lines = [
+    '# AI Code Review Results (RAG Approach)',
+    '',
+    '## Summary',
+    '',
+    `- **Files Analyzed:** ${totalFiles}`,
+    `- **Files with Issues:** ${filesWithIssues}`,
+    `- **Total Issues Found:** ${totalIssues}`,
+  ];
+
+  if (skippedFiles > 0) lines.push(`- **Files Skipped:** ${skippedFiles}`);
+  if (errorFiles > 0) lines.push(`- **Errors:** ${errorFiles}`);
 
-  console.log('## Detailed Review per File\n');
+  lines.push('', '## Detailed Review per File', '');
 
   reviewResults.forEach((fileResult) => {
-    console.log(`### ${fileResult.filePath}\n`);
+    lines.push(`### ${fileResult.filePath}`, '');
     if (!fileResult.success) {
-      console.log(`**Error:** ${fileResult.error}\n`);
+      lines.push(`**Error:** ${fileResult.error}`, '');
       return;
     }
     if (fileResult.skipped) {
-      console.log(`*Skipped (based on exclusion patterns or file type).*\n`);
+      lines.push('*Skipped (based on exclusion patterns or file type).*', '');
       return;
     }
-    if (!fileResult.results || (!fileResult.results.issues?.length && !fileResult.results.positives?.length)) {
-      console.log(`*No significant findings or issues reported.*\n`);
+    if (!fileResult.results || !fileResult.results.issues?.length) {
+      lines.push('*No actionable issues reported.*', '');
       if (fileResult.results?.summary) {
-        console.log(`**Summary:** ${fileResult.results.summary}\n`);
+        lines.push(`**Summary:** ${fileResult.results.summary}`, '');
       }
       return;
     }
 
     const review = fileResult.results;
     if (review.summary) {
-      console.log(`**Summary:** ${review.summary}\n`);
+      lines.push(`**Summary:** ${review.summary}`, '');
     }
 
     if (review.issues && review.issues.length > 0) {
-      console.log(`**Issues Found (${review.issues.length}):**\n`);
+      lines.push(`**Issues Found (${review.issues.length}):**`, '');
       review.issues.forEach((issue) => {
         const severityEmoji = getSeverityEmoji(issue.severity);
-        console.log(
+        lines.push(
           `- **[${issue.severity.toUpperCase()}] ${severityEmoji} (Lines: ${issue.lineNumbers?.join(', ') || 'N/A'})**: ${
             issue.description
           }`
         );
         if (issue.suggestion) {
-          console.log(`\n  *Suggestion:* ${issue.suggestion}\n`);
+          lines.push('', `  *Suggestion:* ${issue.suggestion}`, '');
         }
         // Include code suggestion if available
         if (issue.codeSuggestion) {
           const { startLine, endLine, newCode } = issue.codeSuggestion;
           const lineRange = endLine ? `${startLine}-${endLine}` : `${startLine}`;
-          console.log(`\n  **Suggested change (lines ${lineRange}):**\n`);
-          console.log('  ```suggestion');
-          console.log(
-            newCode
-              .split('\n')
-              .map((line) => `  ${line}`)
-              .join('\n')
-          );
-          console.log('  ```\n');
+          lines.push('', `  **Suggested change (lines ${lineRange}):**`, '', '  ```suggestion');
+          lines.push(...newCode.split('\n').map((line) => `  ${line}`));
+          lines.push('  ```', '');
         }
       });
     }
-
-    if (review.positives && review.positives.length > 0) {
-      console.log(`**Positives Found (${review.positives.length}):**\n`);
-      review.positives.forEach((positive) => {
-        console.log(`  - ${positive}\n`);
-      });
-    }
   });
+
+  const markdownOutput = `${lines.join('\n')}\n`;
+
+  if (options?.outputFile) {
+    fs.writeFileSync(options.outputFile, markdownOutput, 'utf8');
+    console.log(chalk.green(`Markdown output saved to: ${options.outputFile}`));
+    return;
+  }
+
+  process.stdout.write(markdownOutput);
 }
 
 /**
@@ -1149,17 +1140,13 @@ function outputText(reviewResults, cliOptions) {
       return;
     }
     if (fileResult.skipped) {
-      if (cliOptions.verbose) {
-        console.log(chalk.yellow(`\nSkipped: ${fileResult.filePath}`));
-      }
+      verboseLog(cliOptions, chalk.yellow(`\nSkipped: ${fileResult.filePath}`));
       return;
     }
-    if (!fileResult.results || (!fileResult.results.issues?.length && !fileResult.results.positives?.length)) {
-      if (cliOptions.verbose) {
-        console.log(chalk.green(`\nNo findings for: ${fileResult.filePath}`));
-        if (fileResult.results?.summary) {
-          console.log(chalk.green(`  Summary: ${fileResult.results.summary}`));
-        }
+    if (!fileResult.results || !fileResult.results.issues?.length) {
+      verboseLog(cliOptions, chalk.green(`\nNo findings for: ${fileResult.filePath}`));
+      if (fileResult.results?.summary) {
+        verboseLog(cliOptions, chalk.green(`  Summary: ${fileResult.results.summary}`));
       }
       return;
     }
@@ -1194,13 +1181,6 @@ function outputText(reviewResults, cliOptions) {
       });
     }
 
-    if (review.positives && review.positives.length > 0) {
-      console.log(chalk.bold.green('\nPositives:'));
-      review.positives.forEach((positive) => {
-        console.log(`  - ${positive}`);
-      });
-      console.log('');
-    }
     console.log(chalk.gray(`========================================${'='.repeat(fileResult.filePath.length)}`));
   });
 }
@@ -1294,6 +1274,7 @@ async function analyzePRHistory(options) {
       resume: options.resume,
       clearExisting: options.clear,
       projectPath,
+      verbose: options.verbose,
       onProgress: (progress) => displayProgress(progress, options.verbose),
     };
 
@@ -1312,9 +1293,7 @@ async function analyzePRHistory(options) {
     const endTime = Date.now();
     const duration = ((endTime - startTime) / 1000).toFixed(2);
     console.error(chalk.red(`\nError during PR history analysis (${duration}s):`), error.message);
-    if (options.verbose) {
-      console.error(error.stack);
-    }
+    verboseLog(options, error.stack);
     process.exit(1);
   }
 }
@@ -1413,9 +1392,7 @@ async function clearPRHistory(options) {
     }
   } catch (error) {
     console.error(chalk.red('Error clearing PR history data:'), error.message);
-    if (options.verbose) {
-      console.error(error.stack);
-    }
+    verboseLog(options, error.stack);
     process.exit(1);
   }
 }

package/src/llm.js

@@ -15,6 +15,7 @@
 import { Anthropic } from '@anthropic-ai/sdk';
 import chalk from 'chalk';
 import dotenv from 'dotenv';
+import { verboseLog } from './utils/logging.js';
 
 // Load env variables if present; do not enforce key at import time
 dotenv.config();
@@ -56,7 +57,7 @@ async function sendPromptToClaude(prompt, options = {}) {
   const { model = DEFAULT_MODEL, maxTokens = MAX_TOKENS, temperature = 0.7, system = '', jsonSchema = null, cacheTtl = '5m' } = options;
 
   try {
-    console.log(chalk.cyan('Sending prompt to Claude...'));
+    verboseLog(options, chalk.cyan('Sending prompt to Claude...'));
 
     const client = getAnthropicClient();
 
@@ -104,8 +105,8 @@ async function sendPromptToClaude(prompt, options = {}) {
     const response = await client.messages.create(requestParams);
 
     // Log response structure for debugging
-    console.log(chalk.gray(`  Response stop_reason: ${response.stop_reason}`));
-    console.log(chalk.gray(`  Response content blocks: ${response.content?.length || 0}`));
+    verboseLog(options, chalk.gray(`  Response stop_reason: ${response.stop_reason}`));
+    verboseLog(options, chalk.gray(`  Response content blocks: ${response.content?.length || 0}`));
 
     // Process response based on whether we used tool calling
     if (jsonSchema) {