codecritique 2.3.0 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",
@@ -63,7 +63,7 @@
     "fastembed": "2.1.0",
     "glob": "13.0.6",
     "linguist-languages": "9.5.0",
-    "lru-cache": "11.5.1",
+    "lru-cache": "11.5.2",
     "minimatch": "10.2.5",
     "stopwords-iso": "1.1.0"
   },
@@ -78,8 +78,8 @@
     "@vitest/eslint-plugin": "1.6.27",
     "eslint": "9.39.1",
     "eslint-plugin-import": "2.32.0",
-    "globals": "16.5.0",
-    "knip": "5.70.2",
+    "globals": "17.12.0",
+    "knip": "6.36.0",
     "prettier": "3.9.6",
     "prettier-plugin-brace-style": "0.10.3",
     "typescript": "5.9.3",

package/src/feedback-loader.js

@@ -111,7 +111,6 @@ export async function initializeSemanticSimilarity() {
   try {
     embeddingsSystem = getDefaultEmbeddingsSystem();
     await embeddingsSystem.initialize();
-    semanticSimilarityInitialized = true;
     semanticSimilarityAvailable = true;
     verboseLog({}, chalk.green('[FeedbackLoader] Semantic similarity initialized using embeddings system'));
   }
@@ -119,6 +118,11 @@ export async function initializeSemanticSimilarity() {
     console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity initialization failed: ${error.message}`));
     semanticSimilarityAvailable = false;
   }
+  finally {
+    // Records the attempt, not the outcome. Callers initialize lazily, so a failure
+    // that left this unset would reload the model once per issue.
+    semanticSimilarityInitialized = true;
+  }
 }
 
 /**
@@ -168,74 +172,84 @@ async function calculateSemanticSimilarity(text1, text2) {
 // ISSUE SIMILARITY CHECKING
 // ============================================================================
 
+/** Score above which an issue counts as a repeat of a dismissed one. */
+export const DEFAULT_SIMILARITY_THRESHOLD = 0.7;
+
+// A dismissal on the same line is evidence, not proof: a reworded repeat and a
+// different finding on the same topic score too close together to tell apart. The
+// lower bar catches the reworded repeat while a plainly unrelated finding still posts.
+const SAME_LOCATION_SIMILARITY_THRESHOLD = 0.65;
+
+// The word term is what separates a repost from a new finding: semantic scores
+// alone rank unrelated findings above the threshold.
+const SEMANTIC_WEIGHT = 0.7;
+const WORD_WEIGHT = 0.3;
+
 /**
- * Check if an issue should be skipped based on previous feedback
- * Uses semantic similarity when available, falls back to word-based similarity.
+ * Check if an issue should be skipped based on previous feedback.
+ * Compares against dismissed issues with the combined semantic and word-based score,
+ * initializing the embeddings system on first use.
  *
  * @param {string} issueDescription - Description of the current issue
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Filtering options
- * @param {number} [options.similarityThreshold=0.7] - Threshold for considering issues similar
+ * @param {number} [options.similarityThreshold=DEFAULT_SIMILARITY_THRESHOLD] - Threshold for considering issues similar
  * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @param {boolean} [options.useSemanticSimilarity=true] - Use semantic similarity when available
+ * @param {string|null} [options.filePath=null] - Path of the file the current issue is on
+ * @param {number|null} [options.lineNumber=null] - Line the current issue is on
  * @returns {Promise<boolean>} True if issue should be skipped
  */
 export async function shouldSkipSimilarIssue(issueDescription, feedbackData, options = {}) {
-  const { similarityThreshold = 0.7, verbose = false, useSemanticSimilarity = true } = options;
+  const {
+    similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD,
+    verbose = false,
+    useSemanticSimilarity = true,
+    filePath = null,
+    lineNumber = null,
+  } = options;
 
   if (!feedbackData || Object.keys(feedbackData).length === 0) {
     return false;
   }
 
-  // Check if similar issues were previously dismissed
+  // Dismissals worth comparing against: one without its own text can never match.
   const dismissedIssues = Object.values(feedbackData).filter(
     (feedback) =>
-      feedback?.overallSentiment === 'negative' ||
-      feedback?.userReplies?.some(
-        (reply) =>
-          reply.body.toLowerCase().includes('false positive') ||
-          reply.body.toLowerCase().includes('not relevant') ||
-          reply.body.toLowerCase().includes('ignore') ||
-          reply.body.toLowerCase().includes('resolved')
-      )
+      feedback?.originalIssue &&
+      (feedback?.overallSentiment === 'negative' ||
+        feedback?.userReplies?.some(
+          (reply) =>
+            reply.body.toLowerCase().includes('false positive') ||
+            reply.body.toLowerCase().includes('not relevant') ||
+            reply.body.toLowerCase().includes('ignore') ||
+            reply.body.toLowerCase().includes('resolved')
+        ))
   );
 
-  if (dismissedIssues.length === 0) {
+  if (!issueDescription || dismissedIssues.length === 0) {
     return false;
   }
 
-  // Determine if we should use semantic similarity
-  const canUseSemanticSimilarity = useSemanticSimilarity && isSemanticSimilarityAvailable();
-
-  verboseLog(verbose && canUseSemanticSimilarity, chalk.cyan('🔍 Using semantic similarity for issue comparison'));
+  // Loaded here rather than by the caller: this is the first point where a comparison
+  // is certain, and the embedding model is the expensive part of making one.
+  if (useSemanticSimilarity) {
+    await initializeSemanticSimilarity();
+  }
 
   // Check similarity with dismissed issues
   for (const dismissed of dismissedIssues) {
-    if (!dismissed.originalIssue) {
-      continue;
-    }
-
-    let similarity;
-    let similarityMethod;
+    const threshold = isSameLocation(dismissed, filePath, lineNumber)
+      ? Math.min(similarityThreshold, SAME_LOCATION_SIMILARITY_THRESHOLD)
+      : similarityThreshold;
 
-    if (canUseSemanticSimilarity) {
-      // Try semantic similarity first using existing embeddings system
-      similarity = await calculateSemanticSimilarity(issueDescription, dismissed.originalIssue);
-      similarityMethod = 'semantic';
-
-      // Fall back to word similarity if semantic calculation failed
-      if (similarity === null) {
-        similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
-        similarityMethod = 'word-based';
-      }
-    }
-    else {
-      // Use word-based similarity
-      similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
-      similarityMethod = 'word-based';
-    }
+    // The hybrid score, not the semantic score alone: a normalized semantic score ranks
+    // unrelated findings above the threshold, so one dismissal would suppress every issue.
+    const { similarity, method: similarityMethod } = await calculateIssueSimilarity(issueDescription, dismissed.originalIssue, {
+      useSemanticSimilarity,
+    });
 
-    if (similarity > similarityThreshold) {
+    if (similarity > threshold) {
       verboseLog(
         verbose,
         chalk.yellow(`⏭️ Skipping similar dismissed issue (${(similarity * 100).toFixed(1)}% ${similarityMethod} similarity)`)
@@ -249,6 +263,19 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
   return false;
 }
 
+/**
+ * Check whether a dismissed issue was recorded at the given file and line.
+ * A null on either side never matches, so an unknown location never narrows anything.
+ *
+ * @param {Object} dismissed - A dismissed feedback entry
+ * @param {string|null} filePath - Path of the current issue
+ * @param {number|null} lineNumber - Line of the current issue
+ * @returns {boolean} True when both locations are known and equal
+ */
+function isSameLocation(dismissed, filePath, lineNumber) {
+  return Boolean(filePath && lineNumber != null && dismissed.filePath === filePath && dismissed.lineNumber === lineNumber);
+}
+
 /**
  * Calculate combined similarity between two issue descriptions.
  * Uses both semantic and word-based similarity for robust comparison.
@@ -275,9 +302,7 @@ export async function calculateIssueSimilarity(text1, text2, options = {}) {
       // Also calculate word similarity for a hybrid score
       const wordSimilarity = calculateWordSimilarity(text1, text2);
 
-      // Combine both scores with more weight on semantic similarity
-      // This helps catch both semantically similar and lexically similar issues
-      const combinedSimilarity = semanticSimilarity * 0.7 + wordSimilarity * 0.3;
+      const combinedSimilarity = semanticSimilarity * SEMANTIC_WEIGHT + wordSimilarity * WORD_WEIGHT;
 
       return {
         similarity: combinedSimilarity,

package/src/feedback-loader.test.js

@@ -527,3 +527,117 @@ describe('loadFeedbackData edge cases', () => {
     expect(result).toHaveProperty('item');
   });
 });
+
+describe('shouldSkipSimilarIssue without a comparable pair', () => {
+  // Nothing to compare means nothing to load the embedding model for.
+  let loader;
+  let initialize;
+
+  beforeEach(async () => {
+    mockConsoleSelective('log', 'warn');
+    vi.resetModules();
+    initialize = vi.fn().mockResolvedValue(undefined);
+
+    // eslint-disable-next-line no-restricted-syntax
+    const freshFactory = await import('./embeddings/factory.js');
+    freshFactory.getDefaultEmbeddingsSystem.mockReturnValue({ initialize, calculateEmbedding: vi.fn() });
+
+    // eslint-disable-next-line no-restricted-syntax
+    loader = await import('./feedback-loader.js');
+  });
+
+  it.each([
+    ['the only dismissal has no text of its own', 'a candidate description', { i1: { overallSentiment: 'negative', originalIssue: '' } }],
+    ['the candidate has no description', '', { i1: { overallSentiment: 'negative', originalIssue: 'a dismissed finding' } }],
+  ])('should not initialize the embeddings system when %s', async (_name, description, feedbackData) => {
+    await expect(loader.shouldSkipSimilarIssue(description, feedbackData)).resolves.toBe(false);
+
+    expect(initialize).not.toHaveBeenCalled();
+  });
+});
+
+describe('shouldSkipSimilarIssue location match', () => {
+  // Word similarity 0.667: above the same-location bar of 0.65, below the 0.9 passed here.
+  // Only the location can decide these cases.
+  const SHARED = 'alpha bravo charlie delta echo foxtrot golf hotel';
+  const DISMISSED = `${SHARED} india juliett`;
+  const REWORDED = `${SHARED} kilo lima`;
+  const UNRELATED = 'mike november oscar papa quebec';
+  const LOCATION = { filePath: '.github/workflows/pr-review.yml', lineNumber: 51 };
+
+  const feedbackData = {
+    issue1: {
+      overallSentiment: 'neutral',
+      originalIssue: DISMISSED,
+      userReplies: [{ body: 'False positive.' }],
+      ...LOCATION,
+    },
+  };
+
+  const check = (description, options) =>
+    shouldSkipSimilarIssue(description, feedbackData, { similarityThreshold: 0.9, useSemanticSimilarity: false, ...options });
+
+  it.each([
+    ['a reworded repeat at the same location', REWORDED, LOCATION, true],
+    ['a reworded repeat on a different line', REWORDED, { ...LOCATION, lineNumber: 52 }, false],
+    ['an unrelated finding at the same location', UNRELATED, LOCATION, false],
+    ['a reworded repeat with no known line', REWORDED, { ...LOCATION, lineNumber: null }, false],
+  ])('should %s -> %s', async (_name, description, options, expected) => {
+    await expect(check(description, options)).resolves.toBe(expected);
+  });
+});
+
+describe('shouldSkipSimilarIssue with semantic similarity available', () => {
+  // Unit vectors whose cosine similarity is exact: [1, 0] against [cos, sin].
+  const vectorFor = (cosine) => [cosine, Math.sqrt(1 - cosine * cosine)];
+  const DISMISSED = 'Missing null check in the handler function';
+  const REPHRASED = 'The handler function does not guard against a null argument';
+  const UNRELATED = 'Prefer const over let for bindings that never change';
+
+  let loader;
+
+  beforeEach(async () => {
+    mockConsoleSelective('log', 'warn');
+    vi.resetModules();
+
+    // eslint-disable-next-line no-restricted-syntax
+    const freshFactory = await import('./embeddings/factory.js');
+    freshFactory.getDefaultEmbeddingsSystem.mockReturnValue({
+      initialize: vi.fn().mockResolvedValue(undefined),
+      calculateEmbedding: vi.fn(async (text) => {
+        if (text === DISMISSED) {
+          return vectorFor(1);
+        }
+        return vectorFor(text === REPHRASED ? 0.98 : 0.8);
+      }),
+    });
+
+    // eslint-disable-next-line no-restricted-syntax
+    loader = await import('./feedback-loader.js');
+    await loader.initializeSemanticSimilarity();
+  });
+
+  it('should skip a dismissed issue that the model rephrased', async () => {
+    const feedbackData = {
+      issue1: {
+        overallSentiment: 'neutral',
+        originalIssue: DISMISSED,
+        userReplies: [{ body: 'False positive.' }],
+      },
+    };
+
+    await expect(loader.shouldSkipSimilarIssue(REPHRASED, feedbackData, { similarityThreshold: 0.7 })).resolves.toBe(true);
+  });
+
+  it('should not skip an unrelated issue once another issue was dismissed', async () => {
+    const feedbackData = {
+      issue1: {
+        overallSentiment: 'neutral',
+        originalIssue: DISMISSED,
+        userReplies: [{ body: 'False positive.' }],
+      },
+    };
+
+    await expect(loader.shouldSkipSimilarIssue(UNRELATED, feedbackData, { similarityThreshold: 0.7 })).resolves.toBe(false);
+  });
+});

package/src/rag-analyzer.js

@@ -16,7 +16,7 @@ import {
   shouldSkipSimilarIssue,
   extractDismissedPatterns,
   generateFeedbackContext,
-  initializeSemanticSimilarity,
+  DEFAULT_SIMILARITY_THRESHOLD,
   isSemanticSimilarityAvailable,
 } from './feedback-loader.js';
 import * as llm from './llm.js';
@@ -37,9 +37,6 @@ const DEFAULT_TRUNCATE_LINES = 300;
 const GUIDELINE_TRUNCATE_LINES = 400;
 const MAX_PR_COMMENTS_FOR_CONTEXT = 15;
 
-// Track if semantic similarity has been initialized
-let semanticSimilarityInitialized = false;
-
 async function fileExists(filePath) {
   try {
     await fs.promises.access(filePath);
@@ -54,26 +51,6 @@ async function readTextFile(filePath) {
   return await fs.promises.readFile(filePath, 'utf8');
 }
 
-/**
- * Initialize semantic similarity for feedback filtering
- * Uses the shared embeddings system from feedback-loader.js
- */
-async function ensureSemanticSimilarityInitialized() {
-  if (semanticSimilarityInitialized) {
-    return;
-  }
-
-  try {
-    // Initialize semantic similarity using the shared embeddings system
-    await initializeSemanticSimilarity();
-    semanticSimilarityInitialized = true;
-  }
-  catch (error) {
-    console.warn(chalk.yellow(`⚠️ Could not initialize semantic similarity: ${error.message}`));
-    // Continue without semantic similarity - word-based fallback will be used
-  }
-}
-
 // ============================================================================
 // PROMPT FORMATTING HELPERS
 // Note: Static prompt content (critical rules, citation requirements, etc.) is
@@ -578,7 +555,7 @@ async function runAnalysis(filePath, options = {}) {
     if (options.trackFeedback && feedbackData && Object.keys(feedbackData).length > 0) {
       verboseLog(options, chalk.cyan('--- Filtering Results Based on Feedback ---'));
       filteredResults = await filterAnalysisResults(lowSeverityFiltered, feedbackData, {
-        similarityThreshold: options.feedbackThreshold || 0.7,
+        similarityThreshold: options.feedbackThreshold || DEFAULT_SIMILARITY_THRESHOLD,
         verbose: options.verbose,
       });
     }
@@ -2491,12 +2468,12 @@ function filterLowSeverityIssues(analysisResults, options = {}) {
  * @param {Object} analysisResults - Raw analysis results from LLM
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Filtering options
- * @param {number} [options.similarityThreshold=0.7] - Threshold for considering issues similar to dismissed feedback
+ * @param {number} [options.similarityThreshold=DEFAULT_SIMILARITY_THRESHOLD] - Threshold for considering issues similar to dismissed feedback
  * @param {boolean} [options.verbose=false] - Enable verbose similarity and filtering logs
  * @returns {Promise<Object>} Filtered analysis results
  */
 async function filterAnalysisResults(analysisResults, feedbackData, options = {}) {
-  const { similarityThreshold = 0.7, verbose = false } = options;
+  const { similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD, verbose = false } = options;
 
   if (!analysisResults || !analysisResults.issues || !Array.isArray(analysisResults.issues)) {
     return analysisResults;
@@ -2504,16 +2481,6 @@ async function filterAnalysisResults(analysisResults, feedbackData, options = {}
 
   const originalCount = analysisResults.issues.length;
 
-  // Ensure semantic similarity is initialized for better matching
-  await ensureSemanticSimilarityInitialized();
-
-  // Log whether semantic similarity is available
-  const usingSemanticSimilarity = isSemanticSimilarityAvailable();
-  verboseLog(
-    verbose,
-    chalk.cyan(`🔍 Filtering issues using ${usingSemanticSimilarity ? 'semantic + word-based similarity' : 'word-based similarity only'}`)
-  );
-
   // Filter issues based on feedback (now async due to semantic similarity)
   const filterResults = await Promise.all(
     analysisResults.issues.map(async (issue, index) => {

package/src/rag-analyzer.test.js

@@ -59,6 +59,7 @@ vi.mock('./feedback-loader.js', () => ({
   generateFeedbackContext: vi.fn().mockReturnValue(''),
   initializeSemanticSimilarity: vi.fn().mockResolvedValue(undefined),
   isSemanticSimilarityAvailable: vi.fn().mockReturnValue(false),
+  DEFAULT_SIMILARITY_THRESHOLD: 0.7,
 }));
 
 vi.mock('./llm.js', () => ({