@goshenkata/dryscan-core 1.2.5 → 1.2.6

package/dist/index.d.ts

@@ -221,7 +221,7 @@ declare class DryScan {
      * 6. Recompute embeddings for affected units
      * 7. Update file tracking metadata
      */
-    updateIndex(): Promise<void>;
+    updateIndex(): Promise<string[]>;
     /**
      * Runs duplicate detection and returns a normalized report payload ready for persistence or display.
      */

package/dist/index.js

@@ -61,7 +61,7 @@ var DEFAULT_CONFIG = {
   excludedPairs: [],
   minLines: 3,
   minBlockLines: 5,
-  threshold: 0.88,
+  threshold: 0.8,
   embeddingSource: "http://localhost:11434",
   contextLength: 2048
 };
@@ -244,7 +244,8 @@ var JavaExtractor = class {
         const fnUnit = this.buildFunctionUnit(node, source, fileRelPath, currentClass);
         const fnLength = fnUnit.endLine - fnUnit.startLine;
         const bodyNode = this.getFunctionBody(node);
-        const skipFunction = this.shouldSkip("function" /* FUNCTION */, fnUnit.name, fnLength);
+        const fnArity = this.getNodeArity(node);
+        const skipFunction = this.shouldSkip("function" /* FUNCTION */, fnUnit.name, fnLength, fnArity);
         if (skipFunction) {
           return;
         }
@@ -311,22 +312,34 @@ var JavaExtractor = class {
     const normalized = this.normalizeCode(unit.code);
     return crypto.createHash(BLOCK_HASH_ALGO).update(normalized).digest("hex");
   }
-  shouldSkip(unitType, name, lineCount) {
+  shouldSkip(unitType, name, lineCount, arity) {
     if (!this.config) {
       throw new Error("Config not loaded before skip evaluation");
     }
     const config = this.config;
     const minLines = unitType === "block" /* BLOCK */ ? Math.max(indexConfig.blockMinLines, config.minBlockLines ?? 0) : config.minLines;
     const belowMin = minLines > 0 && lineCount < minLines;
-    const trivial = unitType === "function" /* FUNCTION */ && this.isTrivialFunction(name);
+    const trivial = unitType === "function" /* FUNCTION */ && this.isTrivialFunction(name, arity ?? 0);
     return belowMin || trivial;
   }
-  isTrivialFunction(fullName) {
+  /**
+   * A function is trivial if it follows a simple accessor pattern:
+   * - getters/isers: name matches get[A-Z] or is[A-Z] with exactly 0 parameters
+   * - setters: name matches set[A-Z] with at most 1 parameter
+   * Methods like getUserById(Long id) have arity > 0 and are NOT trivial.
+   */
+  isTrivialFunction(fullName, arity) {
     const simpleName = fullName.split(".").pop() || fullName;
-    const isGetter = /^(get|is)[A-Z]/.test(simpleName);
-    const isSetter = /^set[A-Z]/.test(simpleName);
+    const isGetter = /^(get|is)[A-Z]/.test(simpleName) && arity === 0;
+    const isSetter = /^set[A-Z]/.test(simpleName) && arity <= 1;
     return isGetter || isSetter;
   }
+  /** Counts the formal parameters of a method or constructor node. */
+  getNodeArity(node) {
+    const params = node.childForFieldName?.("parameters");
+    if (!params) return 0;
+    return params.namedChildren.filter((c) => c.type === "formal_parameter" || c.type === "spread_parameter").length;
+  }
   isDtoClass(node, source, className) {
     const classBody = node.children.find((child) => child.type === "class_body");
     if (!classBody) return false;
@@ -344,7 +357,8 @@ var JavaExtractor = class {
       if (child.type === "method_declaration" || child.type === "constructor_declaration") {
         const simpleName = this.getSimpleFunctionName(child, source);
         const fullName = `${className}.${simpleName}`;
-        if (!this.isTrivialFunction(fullName)) {
+        const arity = this.getNodeArity(child);
+        if (!this.isTrivialFunction(fullName, arity)) {
           return false;
         }
         continue;
@@ -1021,7 +1035,7 @@ var RepositoryInitializer = class {
 };
 
 // src/services/UpdateService.ts
-import debug4 from "debug";
+import debug5 from "debug";
 
 // src/DryScanUpdater.ts
 import path4 from "path";
@@ -1141,11 +1155,20 @@ async function performIncrementalUpdate(repoPath, extractor, db) {
 }
 
 // src/services/DuplicationCache.ts
+import debug4 from "debug";
+import { cosineSimilarity } from "@langchain/core/utils/math";
+var log4 = debug4("DryScan:DuplicationCache");
 var DuplicationCache = class _DuplicationCache {
   static instance = null;
   comparisons = /* @__PURE__ */ new Map();
   fileIndex = /* @__PURE__ */ new Map();
   initialized = false;
+  /** Per-run similarity matrix from a single batched library call (reset each run). */
+  embSimMatrix = [];
+  /** Maps unit ID to its row/column index in embSimMatrix. */
+  embSimIndex = /* @__PURE__ */ new Map();
+  /** Per-run memoization of parent unit similarity scores (reset each run). */
+  parentSimCache = /* @__PURE__ */ new Map();
   static getInstance() {
     if (!_DuplicationCache.instance) {
       _DuplicationCache.instance = new _DuplicationCache();
@@ -1208,6 +1231,84 @@ var DuplicationCache = class _DuplicationCache {
     this.comparisons.clear();
     this.fileIndex.clear();
     this.initialized = false;
+    this.embSimMatrix = [];
+    this.embSimIndex.clear();
+    this.clearRunCaches();
+  }
+  /**
+   * Resets per-run memoization (parent similarities).
+   * The embedding matrix is intentionally preserved so incremental runs can
+   * reuse clean×clean values across calls.
+   */
+  clearRunCaches() {
+    this.parentSimCache.clear();
+  }
+  /**
+   * Builds or incrementally updates the embedding similarity matrix.
+   *
+   * Full rebuild (default): replaces the entire matrix — O(n²).
+   * Incremental (dirtyPaths provided + prior matrix exists): copies clean×clean
+   * cells from the old matrix and recomputes only dirty rows via one batched
+   * cosineSimilarity call — O(d·n) where d = number of dirty units.
+   */
+  buildEmbSimCache(units, dirtyPaths) {
+    const embedded = units.filter((u) => Array.isArray(u.embedding) && u.embedding.length > 0);
+    if (embedded.length < 2) {
+      this.embSimMatrix = [];
+      this.embSimIndex.clear();
+      return;
+    }
+    const embeddings = embedded.map((u) => u.embedding);
+    const newIndex = new Map(embedded.map((u, i) => [u.id, i]));
+    const dirtySet = dirtyPaths ? new Set(dirtyPaths) : null;
+    const hasPriorMatrix = this.embSimMatrix.length > 0;
+    if (!dirtySet || !hasPriorMatrix) {
+      this.embSimIndex = newIndex;
+      this.embSimMatrix = cosineSimilarity(embeddings, embeddings);
+      log4("Built full embedding similarity matrix: %d units", embedded.length);
+      return;
+    }
+    const dirtyIds = new Set(embedded.filter((u) => dirtySet.has(u.filePath)).map((u) => u.id));
+    if (dirtyIds.size === 0) {
+      log4("Matrix reused: no dirty units detected");
+      return;
+    }
+    const n = embedded.length;
+    const newMatrix = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        if (dirtyIds.has(embedded[i].id) || dirtyIds.has(embedded[j].id)) continue;
+        const oi = this.embSimIndex.get(embedded[i].id);
+        const oj = this.embSimIndex.get(embedded[j].id);
+        if (oi !== void 0 && oj !== void 0) newMatrix[i][j] = this.embSimMatrix[oi][oj];
+      }
+    }
+    const dirtyIndices = embedded.reduce((acc, u, i) => dirtyIds.has(u.id) ? [...acc, i] : acc, []);
+    const dirtyRows = cosineSimilarity(dirtyIndices.map((i) => embeddings[i]), embeddings);
+    dirtyIndices.forEach((rowIdx, di) => {
+      for (let j = 0; j < n; j++) {
+        newMatrix[rowIdx][j] = dirtyRows[di][j];
+        newMatrix[j][rowIdx] = dirtyRows[di][j];
+      }
+    });
+    this.embSimIndex = newIndex;
+    this.embSimMatrix = newMatrix;
+    log4("Incremental matrix update: %d dirty unit(s) out of %d total", dirtyIds.size, n);
+  }
+  /** Returns the pre-computed cosine similarity for a pair of unit IDs, if available. */
+  getEmbSim(id1, id2) {
+    const i = this.embSimIndex.get(id1);
+    const j = this.embSimIndex.get(id2);
+    if (i === void 0 || j === void 0) return void 0;
+    return this.embSimMatrix[i][j];
+  }
+  /** Returns the memoized parent similarity for the given stable key, if available. */
+  getParentSim(key) {
+    return this.parentSimCache.get(key);
+  }
+  /** Stores a memoized parent similarity for the given stable key. */
+  setParentSim(key, sim) {
+    this.parentSimCache.set(key, sim);
   }
   addKeyForFile(filePath, key) {
     const current = this.fileIndex.get(filePath) ?? /* @__PURE__ */ new Set();
@@ -1224,145 +1325,106 @@ var DuplicationCache = class _DuplicationCache {
 };
 
 // src/services/UpdateService.ts
-var log4 = debug4("DryScan:UpdateService");
+var log5 = debug5("DryScan:UpdateService");
 var UpdateService = class {
   constructor(deps, exclusionService) {
     this.deps = deps;
     this.exclusionService = exclusionService;
   }
+  /** Returns the list of file paths that were modified or deleted (dirty). */
   async updateIndex() {
     const extractor = this.deps.extractor;
     const cache = DuplicationCache.getInstance();
     try {
       const changeSet = await performIncrementalUpdate(this.deps.repoPath, extractor, this.deps.db);
       await this.exclusionService.cleanupExcludedFiles();
-      await cache.invalidate([...changeSet.changed, ...changeSet.deleted]);
+      const dirtyPaths = [...changeSet.changed, ...changeSet.deleted, ...changeSet.added];
+      await cache.invalidate(dirtyPaths);
+      return dirtyPaths;
     } catch (err) {
-      log4("Error during index update:", err);
+      log5("Error during index update:", err);
       throw err;
     }
   }
 };
 
 // src/services/DuplicateService.ts
-import debug5 from "debug";
+import debug6 from "debug";
 import shortUuid from "short-uuid";
-import { cosineSimilarity } from "@langchain/core/utils/math";
-var log5 = debug5("DryScan:DuplicateService");
+var log6 = debug6("DryScan:DuplicateService");
 var DuplicateService = class {
   constructor(deps) {
     this.deps = deps;
   }
   config;
   cache = DuplicationCache.getInstance();
-  //todo vetter optimisation
-  async findDuplicates(config) {
+  /**
+   * @param dirtyPaths - File paths changed since last run. When provided, only
+   *   dirty×all similarities are recomputed; clean×clean values are reused from
+   *   the existing matrix.  Pass undefined (or omit) for a full rebuild.
+   */
+  async findDuplicates(config, dirtyPaths) {
     this.config = config;
     const t0 = performance.now();
     const allUnits = await this.deps.db.getAllUnits();
-    log5("Starting duplicate analysis on %d units", allUnits.length);
+    log6("Starting duplicate analysis on %d units", allUnits.length);
     if (allUnits.length < 2) {
-      log5("Not enough units to compare, returning empty result");
-      const score2 = this.computeDuplicationScore([], allUnits);
-      return { duplicates: [], score: score2 };
+      return { duplicates: [], score: this.computeDuplicationScore([], allUnits) };
     }
     const thresholds = this.resolveThresholds(config.threshold);
-    log5("Resolved thresholds: function=%d, block=%d, class=%d", thresholds.function, thresholds.block, thresholds.class);
-    const duplicates = this.computeDuplicates(allUnits, thresholds);
-    const filteredDuplicates = duplicates.filter((group) => !this.isGroupExcluded(group));
-    log5("Found %d duplicate groups (%d excluded)", filteredDuplicates.length, duplicates.length - filteredDuplicates.length);
-    this.cache.update(filteredDuplicates).catch((err) => log5("Cache update failed: %O", err));
-    const score = this.computeDuplicationScore(filteredDuplicates, allUnits);
-    log5("findDuplicates completed in %dms", (performance.now() - t0).toFixed(2));
-    return { duplicates: filteredDuplicates, score };
+    const duplicates = this.computeDuplicates(allUnits, thresholds, dirtyPaths);
+    const filtered = duplicates.filter((g) => !this.isGroupExcluded(g));
+    log6("Found %d duplicate groups (%d excluded)", filtered.length, duplicates.length - filtered.length);
+    this.cache.update(filtered).catch((err) => log6("Cache update failed: %O", err));
+    const score = this.computeDuplicationScore(filtered, allUnits);
+    log6("findDuplicates completed in %dms", (performance.now() - t0).toFixed(2));
+    return { duplicates: filtered, score };
   }
   resolveThresholds(functionThreshold) {
-    const defaults = indexConfig.thresholds;
-    const clamp = (value) => Math.min(1, Math.max(0, value));
-    const base = functionThreshold ?? defaults.function;
-    const blockOffset = defaults.block - defaults.function;
-    const classOffset = defaults.class - defaults.function;
-    const functionThresholdValue = clamp(base);
+    const d = indexConfig.thresholds;
+    const clamp = (v) => Math.min(1, Math.max(0, v));
+    const fn = clamp(functionThreshold ?? d.function);
     return {
-      function: functionThresholdValue,
-      block: clamp(functionThresholdValue + blockOffset),
-      class: clamp(functionThresholdValue + classOffset)
+      function: fn,
+      block: clamp(fn + d.block - d.function),
+      class: clamp(fn + d.class - d.function)
     };
   }
-  computeDuplicates(units, thresholds) {
+  computeDuplicates(units, thresholds, dirtyPaths) {
+    this.cache.clearRunCaches();
+    this.cache.buildEmbSimCache(units, dirtyPaths);
     const duplicates = [];
-    const byType = /* @__PURE__ */ new Map();
-    for (const unit of units) {
-      const list = byType.get(unit.unitType) ?? [];
-      list.push(unit);
-      byType.set(unit.unitType, list);
-    }
     const t0 = performance.now();
-    for (const [type, typedUnits] of byType.entries()) {
+    for (const [type, typedUnits] of this.groupByType(units)) {
       const threshold = this.getThreshold(type, thresholds);
-      log5("Comparing %d units of type '%s' with threshold %d", typedUnits.length, type, threshold);
-      const typeStart = performance.now();
+      log6("Comparing %d %s units (threshold=%.3f)", typedUnits.length, type, threshold);
       for (let i = 0; i < typedUnits.length; i++) {
         for (let j = i + 1; j < typedUnits.length; j++) {
-          const left = typedUnits[i];
-          const right = typedUnits[j];
-          if (this.shouldSkipComparison(left, right)) {
-            log5("Skipping nested block comparison: '%s' and '%s'", left.name, right.name);
-            continue;
-          }
+          const left = typedUnits[i], right = typedUnits[j];
+          if (this.shouldSkipComparison(left, right)) continue;
           const cached = this.cache.get(left.id, right.id, left.filePath, right.filePath);
-          let similarity = null;
-          if (cached !== null) {
-            log5("Cache hit for '%s' <-> '%s': similarity=%d", left.name, right.name, cached);
-            similarity = cached;
-          } else {
-            if (!left.embedding || !right.embedding) {
-              log5("Skipping '%s' <-> '%s': missing embedding", left.name, right.name);
-              continue;
-            }
-            similarity = this.computeWeightedSimilarity(left, right);
-            log5("Computed similarity for '%s' <-> '%s': %d", left.name, right.name, similarity);
-          }
-          if (similarity === null) continue;
-          if (similarity >= threshold) {
-            const exclusionString = this.deps.pairing.pairKeyForUnits(left, right);
-            if (!exclusionString) continue;
-            log5("Duplicate found: '%s' <-> '%s' (similarity=%d)", left.name, right.name, similarity);
-            duplicates.push({
-              id: `${left.id}::${right.id}`,
-              similarity,
-              shortId: shortUuid.generate(),
-              exclusionString,
-              left: {
-                id: left.id,
-                name: left.name,
-                filePath: left.filePath,
-                startLine: left.startLine,
-                endLine: left.endLine,
-                code: left.code,
-                unitType: left.unitType
-              },
-              right: {
-                id: right.id,
-                name: right.name,
-                filePath: right.filePath,
-                startLine: right.startLine,
-                endLine: right.endLine,
-                code: right.code,
-                unitType: right.unitType
-              }
-            });
-          }
+          const hasEmbeddings = left.embedding?.length && right.embedding?.length;
+          const similarity = cached ?? (hasEmbeddings ? this.computeWeightedSimilarity(left, right, threshold) : 0);
+          if (similarity < threshold) continue;
+          const exclusionString = this.deps.pairing.pairKeyForUnits(left, right);
+          if (!exclusionString) continue;
+          duplicates.push({
+            id: `${left.id}::${right.id}`,
+            similarity,
+            shortId: shortUuid.generate(),
+            exclusionString,
+            left: this.toMember(left),
+            right: this.toMember(right)
+          });
         }
       }
-      log5("Type '%s' comparisons completed in %dms", type, (performance.now() - typeStart).toFixed(2));
     }
-    log5("computeDuplicates completed in %dms, found %d raw duplicates", (performance.now() - t0).toFixed(2), duplicates.length);
+    log6("computeDuplicates: %d duplicates in %dms", duplicates.length, (performance.now() - t0).toFixed(2));
     return duplicates.sort((a, b) => b.similarity - a.similarity);
   }
   isGroupExcluded(group) {
     const config = this.config;
-    if (!config || !config.excludedPairs || config.excludedPairs.length === 0) return false;
+    if (!config?.excludedPairs?.length) return false;
     const key = this.deps.pairing.pairKeyForUnits(group.left, group.right);
     if (!key) return false;
     const actual = this.deps.pairing.parsePairKey(key);
@@ -1377,109 +1439,108 @@ var DuplicateService = class {
     if (type === "block" /* BLOCK */) return thresholds.block;
     return thresholds.function;
   }
-  computeWeightedSimilarity(left, right) {
-    const selfSimilarity = this.similarityWithFallback(left, right);
+  computeWeightedSimilarity(left, right, threshold) {
+    const selfSim = this.similarity(left, right);
     if (left.unitType === "class" /* CLASS */) {
-      return selfSimilarity * indexConfig.weights.class.self;
+      return selfSim * indexConfig.weights.class.self;
     }
     if (left.unitType === "function" /* FUNCTION */) {
-      const weights2 = indexConfig.weights.function;
-      const hasParentClass2 = !!this.findParentOfType(left, "class" /* CLASS */) && !!this.findParentOfType(right, "class" /* CLASS */);
-      const parentClassSimilarity = hasParentClass2 ? this.parentSimilarity(left, right, "class" /* CLASS */) : 0;
-      const totalWeight2 = weights2.self + (hasParentClass2 ? weights2.parentClass : 0);
-      return (weights2.self * selfSimilarity + (hasParentClass2 ? weights2.parentClass * parentClassSimilarity : 0)) / totalWeight2;
+      const w2 = indexConfig.weights.function;
+      const hasPC2 = this.bothHaveParent(left, right, "class" /* CLASS */);
+      const total2 = w2.self + (hasPC2 ? w2.parentClass : 0);
+      if ((w2.self * selfSim + (hasPC2 ? w2.parentClass : 0)) / total2 < threshold) return 0;
+      return (w2.self * selfSim + (hasPC2 ? w2.parentClass * this.parentSimilarity(left, right, "class" /* CLASS */) : 0)) / total2;
     }
-    const weights = indexConfig.weights.block;
-    const hasParentFunction = !!this.findParentOfType(left, "function" /* FUNCTION */) && !!this.findParentOfType(right, "function" /* FUNCTION */);
-    const hasParentClass = !!this.findParentOfType(left, "class" /* CLASS */) && !!this.findParentOfType(right, "class" /* CLASS */);
-    const parentFuncSim = hasParentFunction ? this.parentSimilarity(left, right, "function" /* FUNCTION */) : 0;
-    const parentClassSim = hasParentClass ? this.parentSimilarity(left, right, "class" /* CLASS */) : 0;
-    const totalWeight = weights.self + (hasParentFunction ? weights.parentFunction : 0) + (hasParentClass ? weights.parentClass : 0);
-    return (weights.self * selfSimilarity + (hasParentFunction ? weights.parentFunction * parentFuncSim : 0) + (hasParentClass ? weights.parentClass * parentClassSim : 0)) / totalWeight;
-  }
-  parentSimilarity(left, right, targetType) {
-    const leftParent = this.findParentOfType(left, targetType);
-    const rightParent = this.findParentOfType(right, targetType);
-    if (!leftParent || !rightParent) return 0;
-    return this.similarityWithFallback(leftParent, rightParent);
-  }
-  similarityWithFallback(left, right) {
-    const leftHasEmbedding = this.hasVector(left);
-    const rightHasEmbedding = this.hasVector(right);
-    if (leftHasEmbedding && rightHasEmbedding) {
-      return cosineSimilarity([left.embedding], [right.embedding])[0][0];
+    const w = indexConfig.weights.block;
+    const hasPF = this.bothHaveParent(left, right, "function" /* FUNCTION */);
+    const hasPC = this.bothHaveParent(left, right, "class" /* CLASS */);
+    const total = w.self + (hasPF ? w.parentFunction : 0) + (hasPC ? w.parentClass : 0);
+    if ((w.self * selfSim + (hasPF ? w.parentFunction : 0) + (hasPC ? w.parentClass : 0)) / total < threshold) return 0;
+    return (w.self * selfSim + (hasPF ? w.parentFunction * this.parentSimilarity(left, right, "function" /* FUNCTION */) : 0) + (hasPC ? w.parentClass * this.parentSimilarity(left, right, "class" /* CLASS */) : 0)) / total;
+  }
+  /** Groups all units by type for the comparison loop. Units without embeddings are included
+   * so that cache hits can still be returned for pairs whose embeddings were cleared. */
+  groupByType(units) {
+    const byType = /* @__PURE__ */ new Map();
+    for (const unit of units) {
+      const list = byType.get(unit.unitType) ?? [];
+      list.push(unit);
+      byType.set(unit.unitType, list);
     }
-    return this.childSimilarity(left, right);
+    return byType;
+  }
+  toMember(unit) {
+    return {
+      id: unit.id,
+      name: unit.name,
+      filePath: unit.filePath,
+      startLine: unit.startLine,
+      endLine: unit.endLine,
+      code: unit.code,
+      unitType: unit.unitType
+    };
+  }
+  bothHaveParent(left, right, type) {
+    return !!this.findParent(left, type) && !!this.findParent(right, type);
+  }
+  parentSimilarity(left, right, type) {
+    const lp = this.findParent(left, type), rp = this.findParent(right, type);
+    if (!lp || !rp) return 0;
+    const key = lp.id < rp.id ? `${lp.id}::${rp.id}` : `${rp.id}::${lp.id}`;
+    const cached = this.cache.getParentSim(key);
+    if (cached !== void 0) return cached;
+    const sim = this.similarity(lp, rp);
+    this.cache.setParentSim(key, sim);
+    return sim;
+  }
+  /** Resolves similarity via the pre-computed embedding matrix, falling back to best child match. */
+  similarity(left, right) {
+    return this.cache.getEmbSim(left.id, right.id) ?? this.childSimilarity(left, right);
   }
   childSimilarity(left, right) {
-    const leftChildren = left.children ?? [];
-    const rightChildren = right.children ?? [];
-    if (leftChildren.length === 0 || rightChildren.length === 0) return 0;
+    const lc = left.children ?? [], rc = right.children ?? [];
+    if (!lc.length || !rc.length) return 0;
     let best = 0;
-    for (const lChild of leftChildren) {
-      for (const rChild of rightChildren) {
-        if (lChild.unitType !== rChild.unitType) continue;
-        const sim = this.similarityWithFallback(lChild, rChild);
+    for (const l of lc) {
+      for (const r of rc) {
+        if (l.unitType !== r.unitType) continue;
+        const sim = this.similarity(l, r);
         if (sim > best) best = sim;
       }
     }
     return best;
   }
-  hasVector(unit) {
-    return Array.isArray(unit.embedding) && unit.embedding.length > 0;
-  }
   shouldSkipComparison(left, right) {
-    if (left.unitType !== "block" /* BLOCK */ || right.unitType !== "block" /* BLOCK */) {
-      return false;
-    }
-    if (left.filePath !== right.filePath) {
-      return false;
-    }
-    const leftContainsRight = left.startLine <= right.startLine && left.endLine >= right.endLine;
-    const rightContainsLeft = right.startLine <= left.startLine && right.endLine >= left.endLine;
-    return leftContainsRight || rightContainsLeft;
-  }
-  findParentOfType(unit, targetType) {
-    let current = unit.parent;
-    while (current) {
-      if (current.unitType === targetType) return current;
-      current = current.parent;
+    if (left.unitType !== "block" /* BLOCK */ || right.unitType !== "block" /* BLOCK */) return false;
+    if (left.filePath !== right.filePath) return false;
+    return left.startLine <= right.startLine && left.endLine >= right.endLine || right.startLine <= left.startLine && right.endLine >= left.endLine;
+  }
+  findParent(unit, type) {
+    let p = unit.parent;
+    while (p) {
+      if (p.unitType === type) return p;
+      p = p.parent;
     }
     return null;
   }
   computeDuplicationScore(duplicates, allUnits) {
-    const totalLines = this.calculateTotalLines(allUnits);
-    if (totalLines === 0 || duplicates.length === 0) {
-      return {
-        score: 0,
-        grade: "Excellent",
-        totalLines,
-        duplicateLines: 0,
-        duplicateGroups: 0
-      };
+    const totalLines = allUnits.reduce((sum, u) => sum + u.endLine - u.startLine + 1, 0);
+    if (!totalLines || !duplicates.length) {
+      return { score: 0, grade: "Excellent", totalLines, duplicateLines: 0, duplicateGroups: 0 };
     }
-    const weightedDuplicateLines = duplicates.reduce((sum, group) => {
-      const leftLines = group.left.endLine - group.left.startLine + 1;
-      const rightLines = group.right.endLine - group.right.startLine + 1;
-      const avgLines = (leftLines + rightLines) / 2;
-      return sum + group.similarity * avgLines;
+    const duplicateLines = duplicates.reduce((sum, g) => {
+      const avg = (g.left.endLine - g.left.startLine + 1 + (g.right.endLine - g.right.startLine + 1)) / 2;
+      return sum + g.similarity * avg;
     }, 0);
-    const score = weightedDuplicateLines / totalLines * 100;
-    const grade = this.getScoreGrade(score);
+    const score = duplicateLines / totalLines * 100;
     return {
       score,
-      grade,
+      grade: this.getScoreGrade(score),
       totalLines,
-      duplicateLines: Math.round(weightedDuplicateLines),
+      duplicateLines: Math.round(duplicateLines),
       duplicateGroups: duplicates.length
     };
   }
-  calculateTotalLines(units) {
-    return units.reduce((sum, unit) => {
-      const lines = unit.endLine - unit.startLine + 1;
-      return sum + lines;
-    }, 0);
-  }
   getScoreGrade(score) {
     if (score < 5) return "Excellent";
     if (score < 15) return "Good";
@@ -1575,9 +1636,9 @@ var ExclusionService = class {
 
 // src/services/PairingService.ts
 import crypto3 from "crypto";
-import debug6 from "debug";
+import debug7 from "debug";
 import { minimatch as minimatch2 } from "minimatch";
-var log6 = debug6("DryScan:pairs");
+var log7 = debug7("DryScan:pairs");
 var PairingService = class {
   constructor(indexUnitExtractor) {
     this.indexUnitExtractor = indexUnitExtractor;
@@ -1588,7 +1649,7 @@ var PairingService = class {
    */
   pairKeyForUnits(left, right) {
     if (left.unitType !== right.unitType) {
-      log6("Skipping pair with mismatched types: %s vs %s", left.unitType, right.unitType);
+      log7("Skipping pair with mismatched types: %s vs %s", left.unitType, right.unitType);
       return null;
     }
     const type = left.unitType;
@@ -1604,13 +1665,13 @@ var PairingService = class {
   parsePairKey(value) {
     const parts = value.split("|");
     if (parts.length !== 3) {
-      log6("Invalid pair key format: %s", value);
+      log7("Invalid pair key format: %s", value);
       return null;
     }
     const [typeRaw, leftRaw, rightRaw] = parts;
     const type = this.stringToUnitType(typeRaw);
     if (!type) {
-      log6("Unknown unit type in pair key: %s", typeRaw);
+      log7("Unknown unit type in pair key: %s", typeRaw);
       return null;
     }
     const [left, right] = [leftRaw, rightRaw].sort();
@@ -1744,9 +1805,10 @@ var DryScan = class {
     console.log("[DryScan] Checking for file changes...");
     const start = Date.now();
     await this.ensureDatabase();
-    await this.services.updater.updateIndex();
+    const dirtyPaths = await this.services.updater.updateIndex();
     const duration = Date.now() - start;
     console.log(`[DryScan] Index update complete. Took ${duration}ms.`);
+    return dirtyPaths;
   }
   /**
    * Runs duplicate detection and returns a normalized report payload ready for persistence or display.
@@ -1775,12 +1837,12 @@ var DryScan = class {
     await this.ensureDatabase();
     console.log("[DryScan] Updating index...");
     const updateStart = Date.now();
-    await this.updateIndex();
+    const dirtyPaths = await this.updateIndex();
     const updateDuration = Date.now() - updateStart;
     console.log(`[DryScan] Index update  took ${updateDuration}ms.`);
     console.log("[DryScan] Detecting duplicates...");
     const dupStart = Date.now();
-    const result = await this.services.duplicate.findDuplicates(config);
+    const result = await this.services.duplicate.findDuplicates(config, dirtyPaths);
     const dupDuration = Date.now() - dupStart;
     console.log(`[DryScan] Duplicate detection took ${dupDuration}ms.`);
     return result;