codecritique 1.2.2 → 1.2.4

package/package.json

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

package/src/content-retrieval.js

@@ -23,7 +23,9 @@ 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';
+import { isPathWithinProject } from './utils/path-utils.js';
+import { escapeSqlString } from './utils/string-utils.js';
 
 const FILE_EMBEDDINGS_TABLE = TABLE_NAMES.FILE_EMBEDDINGS;
 const DOCUMENT_CHUNK_TABLE = TABLE_NAMES.DOCUMENT_CHUNK;
@@ -54,6 +56,58 @@ export class ContentRetriever {
     this.cleaningUp = false;
   }
 
+  resolveProjectResultPath(filePath, resolvedProjectPath) {
+    if (!filePath) {
+      return null;
+    }
+
+    const absolutePath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(resolvedProjectPath, filePath);
+    return isPathWithinProject(absolutePath, resolvedProjectPath) ? absolutePath : null;
+  }
+
+  async filterResultsForProject(results, resolvedProjectPath, getPath) {
+    const resultsToCheck = [];
+    const projectMatchMap = new Map();
+
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const resultPath = getPath(result);
+
+      if (result.project_path && result.project_path !== resolvedProjectPath) {
+        projectMatchMap.set(i, false);
+        continue;
+      }
+
+      const absolutePath = this.resolveProjectResultPath(resultPath, resolvedProjectPath);
+      if (!absolutePath) {
+        projectMatchMap.set(i, false);
+        continue;
+      }
+
+      resultsToCheck.push({ index: i, absolutePath, resultPath });
+    }
+
+    if (resultsToCheck.length > 0) {
+      const existenceResults = await Promise.all(
+        resultsToCheck.map(async ({ index, absolutePath, resultPath }) => {
+          try {
+            await fs.promises.access(absolutePath, fs.constants.F_OK);
+            return { index, exists: true };
+          } catch {
+            debug(`Filtering out non-existent project file: ${resultPath}`);
+            return { index, exists: false };
+          }
+        })
+      );
+
+      for (const { index, exists } of existenceResults) {
+        projectMatchMap.set(index, exists);
+      }
+    }
+
+    return results.filter((result, index) => projectMatchMap.get(index) === true);
+  }
+
   /**
    * Find relevant documentation with sophisticated reranking
    * @param {string} queryText - The search query
@@ -79,7 +133,8 @@ export class ContentRetriever {
         return [];
       }
 
-      console.log(
+      verboseLog(
+        options,
         chalk.cyan(`Native hybrid documentation search - limit: ${limit}, threshold: ${similarityThreshold}, reranking: ${useReranking}`)
       );
 
@@ -91,14 +146,14 @@ 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);
       try {
         const tableSchema = await table.schema;
         if (tableSchema?.fields?.some((field) => field.name === 'project_path')) {
-          query = query.where(`project_path = '${resolvedProjectPath.replace(/'/g, "''")}'`);
+          query = query.where(`project_path = '${escapeSqlString(resolvedProjectPath)}'`);
           debug(`Filtering documentation by project_path: ${resolvedProjectPath}`);
         }
       } catch (schemaError) {
@@ -106,69 +161,15 @@ 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`));
-
-      // OPTIMIZATION: Enhanced batch file existence checks with parallel processing
-      const docsToCheck = [];
-      const docProjectMatchMap = new Map();
-
-      // First pass: collect files that need existence checking
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-
-        if (result.project_path) {
-          docProjectMatchMap.set(i, result.project_path === resolvedProjectPath);
-          continue;
-        }
-
-        if (!result.original_document_path) {
-          docProjectMatchMap.set(i, false);
-          continue;
-        }
-
-        const filePath = result.original_document_path;
-        try {
-          if (path.isAbsolute(filePath)) {
-            docProjectMatchMap.set(i, filePath.startsWith(resolvedProjectPath));
-            continue;
-          }
-
-          const absolutePath = path.resolve(resolvedProjectPath, filePath);
-          if (absolutePath.startsWith(resolvedProjectPath)) {
-            // Mark for batch existence check
-            docsToCheck.push({ result, index: i, absolutePath, filePath });
-          } else {
-            docProjectMatchMap.set(i, false);
-          }
-        } catch (error) {
-          debug(`Error filtering result for project: ${error.message}`);
-          docProjectMatchMap.set(i, false);
-        }
-      }
-
-      // Enhanced batch check file existence with improved error handling
-      if (docsToCheck.length > 0) {
-        debug(`[OPTIMIZATION] Batch checking existence of ${docsToCheck.length} documentation files`);
-        const existencePromises = docsToCheck.map(async ({ index, absolutePath, filePath }) => {
-          try {
-            await fs.promises.access(absolutePath, fs.constants.F_OK);
-            return { index, exists: true };
-          } catch {
-            debug(`Filtering out non-existent documentation file: ${filePath}`);
-            return { index, exists: false };
-          }
-        });
-
-        const existenceResults = await Promise.all(existencePromises);
-        for (const { index, exists } of existenceResults) {
-          docProjectMatchMap.set(index, exists);
-        }
-      }
+      verboseLog(options, chalk.green(`Native hybrid search returned ${results.length} documentation results`));
 
-      // Filter results based on project match using the map
-      const projectFilteredResults = results.filter((result, index) => docProjectMatchMap.get(index) === true);
+      const projectFilteredResults = await this.filterResultsForProject(
+        results,
+        resolvedProjectPath,
+        (result) => result.original_document_path
+      );
 
-      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.`));
         }
       }
 
@@ -489,13 +493,13 @@ export class ContentRetriever {
       if (queryFilePath) {
         const normalizedQueryPath = path.resolve(resolvedProjectPath, queryFilePath);
         // Add condition to exclude the file being reviewed
-        const escapedPath = normalizedQueryPath.replace(/'/g, "''");
+        const escapedPath = escapeSqlString(normalizedQueryPath);
         conditions.push(`path != '${escapedPath}'`);
 
         // Also check for relative path variants to be thorough
         const relativePath = path.relative(resolvedProjectPath, normalizedQueryPath);
         if (relativePath && !relativePath.startsWith('..')) {
-          const escapedRelativePath = relativePath.replace(/'/g, "''");
+          const escapedRelativePath = escapeSqlString(relativePath);
           conditions.push(`path != '${escapedRelativePath}'`);
         }
 
@@ -511,7 +515,7 @@ export class ContentRetriever {
 
           if (hasProjectPathField) {
             // Use exact match for project path
-            conditions.push(`project_path = '${resolvedProjectPath.replace(/'/g, "''")}'`);
+            conditions.push(`project_path = '${escapeSqlString(resolvedProjectPath)}'`);
             debug(`Filtering by project_path: ${resolvedProjectPath}`);
           }
         }
@@ -526,76 +530,15 @@ 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`));
-
-      // OPTIMIZATION: Batch file existence checks for better performance
-      const resultsToCheck = [];
-      const projectMatchMap = new Map();
-
-      // First pass: collect files that need existence checking
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-
-        // Use project_path field if available (new schema)
-        if (result.project_path) {
-          projectMatchMap.set(i, result.project_path === resolvedProjectPath);
-          continue;
-        }
-
-        // Fallback for old embeddings without project_path field
-        if (!result.path && !result.original_document_path) {
-          projectMatchMap.set(i, false);
-          continue;
-        }
-
-        const filePath = result.original_document_path || result.path;
-        try {
-          // Check if this result belongs to the current project
-          // First try as absolute path
-          if (path.isAbsolute(filePath)) {
-            projectMatchMap.set(i, filePath.startsWith(resolvedProjectPath));
-            continue;
-          }
-
-          // For relative paths, check if the file actually exists in the project
-          const absolutePath = path.resolve(resolvedProjectPath, filePath);
-
-          // Verify the path is within project bounds
-          if (absolutePath.startsWith(resolvedProjectPath)) {
-            // Mark for batch existence check
-            resultsToCheck.push({ result, index: i, absolutePath });
-          } else {
-            projectMatchMap.set(i, false);
-          }
-        } catch (error) {
-          debug(`Error filtering result for project: ${error.message}`);
-          projectMatchMap.set(i, false);
-        }
-      }
-
-      // Batch check file existence for better performance
-      if (resultsToCheck.length > 0) {
-        debug(`[OPTIMIZATION] Batch checking existence of ${resultsToCheck.length} files`);
-        const existencePromises = resultsToCheck.map(async ({ result, index, absolutePath }) => {
-          try {
-            await fs.promises.access(absolutePath, fs.constants.F_OK);
-            return { index, exists: true };
-          } catch {
-            debug(`Filtering out non-existent file: ${result.original_document_path || result.path}`);
-            return { index, exists: false };
-          }
-        });
-
-        const existenceResults = await Promise.all(existencePromises);
-        for (const { index, exists } of existenceResults) {
-          projectMatchMap.set(index, exists);
-        }
-      }
+      verboseLog(options, chalk.green(`Native hybrid search returned ${results.length} results`));
 
-      // Filter results based on project match using the map
-      const projectFilteredResults = results.filter((result, index) => projectMatchMap.get(index) === true);
+      const projectFilteredResults = await this.filterResultsForProject(
+        results,
+        resolvedProjectPath,
+        (result) => result.original_document_path || result.path
+      );
 
-      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) => {
@@ -639,14 +582,11 @@ export class ContentRetriever {
         try {
           const fileTable = await this.database.getTable(FILE_EMBEDDINGS_TABLE);
           if (fileTable) {
-            // Look for project-specific structure ID
-            const projectStructureId = `__project_structure__${path.basename(resolvedProjectPath)}`;
-            let structureResults = await fileTable.query().where(`id = '${projectStructureId}'`).limit(1).toArray();
-
-            // Fall back to generic project structure if project-specific one doesn't exist
-            if (structureResults.length === 0) {
-              structureResults = await fileTable.query().where("id = '__project_structure__'").limit(1).toArray();
-            }
+            const structureResults = await fileTable
+              .query()
+              .where(`project_path = '${escapeSqlString(resolvedProjectPath)}' AND type = 'directory-structure'`)
+              .limit(1)
+              .toArray();
 
             if (structureResults.length > 0) {
               const structureRecord = structureResults[0];
@@ -683,7 +623,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 +652,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 +679,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/content-retrieval.test.js

@@ -459,6 +459,14 @@ describe('ContentRetriever', () => {
       const results = await retriever.findRelevantDocs('query', { projectPath: '/project' });
       expect(results.length).toBe(0);
     });
+
+    it('should reject sibling project absolute paths for documentation', async () => {
+      mockTable.toArray.mockResolvedValue([
+        createMockDocResult({ project_path: null, original_document_path: '/project-old/docs/readme.md' }),
+      ]);
+      const results = await retriever.findRelevantDocs('query', { projectPath: '/project' });
+      expect(results).toHaveLength(0);
+    });
   });
 
   // ==========================================================================
@@ -498,6 +506,12 @@ describe('ContentRetriever', () => {
       expect(results.length).toBe(0);
     });
 
+    it('should reject sibling project absolute paths for code results', async () => {
+      mockTable.toArray.mockResolvedValue([createMockCodeResult({ project_path: null, path: '/project-old/src/file.js' })]);
+      const results = await retriever.findSimilarCode('query', { projectPath: '/project', similarityThreshold: 0 });
+      expect(results).toHaveLength(0);
+    });
+
     it('should handle schema check errors', async () => {
       mockTable.schema = null;
       mockTable.toArray.mockResolvedValue([createMockCodeResult()]);
@@ -511,20 +525,31 @@ describe('ContentRetriever', () => {
   // ==========================================================================
 
   describe('project structure inclusion', () => {
-    it('should fall back to generic project structure', async () => {
+    it('should include only project-scoped structure rows', async () => {
       mockTable.toArray.mockResolvedValue([createMockCodeResult()]);
-      mockTable.query.mockReturnValue({
+      const queryChain = {
         where: vi.fn().mockReturnThis(),
         limit: vi.fn().mockReturnThis(),
-        toArray: vi
-          .fn()
-          .mockResolvedValueOnce([])
-          .mockResolvedValueOnce([
-            { id: '__project_structure__', content: 'Generic structure', path: '.', vector: new Float32Array(384).fill(0.1) },
-          ]),
+        toArray: vi.fn().mockResolvedValue([
+          {
+            id: '__project_structure__#abc12345',
+            content: 'Project structure',
+            path: '.',
+            project_path: '/project',
+            type: 'directory-structure',
+            vector: new Float32Array(384).fill(0.1),
+          },
+        ]),
+      };
+      mockTable.query.mockReturnValue(queryChain);
+      const results = await retriever.findSimilarCode('query', {
+        includeProjectStructure: true,
+        similarityThreshold: 0,
+        projectPath: '/project',
       });
-      const results = await retriever.findSimilarCode('query', { includeProjectStructure: true, similarityThreshold: 0 });
       expect(results.some((r) => r.type === 'project-structure')).toBe(true);
+      expect(queryChain.where).toHaveBeenCalledWith(expect.stringContaining("type = 'directory-structure'"));
+      expect(queryChain.where).toHaveBeenCalledWith(expect.stringContaining("project_path = '/project'"));
     });
 
     it('should handle project structure inclusion errors', async () => {
@@ -539,6 +564,21 @@ describe('ContentRetriever', () => {
       expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Project structure inclusion failed'));
     });
 
+    it('should skip project structure rows from another project', async () => {
+      mockTable.toArray.mockResolvedValue([createMockCodeResult()]);
+      mockTable.query.mockReturnValue({
+        where: vi.fn().mockReturnThis(),
+        limit: vi.fn().mockReturnThis(),
+        toArray: vi.fn().mockResolvedValue([]),
+      });
+      const results = await retriever.findSimilarCode('query', {
+        includeProjectStructure: true,
+        similarityThreshold: 0,
+        projectPath: '/project',
+      });
+      expect(results.some((r) => r.type === 'project-structure')).toBe(false);
+    });
+
     it('should skip structure when similarity is too low', async () => {
       mockTable.toArray.mockResolvedValue([createMockCodeResult()]);
       mockTable.query.mockReturnValue({

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) {
@@ -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++) {
@@ -521,7 +521,7 @@ export class CustomDocumentProcessor {
       const resolvedProjectPath = path.resolve(projectPath);
       this.customDocumentChunks.delete(resolvedProjectPath);
       this.cacheManager.customDocumentChunks.delete(resolvedProjectPath);
-      console.log(chalk.green(`Cleared custom document chunks for project: ${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;
     }