codecritique 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",

package/src/content-retrieval.js

@@ -23,7 +23,7 @@ import { calculateCosineSimilarity, calculatePathSimilarity } from './embeddings
 import { inferContextFromDocumentContent } from './utils/context-inference.js';
 import { isGenericDocument, getGenericDocumentContext } from './utils/document-detection.js';
 import { isDocumentationFile } from './utils/file-validation.js';
-import { debug } from './utils/logging.js';
+import { debug, verboseLog } from './utils/logging.js';
 
 const FILE_EMBEDDINGS_TABLE = TABLE_NAMES.FILE_EMBEDDINGS;
 const DOCUMENT_CHUNK_TABLE = TABLE_NAMES.DOCUMENT_CHUNK;
@@ -79,7 +79,8 @@ export class ContentRetriever {
         return [];
       }
 
-      console.log(
+      verboseLog(
+        options,
         chalk.cyan(`Native hybrid documentation search - limit: ${limit}, threshold: ${similarityThreshold}, reranking: ${useReranking}`)
       );
 
@@ -91,7 +92,7 @@ export class ContentRetriever {
         return [];
       }
 
-      console.log(chalk.cyan('Performing native hybrid search for documentation...'));
+      verboseLog(options, chalk.cyan('Performing native hybrid search for documentation...'));
       let query = table.search(queryText).nearestToText(queryText);
 
       const resolvedProjectPath = path.resolve(projectPath);
@@ -106,7 +107,7 @@ export class ContentRetriever {
       }
 
       const results = await query.limit(Math.max(limit * 3, 20)).toArray();
-      console.log(chalk.green(`Native hybrid search returned ${results.length} documentation results`));
+      verboseLog(options, chalk.green(`Native hybrid search returned ${results.length} documentation results`));
 
       // OPTIMIZATION: Enhanced batch file existence checks with parallel processing
       const docsToCheck = [];
@@ -168,7 +169,7 @@ export class ContentRetriever {
       // Filter results based on project match using the map
       const projectFilteredResults = results.filter((result, index) => docProjectMatchMap.get(index) === true);
 
-      console.log(chalk.blue(`Filtered to ${projectFilteredResults.length} documentation results from current project`));
+      verboseLog(options, chalk.blue(`Filtered to ${projectFilteredResults.length} documentation results from current project`));
       let finalResults = projectFilteredResults.map((result) => {
         let similarity;
         if (result._distance !== undefined) {
@@ -197,7 +198,7 @@ export class ContentRetriever {
 
       let queryEmbedding = null;
       if (useReranking && queryContextForReranking && finalResults.length >= 3) {
-        console.log(chalk.cyan('Applying sophisticated contextual reranking to documentation...'));
+        verboseLog(options, chalk.cyan('Applying sophisticated contextual reranking to documentation...'));
         const WEIGHT_INITIAL_SIM = 0.3;
         const WEIGHT_H1_CHUNK_RERANK = 0.15;
         const HEAVY_BOOST_SAME_AREA = 0.4;
@@ -416,7 +417,7 @@ export class ContentRetriever {
         finalResults = finalResults.slice(0, limit);
       }
 
-      console.log(chalk.green(`Returning ${finalResults.length} documentation results`));
+      verboseLog(options, chalk.green(`Returning ${finalResults.length} documentation results`));
 
       return finalResults;
     } catch (error) {
@@ -443,7 +444,10 @@ export class ContentRetriever {
       precomputedQueryEmbedding = null,
     } = options;
 
-    console.log(chalk.cyan(`Native hybrid code search - limit: ${limit}, threshold: ${similarityThreshold}, isTestFile: ${isTestFile}`));
+    verboseLog(
+      options,
+      chalk.cyan(`Native hybrid code search - limit: ${limit}, threshold: ${similarityThreshold}, isTestFile: ${isTestFile}`)
+    );
 
     try {
       if (!queryText?.trim()) {
@@ -460,7 +464,7 @@ export class ContentRetriever {
       }
 
       // Native hybrid search with automatic vector + FTS + RRF
-      console.log(chalk.cyan('Performing native hybrid search for code...'));
+      verboseLog(options, chalk.cyan('Performing native hybrid search for code...'));
       let query = table.search(queryText).nearestToText(queryText);
 
       // Add filtering conditions
@@ -472,13 +476,13 @@ export class ContentRetriever {
         if (isTestFile) {
           // Only include test files
           conditions.push(`(path LIKE '%.test.%' OR path LIKE '%.spec.%' OR path LIKE '%_test.py' OR path LIKE 'test_%.py')`);
-          console.log(chalk.blue(`Filtering to include only test files.`));
+          verboseLog(options, chalk.blue(`Filtering to include only test files.`));
         } else {
           // Exclude test files
           conditions.push(
             `(path NOT LIKE '%.test.%' AND path NOT LIKE '%.spec.%' AND path NOT LIKE '%_test.py' AND path NOT LIKE 'test_%.py')`
           );
-          console.log(chalk.blue(`Filtering to exclude test files.`));
+          verboseLog(options, chalk.blue(`Filtering to exclude test files.`));
         }
       }
 
@@ -526,7 +530,7 @@ export class ContentRetriever {
 
       const results = await query.limit(Math.max(limit * 3, 20)).toArray();
 
-      console.log(chalk.green(`Native hybrid search returned ${results.length} results`));
+      verboseLog(options, chalk.green(`Native hybrid search returned ${results.length} results`));
 
       // OPTIMIZATION: Batch file existence checks for better performance
       const resultsToCheck = [];
@@ -595,7 +599,7 @@ export class ContentRetriever {
       // Filter results based on project match using the map
       const projectFilteredResults = results.filter((result, index) => projectMatchMap.get(index) === true);
 
-      console.log(chalk.blue(`Filtered to ${projectFilteredResults.length} results from current project`));
+      verboseLog(options, chalk.blue(`Filtered to ${projectFilteredResults.length} results from current project`));
 
       // Map results to expected format
       let finalResults = projectFilteredResults.map((result) => {
@@ -683,7 +687,7 @@ export class ContentRetriever {
         finalResults = finalResults.slice(0, limit);
       }
 
-      console.log(chalk.green(`Returning ${finalResults.length} optimized hybrid search results`));
+      verboseLog(options, chalk.green(`Returning ${finalResults.length} optimized hybrid search results`));
       return finalResults;
     } catch (error) {
       console.error(chalk.red(`Error in optimized findSimilarCode: ${error.message}`), error);
@@ -712,7 +716,7 @@ export class ContentRetriever {
     this.h1EmbeddingCache.clear();
     this.documentContextCache.clear();
     this.documentContextPromiseCache.clear();
-    console.log(chalk.green('ContentRetriever caches cleared'));
+    verboseLog({}, chalk.green('ContentRetriever caches cleared'));
   }
 
   /**
@@ -739,7 +743,7 @@ export class ContentRetriever {
         parallelRerankingTime: 0,
       };
 
-      console.log(chalk.green('ContentRetriever cleanup complete'));
+      verboseLog({}, chalk.green('ContentRetriever cleanup complete'));
     } finally {
       this.cleaningUp = false;
     }

package/src/custom-documents.js

@@ -18,7 +18,7 @@ import { CacheManager } from './embeddings/cache-manager.js';
 import { EmbeddingError, ValidationError } from './embeddings/errors.js';
 import { ModelManager } from './embeddings/model-manager.js';
 import { calculateCosineSimilarity, calculatePathSimilarity } from './embeddings/similarity-calculator.js';
-import { debug } from './utils/logging.js';
+import { debug, verboseLog } from './utils/logging.js';
 import { slugify } from './utils/string-utils.js';
 
 /**
@@ -140,7 +140,7 @@ export class CustomDocumentProcessor {
       this.performanceMetrics.averageChunkSize = chunks.reduce((sum, chunk) => sum + chunk.content.length, 0) / chunks.length;
       this.performanceMetrics.processingTime += Date.now() - startTime;
 
-      console.log(chalk.gray(`  Chunked document "${documentTitle}" into ${chunks.length} chunks`));
+      verboseLog({}, chalk.gray(`  Chunked document "${documentTitle}" into ${chunks.length} chunks`));
       return chunks;
     } catch (error) {
       console.error(chalk.red(`Error chunking document: ${error.message}`));
@@ -159,18 +159,18 @@ export class CustomDocumentProcessor {
 
     try {
       if (!customDocs || customDocs.length === 0) {
-        console.log(chalk.gray('No custom documents to process'));
+        verboseLog({}, chalk.gray('No custom documents to process'));
         return [];
       }
 
-      console.log(chalk.cyan(`Processing ${customDocs.length} custom documents into chunks...`));
+      verboseLog({}, chalk.cyan(`Processing ${customDocs.length} custom documents into chunks...`));
 
       const allChunks = [];
       let totalBatchAttempts = 0;
       let successfulBatches = 0;
 
       for (const doc of customDocs) {
-        console.log(chalk.gray(`  Processing document: ${doc.title}`));
+        verboseLog({}, chalk.gray(`  Processing document: ${doc.title}`));
 
         // Chunk the document
         const chunks = this.chunkDocument(doc);
@@ -205,12 +205,12 @@ export class CustomDocumentProcessor {
           const validChunks = chunksWithEmbeddings.filter((chunk) => chunk !== null);
           allChunks.push(...validChunks);
 
-          console.log(chalk.gray(`    Generated embeddings for ${validChunks.length}/${chunks.length} chunks`));
+          verboseLog({}, chalk.gray(`    Generated embeddings for ${validChunks.length}/${chunks.length} chunks`));
           this.performanceMetrics.embeddingsCalculated += validChunks.length;
         } catch (error) {
           console.error(chalk.red(`Error in batch embedding generation for document ${doc.title}: ${error.message}`));
           // Fallback to individual processing for this document
-          console.log(chalk.yellow(`    Falling back to individual processing for ${doc.title}`));
+          verboseLog({}, chalk.yellow(`    Falling back to individual processing for ${doc.title}`));
 
           const chunksWithEmbeddings = await Promise.all(
             chunks.map(async (chunk) => {
@@ -235,7 +235,7 @@ export class CustomDocumentProcessor {
           const validChunks = chunksWithEmbeddings.filter((chunk) => chunk !== null);
           allChunks.push(...validChunks);
 
-          console.log(chalk.gray(`    Generated embeddings for ${validChunks.length}/${chunks.length} chunks (fallback)`));
+          verboseLog({}, chalk.gray(`    Generated embeddings for ${validChunks.length}/${chunks.length} chunks (fallback)`));
         }
       }
 
@@ -252,7 +252,7 @@ export class CustomDocumentProcessor {
       this.performanceMetrics.documentsProcessed += customDocs.length;
       this.performanceMetrics.processingTime += Date.now() - startTime;
 
-      console.log(chalk.green(`Successfully processed ${allChunks.length} custom document chunks (${Date.now() - startTime}ms)`));
+      verboseLog({}, chalk.green(`Successfully processed ${allChunks.length} custom document chunks (${Date.now() - startTime}ms)`));
       return allChunks;
     } catch (error) {
       console.error(chalk.red(`Error processing custom documents: ${error.message}`));
@@ -285,11 +285,11 @@ export class CustomDocumentProcessor {
       }
 
       if (!chunks || chunks.length === 0) {
-        console.log(chalk.gray('No custom document chunks available for search'));
+        verboseLog({}, chalk.gray('No custom document chunks available for search'));
         return [];
       }
 
-      console.log(chalk.cyan(`Searching ${chunks.length} custom document chunks...`));
+      verboseLog({}, chalk.cyan(`Searching ${chunks.length} custom document chunks...`));
 
       // OPTIMIZATION: Use pre-computed query embedding if available
       let queryEmbedding = precomputedQueryEmbedding;
@@ -319,7 +319,7 @@ export class CustomDocumentProcessor {
         filteredResults = filteredResults.slice(0, limit);
       }
 
-      console.log(chalk.green(`Found ${filteredResults.length} relevant custom document chunks (${Date.now() - startTime}ms)`));
+      verboseLog({}, chalk.green(`Found ${filteredResults.length} relevant custom document chunks (${Date.now() - startTime}ms)`));
 
       // Log top results for debugging
       if (filteredResults.length > 0) {
@@ -350,7 +350,7 @@ export class CustomDocumentProcessor {
       }
 
       // Try cache manager
-      const cachedChunks = await this.cacheManager.getCustomDocuments(resolvedProjectPath);
+      const cachedChunks = this.cacheManager.getCustomDocumentChunks(resolvedProjectPath);
       if (cachedChunks && cachedChunks.length > 0) {
         // Restore to memory
         this.customDocumentChunks.set(resolvedProjectPath, cachedChunks);
@@ -371,7 +371,7 @@ export class CustomDocumentProcessor {
    * @private
    */
   async _applyParallelReranking(filteredResults, queryText, queryContextForReranking, queryFilePath, queryEmbedding) {
-    console.log(chalk.cyan('Applying optimized parallel contextual reranking to custom document chunks...'));
+    verboseLog({}, chalk.cyan('Applying optimized parallel contextual reranking to custom document chunks...'));
 
     const WEIGHT_INITIAL_SIM = 0.4;
     const WEIGHT_DOCUMENT_TITLE_MATCH = 0.2;
@@ -466,7 +466,7 @@ export class CustomDocumentProcessor {
     // Wait for all reranking calculations to complete in parallel
     await Promise.all(rerankingPromises);
 
-    console.log(chalk.cyan(`Parallel reranking completed for ${filteredResults.length} chunks`));
+    verboseLog({}, chalk.cyan(`Parallel reranking completed for ${filteredResults.length} chunks`));
 
     // Log debug info for first few results
     for (let i = 0; i < Math.min(3, filteredResults.length); i++) {
@@ -520,8 +520,8 @@ export class CustomDocumentProcessor {
     try {
       const resolvedProjectPath = path.resolve(projectPath);
       this.customDocumentChunks.delete(resolvedProjectPath);
-      await this.cacheManager.clearCustomDocuments(resolvedProjectPath);
-      console.log(chalk.green(`Cleared custom document chunks for project: ${resolvedProjectPath}`));
+      this.cacheManager.customDocumentChunks.delete(resolvedProjectPath);
+      verboseLog({}, chalk.green(`Cleared custom document chunks for project: ${resolvedProjectPath}`));
     } catch (error) {
       console.error(chalk.red(`Error clearing project chunks: ${error.message}`));
     }
@@ -561,7 +561,7 @@ export class CustomDocumentProcessor {
   clearCaches() {
     this.h1EmbeddingCache.clear();
     this.customDocumentChunks.clear();
-    console.log(chalk.green('CustomDocumentProcessor caches cleared'));
+    verboseLog({}, chalk.green('CustomDocumentProcessor caches cleared'));
   }
 
   /**
@@ -589,7 +589,7 @@ export class CustomDocumentProcessor {
         processingTime: 0,
       };
 
-      console.log(chalk.green('CustomDocumentProcessor cleanup complete'));
+      verboseLog({}, chalk.green('CustomDocumentProcessor cleanup complete'));
     } finally {
       this.cleaningUp = false;
     }

package/src/custom-documents.test.js

@@ -11,8 +11,7 @@ vi.mock('./embeddings/model-manager.js', () => ({
 vi.mock('./embeddings/cache-manager.js', () => ({
   CacheManager: class {
     storeCustomDocuments = vi.fn().mockResolvedValue(undefined);
-    getCustomDocuments = vi.fn().mockResolvedValue([]);
-    clearCustomDocuments = vi.fn().mockResolvedValue(undefined);
+    getCustomDocumentChunks = vi.fn().mockReturnValue([]);
   },
 }));
 
@@ -32,8 +31,7 @@ describe('CustomDocumentProcessor', () => {
 
     mockCacheManager = {
       storeCustomDocuments: vi.fn().mockResolvedValue(undefined),
-      getCustomDocuments: vi.fn().mockResolvedValue([]),
-      clearCustomDocuments: vi.fn().mockResolvedValue(undefined),
+      getCustomDocumentChunks: vi.fn().mockReturnValue([]),
     };
 
     processor = new CustomDocumentProcessor({
@@ -319,7 +317,7 @@ describe('CustomDocumentProcessor', () => {
 
     it('should return chunks from cache if not in memory', async () => {
       const cachedChunks = [{ id: 'cached', content: 'from cache' }];
-      mockCacheManager.getCustomDocuments.mockResolvedValue(cachedChunks);
+      mockCacheManager.getCustomDocumentChunks.mockReturnValue(cachedChunks);
 
       const result = await processor.getExistingChunks('/project');
 
@@ -328,7 +326,7 @@ describe('CustomDocumentProcessor', () => {
 
     it('should restore cached chunks to memory', async () => {
       const cachedChunks = [{ id: 'cached', content: 'from cache' }];
-      mockCacheManager.getCustomDocuments.mockResolvedValue(cachedChunks);
+      mockCacheManager.getCustomDocumentChunks.mockReturnValue(cachedChunks);
 
       await processor.getExistingChunks('/project');
 
@@ -336,7 +334,7 @@ describe('CustomDocumentProcessor', () => {
     });
 
     it('should return empty array when no chunks exist', async () => {
-      mockCacheManager.getCustomDocuments.mockResolvedValue([]);
+      mockCacheManager.getCustomDocumentChunks.mockReturnValue([]);
 
       const result = await processor.getExistingChunks('/project');
 
@@ -353,10 +351,14 @@ describe('CustomDocumentProcessor', () => {
       expect(processor.customDocumentChunks.has('/project')).toBe(false);
     });
 
-    it('should clear chunks from cache', async () => {
+    it('should clear chunks for only the selected project', async () => {
+      processor.customDocumentChunks.set('/project', [{ id: 'chunk-a' }]);
+      processor.customDocumentChunks.set('/other', [{ id: 'chunk-b' }]);
+
       await processor.clearProjectChunks('/project');
 
-      expect(mockCacheManager.clearCustomDocuments).toHaveBeenCalled();
+      expect(processor.customDocumentChunks.has('/project')).toBe(false);
+      expect(processor.customDocumentChunks.has('/other')).toBe(true);
     });
   });
 

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;
 }