codecritique 1.2.3 → 2.0.0

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/codecritique.svg)](https://www.npmjs.com/package/codecritique)
 [![npm downloads](https://img.shields.io/npm/dm/codecritique.svg)](https://www.npmjs.com/package/codecritique)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D22.14.0-brightgreen.svg)](https://nodejs.org/)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D24.15.0-brightgreen.svg)](https://nodejs.org/)
 [![CI](https://github.com/cosmocoder/CodeCritique/actions/workflows/release.yml/badge.svg)](https://github.com/cosmocoder/CodeCritique/actions/workflows/release.yml)
 
 **AI-Powered Code Review. Context-Aware. Privacy-First.**
@@ -96,7 +96,7 @@ This RAG-based approach provides more accurate, project-specific code reviews co
 
 ### Prerequisites
 
-- **Node.js** v22.14.0 or higher
+- **Node.js** v24.15.0 or higher
 - **Git** (for diff-based analysis)
 - **Anthropic API key** (for LLM analysis)
 
@@ -199,7 +199,7 @@ For easier integration with non-JavaScript projects, you can use the provided sh
 
 3. **Environment setup** (the script handles this automatically):
    - Creates/uses `.env` file in your project directory
-   - Validates Node.js v22.14.0+ requirement
+   - Validates Node.js v24.15.0+ requirement
    - Provides helpful error messages for missing dependencies
 
 ## Quick Start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "1.2.3",
+  "version": "2.0.0",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",
@@ -53,43 +53,45 @@
   "dependencies": {
     "@anthropic-ai/sdk": "0.71.0",
     "@huggingface/transformers": "3.8.0",
-    "@lancedb/lancedb": "0.22.3",
+    "@lancedb/lancedb": "0.30.0",
     "@octokit/rest": "22.0.1",
+    "apache-arrow": "18.1.0",
     "chalk": "5.6.2",
     "cli-spinner": "0.2.10",
     "commander": "14.0.1",
-    "dotenv": "17.2.3",
-    "fastembed": "2.0.0",
-    "glob": "13.0.0",
-    "linguist-languages": "9.1.0",
-    "lru-cache": "11.2.2",
-    "minimatch": "10.1.1",
+    "dotenv": "17.4.2",
+    "fastembed": "2.1.0",
+    "glob": "13.0.6",
+    "linguist-languages": "9.3.2",
+    "lru-cache": "11.5.1",
+    "minimatch": "10.2.5",
     "stopwords-iso": "1.1.0"
   },
   "devDependencies": {
     "@eslint/js": "9.39.1",
     "@semantic-release/commit-analyzer": "13.0.1",
-    "@semantic-release/github": "12.0.3",
-    "@semantic-release/npm": "13.1.3",
-    "@semantic-release/release-notes-generator": "14.1.0",
-    "@types/node": "24.9.1",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/eslint-plugin": "1.3.23",
+    "@semantic-release/github": "12.0.8",
+    "@semantic-release/npm": "13.1.5",
+    "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/node": "24.12.4",
+    "@vitest/coverage-v8": "4.1.8",
+    "@vitest/eslint-plugin": "1.6.19",
     "eslint": "9.39.1",
     "eslint-plugin-import": "2.32.0",
     "globals": "16.5.0",
     "knip": "5.70.2",
-    "prettier": "3.7.1",
+    "prettier": "3.8.3",
+    "prettier-plugin-brace-style": "0.10.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.16"
+    "vitest": "4.1.8"
   },
   "volta": {
-    "node": "22.14.0",
-    "npm": "10.9.2"
+    "node": "24.15.0",
+    "npm": "11.12.1"
   },
   "engines": {
-    "node": ">=22.14.0",
-    "npm": "10.x"
+    "node": ">=24.15.0",
+    "npm": ">=11.12.1 <12"
   },
   "engine-strict": true,
   "publishConfig": {

package/src/content-retrieval.js

@@ -23,7 +23,10 @@ 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 { getTableSchema, schemaHasField } from './utils/lancedb.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 +57,59 @@ 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
@@ -97,86 +153,35 @@ export class ContentRetriever {
 
       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, "''")}'`);
+        const tableSchema = await getTableSchema(table);
+        if (schemaHasField(tableSchema, 'project_path')) {
+          query = query.where(`project_path = '${escapeSqlString(resolvedProjectPath)}'`);
           debug(`Filtering documentation by project_path: ${resolvedProjectPath}`);
         }
-      } catch (schemaError) {
+      }
+      catch (schemaError) {
         debug(`Could not check schema for project_path field: ${schemaError.message}`);
       }
 
       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) => {
         let similarity;
         if (result._distance !== undefined) {
           similarity = Math.max(0, Math.min(1, 1 - result._distance));
-        } else if (result._score !== undefined) {
+        }
+        else if (result._score !== undefined) {
           similarity = Math.max(0, Math.min(1, result._score));
-        } else {
+        }
+        else {
           similarity = 0.5;
         }
 
@@ -286,7 +291,8 @@ export class ContentRetriever {
                     // Use pre-computed context for generic documents (README, RUNBOOK, etc.)
                     context = getGenericDocumentContext(originalPath, docH1);
                     debug(`[FAST-PATH] Using pre-computed context for generic document: ${originalPath}`);
-                  } else {
+                  }
+                  else {
                     // Use the expensive inference for non-generic documents
                     context = await inferContextFromDocumentContent(
                       originalPath,
@@ -297,7 +303,8 @@ export class ContentRetriever {
                   }
 
                   return context;
-                } catch (error) {
+                }
+                catch (error) {
                   debug(`[ERROR] Failed to get context for ${originalPath}: ${error.message}`);
                   // Return a fallback context to avoid breaking the pipeline
                   return {
@@ -367,7 +374,8 @@ export class ContentRetriever {
                   contextMatchBonus += MODERATE_BOOST_TECH_MATCH;
                 }
               }
-            } else if (queryContextForReranking.area !== 'GeneralJS_TS') {
+            }
+            else if (queryContextForReranking.area !== 'GeneralJS_TS') {
               contextMatchBonus += HEAVY_PENALTY_AREA_MISMATCH;
             }
           }
@@ -420,7 +428,8 @@ export class ContentRetriever {
       verboseLog(options, chalk.green(`Returning ${finalResults.length} documentation results`));
 
       return finalResults;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error in findRelevantDocs: ${error.message}`), error);
       throw new EmbeddingError(`Documentation search failed: ${error.message}`);
     }
@@ -477,7 +486,8 @@ export class ContentRetriever {
           // Only include test files
           conditions.push(`(path LIKE '%.test.%' OR path LIKE '%.spec.%' OR path LIKE '%_test.py' OR path LIKE 'test_%.py')`);
           verboseLog(options, chalk.blue(`Filtering to include only test files.`));
-        } else {
+        }
+        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')`
@@ -493,13 +503,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}'`);
         }
 
@@ -509,17 +519,14 @@ export class ContentRetriever {
       // Add project path filtering if the field exists in the schema
       // Check if the table has project_path field
       try {
-        const tableSchema = await table.schema;
-        if (tableSchema && tableSchema.fields) {
-          const hasProjectPathField = tableSchema.fields.some((field) => field.name === 'project_path');
-
-          if (hasProjectPathField) {
-            // Use exact match for project path
-            conditions.push(`project_path = '${resolvedProjectPath.replace(/'/g, "''")}'`);
-            debug(`Filtering by project_path: ${resolvedProjectPath}`);
-          }
+        const tableSchema = await getTableSchema(table);
+        if (schemaHasField(tableSchema, 'project_path')) {
+          // Use exact match for project path
+          conditions.push(`project_path = '${escapeSqlString(resolvedProjectPath)}'`);
+          debug(`Filtering by project_path: ${resolvedProjectPath}`);
         }
-      } catch (schemaError) {
+      }
+      catch (schemaError) {
         debug(`Could not check schema for project_path field: ${schemaError.message}`);
         // Continue without project_path filtering in query
       }
@@ -532,72 +539,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`));
 
@@ -609,10 +555,12 @@ export class ContentRetriever {
           // Vector search distance (0 = perfect match, higher = less similar)
           // Apply more precise normalization to avoid all scores being 1.000
           similarity = Math.max(0, Math.min(1, Math.exp(-result._distance * 2)));
-        } else if (result._score !== undefined) {
+        }
+        else if (result._score !== undefined) {
           // FTS or hybrid score - normalize to 0-1 range with better scaling
           similarity = Math.max(0, Math.min(1, result._score / Math.max(result._score, 1)));
-        } else {
+        }
+        else {
           // Fallback
           similarity = 0.5;
         }
@@ -643,14 +591,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];
@@ -676,7 +621,8 @@ export class ContentRetriever {
               }
             }
           }
-        } catch (error) {
+        }
+        catch (error) {
           console.warn(chalk.yellow(`Project structure inclusion failed: ${error.message}`));
         }
       }
@@ -689,7 +635,8 @@ export class ContentRetriever {
 
       verboseLog(options, chalk.green(`Returning ${finalResults.length} optimized hybrid search results`));
       return finalResults;
-    } catch (error) {
+    }
+    catch (error) {
       console.error(chalk.red(`Error in optimized findSimilarCode: ${error.message}`), error);
       return [];
     }
@@ -744,7 +691,8 @@ export class ContentRetriever {
       };
 
       verboseLog({}, chalk.green('ContentRetriever cleanup complete'));
-    } finally {
+    }
+    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({