codecritique 1.2.2 → 1.2.3

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) {
@@ -630,15 +629,14 @@ async function generateEmbeddings(options) {
       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 +754,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 +835,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 +860,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 +868,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 +973,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 +1007,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 +1030,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 +1141,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 +1182,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 +1275,7 @@ async function analyzePRHistory(options) {
       resume: options.resume,
       clearExisting: options.clear,
       projectPath,
+      verbose: options.verbose,
       onProgress: (progress) => displayProgress(progress, options.verbose),
     };
 
@@ -1312,9 +1294,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 +1393,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) {

package/src/project-analyzer.js

@@ -13,6 +13,7 @@ import { getDefaultEmbeddingsSystem } from './embeddings/factory.js';
 import * as llm from './llm.js';
 import { FILE_SELECTION_SYSTEM_PROMPT, PROJECT_SUMMARY_SYSTEM_PROMPT } from './prompt-cache.js';
 import { isDocumentationFile, isTestFile } from './utils/file-validation.js';
+import { verboseLog } from './utils/logging.js';
 
 // Consolidated file classification configuration
 const FILE_PATTERNS = {
@@ -198,9 +199,7 @@ export class ProjectAnalyzer {
     const { verbose = false, forceAnalysis = false } = options;
 
     try {
-      if (verbose) {
-        console.log(chalk.cyan('🔍 Starting project architecture analysis...'));
-      }
+      verboseLog(verbose, chalk.cyan('🔍 Starting project architecture analysis...'));
 
       // Initialize LLM client
       if (!this.llm) {
@@ -212,16 +211,13 @@ export class ProjectAnalyzer {
       if (existingSummary && !forceAnalysis) {
         const currentHash = await this.calculateKeyFilesHash(existingSummary.keyFiles);
         if (existingSummary.keyFilesHash === currentHash) {
-          if (verbose) {
-            console.log(chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
-          }
+          verboseLog(verbose, chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
           return existingSummary;
         }
-        if (verbose) {
-          console.log(chalk.yellow('🔄 Key files changed, regenerating analysis...'));
-        }
-      } else if (verbose) {
-        console.log(
+        verboseLog(verbose, chalk.yellow('🔄 Key files changed, regenerating analysis...'));
+      } else {
+        verboseLog(
+          verbose,
           chalk.cyan(
             forceAnalysis
               ? '🔄 Force analysis requested - regenerating from scratch...'
@@ -235,10 +231,8 @@ export class ProjectAnalyzer {
         ? await this.validateAndUpdateKeyFiles(existingSummary.keyFiles, projectPath)
         : await this.discoverKeyFilesWithLLM(projectPath);
 
-      if (verbose) {
-        console.log(chalk.gray(`   Found ${keyFiles.length} key architectural files`));
-        console.log(chalk.cyan('🧠 Generating LLM-based project analysis...'));
-      }
+      verboseLog(verbose, chalk.gray(`   Found ${keyFiles.length} key architectural files`));
+      verboseLog(verbose, chalk.cyan('🧠 Generating LLM-based project analysis...'));
 
       // Generate summary
       const projectSummary = await this.generateProjectSummary(keyFiles, projectPath);
@@ -254,12 +248,10 @@ export class ProjectAnalyzer {
       this.keyFiles = keyFiles;
       this.lastAnalysisHash = currentHash;
 
-      if (verbose) {
-        console.log(chalk.green('✅ Project analysis complete'));
-        console.log(chalk.gray(`   Technologies: ${(projectSummary.technologies || []).join(', ')}`));
-        console.log(chalk.gray(`   Key patterns: ${(projectSummary.keyPatterns || []).length} identified`));
-        console.log(chalk.gray(`   Key files tracked: ${keyFiles.length}`));
-      }
+      verboseLog(verbose, chalk.green('✅ Project analysis complete'));
+      verboseLog(verbose, chalk.gray(`   Technologies: ${(projectSummary.technologies || []).join(', ')}`));
+      verboseLog(verbose, chalk.gray(`   Key patterns: ${(projectSummary.keyPatterns || []).length} identified`));
+      verboseLog(verbose, chalk.gray(`   Key files tracked: ${keyFiles.length}`));
 
       return projectSummary;
     } catch (error) {
@@ -300,7 +292,7 @@ export class ProjectAnalyzer {
     try {
       const embeddingsSystem = getDefaultEmbeddingsSystem();
       await embeddingsSystem.storeProjectSummary(projectPath, projectSummary);
-      console.log(chalk.green('✅ Project analysis stored in database'));
+      verboseLog({}, chalk.green('✅ Project analysis stored in database'));
     } catch (error) {
       console.error(chalk.yellow('Warning: Could not store analysis:'), error.message);
     }
@@ -328,7 +320,7 @@ export class ProjectAnalyzer {
 
     // If we lost more than 30% of key files, trigger fresh discovery
     if (validatedFiles.length < existingKeyFiles.length * 0.7) {
-      console.log(chalk.yellow('⚠️ Many key files missing, performing fresh discovery...'));
+      verboseLog({}, chalk.yellow('⚠️ Many key files missing, performing fresh discovery...'));
       return await this.discoverKeyFilesWithLLM(projectPath);
     }
 
@@ -339,10 +331,10 @@ export class ProjectAnalyzer {
    * Discover key architectural files using LanceDB hybrid search
    */
   async discoverKeyFilesWithLLM(projectPath) {
-    console.log(chalk.cyan('🔍 Mining codebase embeddings with LanceDB hybrid search...'));
+    verboseLog({}, chalk.cyan('🔍 Mining codebase embeddings with LanceDB hybrid search...'));
 
     const keyFilesByCategory = await this.mineKeyFilesFromEmbeddings(projectPath);
-    console.log(chalk.cyan(`🧠 LLM analyzing ${keyFilesByCategory.length} candidates from embedding search...`));
+    verboseLog({}, chalk.cyan(`🧠 LLM analyzing ${keyFilesByCategory.length} candidates from embedding search...`));
 
     const keyFiles = await this.selectFinalKeyFiles(keyFilesByCategory, projectPath);
     return keyFiles;
@@ -362,7 +354,7 @@ export class ProjectAnalyzer {
       await table.optimize();
     } catch (optimizeError) {
       if (optimizeError.message && optimizeError.message.includes('legacy format')) {
-        console.log(chalk.yellow(`Skipping optimization due to legacy index format - will be auto-upgraded during normal operations`));
+        console.warn(chalk.yellow(`Skipping optimization due to legacy index format - will be auto-upgraded during normal operations`));
       } else {
         console.warn(chalk.yellow(`Warning: Failed to optimize file embeddings table: ${optimizeError.message}`));
       }
@@ -371,7 +363,7 @@ export class ProjectAnalyzer {
     const keyFiles = new Map();
 
     try {
-      console.log(chalk.gray(`   📊 Using LanceDB hybrid search for project: ${projectPath}`));
+      verboseLog({}, chalk.gray(`   📊 Using LanceDB hybrid search for project: ${projectPath}`));
 
       // Unified query function
       const queryFiles = async (config) => {
@@ -414,17 +406,17 @@ export class ProjectAnalyzer {
 
           return await query.limit(config.limit || 30).toArray();
         } catch (error) {
-          console.log(chalk.yellow(`     ⚠️ Query failed for ${config.category}: ${error.message}`));
+          verboseLog({}, chalk.yellow(`     ⚠️ Query failed for ${config.category}: ${error.message}`));
           return [];
         }
       };
 
       // Execute all searches
       for (const config of DB_SEARCH_CONFIGS) {
-        console.log(chalk.gray(`   🔍 Searching for ${config.category} files...`));
+        verboseLog({}, chalk.gray(`   🔍 Searching for ${config.category} files...`));
 
         const results = await queryFiles(config);
-        console.log(chalk.gray(`   📦 Found ${results.length} ${config.category} file candidates`));
+        verboseLog({}, chalk.gray(`   📦 Found ${results.length} ${config.category} file candidates`));
 
         results.forEach((result) => {
           if (this.matchesFileType(result.path, result.name, config.matcher)) {
@@ -438,7 +430,7 @@ export class ProjectAnalyzer {
     }
 
     const results = Array.from(keyFiles.values());
-    console.log(chalk.cyan(`🗃️ Found ${results.length} key files from embeddings database`));
+    verboseLog({}, chalk.cyan(`🗃️ Found ${results.length} key files from embeddings database`));
     return results;
   }
 
@@ -475,11 +467,11 @@ export class ProjectAnalyzer {
    */
   async selectFinalKeyFiles(candidates, projectPath) {
     if (candidates.length === 0) {
-      console.log(chalk.yellow('⚠️ No candidates found from embeddings search'));
+      verboseLog({}, chalk.yellow('⚠️ No candidates found from embeddings search'));
       return [];
     }
 
-    console.log(chalk.cyan(`🤖 LLM analyzing ${candidates.length} candidates...`));
+    verboseLog({}, chalk.cyan(`🤖 LLM analyzing ${candidates.length} candidates...`));
 
     const candidatesSummary = candidates
       .map((file, index) => {
@@ -520,7 +512,7 @@ Select files following the criteria in the system instructions.`;
         jsonSchema: fileSelectionSchema,
       });
 
-      console.log(chalk.gray('   📄 LLM Response preview:'), response.content.substring(0, 200));
+      verboseLog({}, chalk.gray('   📄 LLM Response preview:'), response.content.substring(0, 200));
 
       const selectedPaths = response.json.selectedFiles;
 
@@ -546,14 +538,14 @@ Select files following the criteria in the system instructions.`;
           })
           .filter(Boolean);
 
-        console.log(chalk.cyan(`🎯 LLM selected ${keyFiles.length} final key files`));
+        verboseLog({}, chalk.cyan(`🎯 LLM selected ${keyFiles.length} final key files`));
         return keyFiles;
       } else {
         throw new Error(`Failed to extract valid JSON array from LLM response`);
       }
     } catch (error) {
       console.error(chalk.red('Error in LLM selection:'), error.message);
-      console.log(chalk.yellow('   🔄 Falling back to automatic selection...'));
+      verboseLog({}, chalk.yellow('   🔄 Falling back to automatic selection...'));
       return this.fallbackFileSelection(candidates, projectPath);
     }
   }
@@ -588,7 +580,7 @@ Select files following the criteria in the system instructions.`;
       }
     }
 
-    console.log(chalk.yellow(`⚠️ Used fallback selection: ${fallbackFiles.length} files`));
+    verboseLog({}, chalk.yellow(`⚠️ Used fallback selection: ${fallbackFiles.length} files`));
     return fallbackFiles;
   }
 
@@ -793,7 +785,7 @@ Follow the analysis guidelines from the system instructions to identify custom i
     } catch (error) {
       console.error(chalk.red('Error generating project summary:'), error.message);
       const fallback = this.createFallbackSummary(projectPath, keyFiles);
-      console.log(chalk.yellow('Using fallback summary with technologies:'), fallback.technologies);
+      verboseLog({}, chalk.yellow('Using fallback summary with technologies:'), fallback.technologies);
       return fallback;
     }
   }
@@ -857,7 +849,8 @@ Follow the analysis guidelines from the system instructions to identify custom i
       };
     }
 
-    console.log(
+    verboseLog(
+      {},
       chalk.cyan(
         `✅ Project summary validated - Technologies: ${validatedSummary.technologies.length}, Frameworks: ${validatedSummary.mainFrameworks.length}`
       )

package/src/project-analyzer.test.js

@@ -272,7 +272,6 @@ describe('ProjectAnalyzer', () => {
       await analyzer.storeAnalysis(mockProjectPath, summary);
 
       expect(mockEmbeddingsSystem.storeProjectSummary).toHaveBeenCalledWith(mockProjectPath, summary);
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Project analysis stored'));
     });
 
     it('should handle storage errors gracefully', async () => {
@@ -319,7 +318,7 @@ describe('ProjectAnalyzer', () => {
       await analyzer.validateAndUpdateKeyFiles(existingFiles, mockProjectPath);
 
       // With 1 of 3 files found (33%), it should trigger fresh discovery
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Many key files missing'));
+      expect(mockEmbeddingsSystem.initialize).toHaveBeenCalled();
     });
 
     it('should filter out missing files and keep existing ones', async () => {
@@ -366,7 +365,7 @@ describe('ProjectAnalyzer', () => {
       await analyzer.validateAndUpdateKeyFiles(existingFiles, mockProjectPath);
 
       // Should trigger discoverKeyFilesWithLLM
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Many key files missing'));
+      expect(mockEmbeddingsSystem.initialize).toHaveBeenCalled();
     });
   });
 
@@ -410,7 +409,7 @@ describe('ProjectAnalyzer', () => {
       const result = await analyzer.mineKeyFilesFromEmbeddings(mockProjectPath);
 
       expect(result).toEqual([]);
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Skipping optimization'));
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('legacy index format'));
     });
 
     it('should return empty array on query error', async () => {
@@ -496,7 +495,6 @@ describe('ProjectAnalyzer', () => {
       await analyzer.selectFinalKeyFiles(candidates, mockProjectPath);
 
       expect(console.error).toHaveBeenCalled();
-      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Falling back to automatic selection'));
     });
 
     it('should fallback if LLM returns invalid response', async () => {