codecritique 1.2.3 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "1.2.3",
+  "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

@@ -24,6 +24,8 @@ import { inferContextFromDocumentContent } from './utils/context-inference.js';
 import { isGenericDocument, getGenericDocumentContext } from './utils/document-detection.js';
 import { isDocumentationFile } from './utils/file-validation.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
@@ -99,7 +153,7 @@ export class ContentRetriever {
       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) {
@@ -109,65 +163,11 @@ export class ContentRetriever {
       const results = await query.limit(Math.max(limit * 3, 20)).toArray();
       verboseLog(options, 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);
-        }
-      }
-
-      // 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
+      );
 
       verboseLog(options, chalk.blue(`Filtered to ${projectFilteredResults.length} documentation results from current project`));
       let finalResults = projectFilteredResults.map((result) => {
@@ -493,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}'`);
         }
 
@@ -515,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}`);
           }
         }
@@ -532,72 +532,11 @@ export class ContentRetriever {
 
       verboseLog(options, 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);
-        }
-      }
-
-      // 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
+      );
 
       verboseLog(options, chalk.blue(`Filtered to ${projectFilteredResults.length} results from current project`));
 
@@ -643,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];

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/index.js

@@ -519,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...'));
@@ -585,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') {
@@ -625,9 +627,6 @@ async function generateEmbeddings(options) {
         forceAnalysis: options.forceAnalysis,
       });
 
-      // Store project summary in embeddings system for later use
-      await embeddingsSystem.storeProjectSummary(projectDir, projectSummary);
-
       console.log(chalk.green('✅ Project analysis complete and stored'));
       verboseLog(options, chalk.gray(`   Project: ${projectSummary.projectName}`));
       verboseLog(

package/src/project-analyzer.js

@@ -209,12 +209,17 @@ export class ProjectAnalyzer {
       // Check for existing analysis
       const existingSummary = forceAnalysis ? null : await this.loadExistingAnalysis(projectPath);
       if (existingSummary && !forceAnalysis) {
-        const currentHash = await this.calculateKeyFilesHash(existingSummary.keyFiles);
-        if (existingSummary.keyFilesHash === currentHash) {
-          verboseLog(verbose, chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
-          return existingSummary;
+        const currentEmbeddingInventoryHash = await this.calculateEmbeddingInventoryHash(projectPath);
+        if (existingSummary.embeddingInventoryHash !== currentEmbeddingInventoryHash) {
+          verboseLog(verbose, chalk.yellow('🔄 Embedding inventory changed, regenerating analysis...'));
+        } else {
+          const currentHash = await this.calculateKeyFilesHash(existingSummary.keyFiles);
+          if (existingSummary.keyFilesHash === currentHash) {
+            verboseLog(verbose, chalk.green('✅ Project analysis up-to-date (no key file changes detected)'));
+            return existingSummary;
+          }
+          verboseLog(verbose, chalk.yellow('🔄 Key files changed, regenerating analysis...'));
         }
-        verboseLog(verbose, chalk.yellow('🔄 Key files changed, regenerating analysis...'));
       } else {
         verboseLog(
           verbose,
@@ -241,6 +246,7 @@ export class ProjectAnalyzer {
       const currentHash = await this.calculateKeyFilesHash(keyFiles);
       projectSummary.keyFiles = keyFiles;
       projectSummary.keyFilesHash = currentHash;
+      projectSummary.embeddingInventoryHash = await this.calculateEmbeddingInventoryHash(projectPath);
 
       await this.storeAnalysis(projectPath, projectSummary);
 
@@ -613,6 +619,39 @@ Select files following the criteria in the system instructions.`;
     return hash.digest('hex');
   }
 
+  /**
+   * Calculate a project-scoped hash of the current embedding inventory.
+   */
+  async calculateEmbeddingInventoryHash(projectPath) {
+    try {
+      const embeddingsSystem = getDefaultEmbeddingsSystem();
+      await embeddingsSystem.initialize();
+      const table = await embeddingsSystem.databaseManager.getTable(embeddingsSystem.databaseManager.fileEmbeddingsTable);
+
+      if (!table) {
+        return 'no-file-embeddings-table';
+      }
+
+      const records = await table
+        .query()
+        .select(['type', 'path', 'content_hash', 'project_path'])
+        .where(`project_path = '${projectPath.replace(/'/g, "''")}'`)
+        .toArray();
+
+      const hash = crypto.createHash('sha256');
+      const normalizedRows = records.map((record) => `${record.type || 'file'}:${record.path || ''}:${record.content_hash || ''}`).sort();
+
+      for (const row of normalizedRows) {
+        hash.update(row);
+      }
+
+      return hash.digest('hex');
+    } catch (error) {
+      verboseLog({}, chalk.yellow(`Warning: Could not calculate embedding inventory hash: ${error.message}`));
+      return 'embedding-inventory-unavailable';
+    }
+  }
+
   /**
    * Generate comprehensive project summary using LLM analysis (SINGLE CALL)
    */

package/src/rag-analyzer.test.js

@@ -910,6 +910,15 @@ describe('rag-analyzer', () => {
       expect(context).toHaveProperty('codeExamples');
     });
 
+    it('should degrade gracefully when retrieval returns no context for active files', async () => {
+      mockEmbeddingsSystem.findSimilarCode.mockResolvedValue([]);
+      mockEmbeddingsSystem.findRelevantDocs.mockResolvedValue([]);
+      const prFiles = [{ filePath: '/src/file.js', content: 'code', language: 'javascript' }];
+      const context = await gatherUnifiedContextForPR(prFiles, { projectPath: '/project' });
+      expect(context.codeExamples).toEqual([]);
+      expect(context.guidelines).toEqual([]);
+    });
+
     it('should find custom document chunks', async () => {
       mockEmbeddingsSystem.getExistingCustomDocumentChunks.mockResolvedValue([{ content: 'Custom doc', document_title: 'Guidelines' }]);
       const prFiles = [{ filePath: '/src/file.js', content: 'code', language: 'javascript' }];