omp-plugin-duplicate-detector 0.2.2 → 0.3.0

package/dist/detector-worker.js

@@ -977,11 +977,11 @@ import * as path5 from "path";
 
 // src/disk-cache.ts
 import { Database } from "bun:sqlite";
-import * as crypto from "crypto";
-import * as fsSync from "fs";
-import * as fs from "fs/promises";
+import * as crypto2 from "crypto";
+import * as fsSync2 from "fs";
+import * as fs2 from "fs/promises";
 import * as os from "os";
-import * as path3 from "path";
+import * as path4 from "path";
 import * as zlib from "zlib";
 
 // node_modules/eventemitter3/index.mjs
@@ -12292,6 +12292,95 @@ async function getTrackedGitFiles(rootDir, options = {}) {
   }
 }
 
+// src/repo-context.ts
+import * as crypto from "crypto";
+import * as fsSync from "fs";
+import * as fs from "fs/promises";
+import * as path3 from "path";
+function canonicalizePath(targetPath) {
+  const resolved = path3.resolve(targetPath);
+  let current = resolved;
+  let suffix = "";
+  while (current && current !== path3.dirname(current)) {
+    try {
+      if (fsSync.existsSync(current)) {
+        const real = fsSync.realpathSync(current);
+        return suffix ? path3.join(real, suffix) : real;
+      }
+    } catch {}
+    suffix = suffix ? path3.join(path3.basename(current), suffix) : path3.basename(current);
+    current = path3.dirname(current);
+  }
+  return resolved;
+}
+function isOmpWorktreePath(targetPath) {
+  const normalized = targetPath.replace(/\\/g, "/");
+  return normalized.includes("/.omp/wt/") || normalized.includes("/.omp/worktrees/");
+}
+async function resolveRepositoryContext(cwd, signal) {
+  const canonicalCwd = canonicalizePath(cwd);
+  try {
+    const { stdout } = await execGit([
+      "rev-parse",
+      "--path-format=absolute",
+      "--show-toplevel",
+      "--git-dir",
+      "--git-common-dir"
+    ], canonicalCwd, { signal });
+    const lines = stdout.split(`
+`).map((l) => l.trim()).filter(Boolean);
+    const resolveEntry = (val) => {
+      if (!val)
+        return "";
+      return path3.isAbsolute(val) ? val : path3.resolve(canonicalCwd, val);
+    };
+    const workspaceRoot = canonicalizePath(resolveEntry(lines[0]));
+    const gitDir = canonicalizePath(resolveEntry(lines[1] || path3.join(workspaceRoot, ".git")));
+    const commonGitDir = canonicalizePath(resolveEntry(lines[2] || lines[1] || path3.join(workspaceRoot, ".git")));
+    let repositoryObjectDir = path3.join(commonGitDir, "objects");
+    const isOmpIsolation = isOmpWorktreePath(workspaceRoot) || isOmpWorktreePath(canonicalCwd);
+    if (isOmpIsolation && gitDir === commonGitDir) {
+      const alternatesFile = path3.join(gitDir, "objects", "info", "alternates");
+      try {
+        if (fsSync.existsSync(alternatesFile)) {
+          const content = await fs.readFile(alternatesFile, "utf-8");
+          const altLines = content.split(`
+`).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          for (const line of altLines) {
+            const resolvedAlt = path3.isAbsolute(line) ? line : path3.resolve(path3.join(gitDir, "objects"), line);
+            const canonicalAlt = canonicalizePath(resolvedAlt);
+            if (fsSync.existsSync(canonicalAlt)) {
+              repositoryObjectDir = canonicalAlt;
+              break;
+            }
+          }
+        }
+      } catch {}
+    }
+    repositoryObjectDir = canonicalizePath(repositoryObjectDir);
+    const repositoryKey = crypto.createHash("sha256").update(`git-object-dir\x00${repositoryObjectDir}`).digest("hex").slice(0, 16);
+    return {
+      workspaceRoot,
+      isGit: true,
+      gitDir,
+      commonGitDir,
+      repositoryObjectDir,
+      repositoryKey,
+      isOmpIsolation
+    };
+  } catch {
+    const repositoryObjectDir = path3.join(canonicalCwd, ".non-git");
+    const repositoryKey = crypto.createHash("sha256").update(`directory\x00${canonicalCwd}`).digest("hex").slice(0, 16);
+    return {
+      workspaceRoot: canonicalCwd,
+      isGit: false,
+      repositoryObjectDir,
+      repositoryKey,
+      isOmpIsolation: false
+    };
+  }
+}
+
 // src/source-aware-index.ts
 class CompactSourceFrame {
   id;
@@ -12673,6 +12762,7 @@ class SourceAwareCloneIndex {
     const detectedClones = [];
     const { insertFrames = false } = options;
     let activeClones = new Map;
+    const canonicalSourceId = canonicalizePath(sourceId);
     for (const frame of frames) {
       const frameStartLine = "startLine" in frame ? frame.startLine : frame.start.loc?.start.line ?? frame.start.line ?? 1;
       const frameStartCol = "startCol" in frame ? frame.startCol : frame.start.loc?.start.column ?? frame.start.column ?? 1;
@@ -12720,7 +12810,8 @@ class SourceAwareCloneIndex {
         const targetEndCol = targetFrame.endCol;
         const targetEndPos = targetFrame.endPos;
         const targetEndRange = targetFrame.endRange;
-        if (targetFrame.sourceId === sourceId && targetStartLine === frameStartLine && targetStartCol === frameStartCol) {
+        const isSameSource = targetFrame.sourceId === sourceId || canonicalizePath(targetFrame.sourceId) === canonicalSourceId;
+        if (isSameSource && targetStartLine === frameStartLine && targetStartCol === frameStartCol) {
           continue;
         }
         const offsetKey = `${targetFrame.sourceId}:${targetStartRange - frameStartRange}`;
@@ -12838,20 +12929,20 @@ class SourceAwareCloneIndex {
 
 // src/disk-cache.ts
 var DEFAULT_MAX_CACHE_BYTES = 250 * 1024 * 1024;
-var TOKENIZER_CACHE_VERSION = "4.0";
+var TOKENIZER_CACHE_VERSION = "5.0";
 function getDefaultCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA;
     if (localAppData) {
-      return path3.join(localAppData, "omp", "duplicate-detector");
+      return path4.join(localAppData, "omp", "duplicate-detector");
     }
-    return path3.join(os.homedir(), "AppData", "Local", "omp", "duplicate-detector");
+    return path4.join(os.homedir(), "AppData", "Local", "omp", "duplicate-detector");
   }
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome) {
-    return path3.join(xdgCacheHome, "omp", "duplicate-detector");
+    return path4.join(xdgCacheHome, "omp", "duplicate-detector");
   }
-  return path3.join(os.homedir(), ".cache", "omp", "duplicate-detector");
+  return path4.join(os.homedir(), ".cache", "omp", "duplicate-detector");
 }
 function computeConfigFingerprint(config) {
   if (!config)
@@ -12871,15 +12962,15 @@ function computeConfigFingerprint(config) {
     crossFormats: config.crossFormats ?? false,
     formatsExts: sortedFormats
   };
-  return crypto.createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
+  return crypto2.createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
 }
 function computeWorkspaceCachePath(baseDir, repositoryKeyOrRootDir, configFingerprint) {
   const isKey = /^[0-9a-f]{16}$/i.test(repositoryKeyOrRootDir);
-  const repoKey = isKey ? repositoryKeyOrRootDir : crypto.createHash("sha256").update(path3.resolve(repositoryKeyOrRootDir)).digest("hex").slice(0, 16);
-  return path3.join(baseDir, `${repoKey}_${configFingerprint}_v${CACHE_FORMAT_VERSION}.sqlite`);
+  const repoKey = isKey ? repositoryKeyOrRootDir : crypto2.createHash("sha256").update(path4.resolve(repositoryKeyOrRootDir)).digest("hex").slice(0, 16);
+  return path4.join(baseDir, `${repoKey}_${configFingerprint}_v${CACHE_FORMAT_VERSION}.sqlite`);
 }
 var CACHE_FORMAT_MAGIC = "DUP3";
-var CACHE_FORMAT_VERSION = 4;
+var CACHE_FORMAT_VERSION = 5;
 function packBinaryShard(shard) {
   return packBinaryShardV3(shard, shard.tokens ?? []);
 }
@@ -12913,20 +13004,22 @@ function packBinaryShardV3(shard, tokens) {
   const dLenBuf = Buffer.allocUnsafe(colBytes);
   let prevLine = 0;
   let prevCol = 0;
-  let prevPos = 0;
+  let prevRangeStart = 0;
   for (let i = 0;i < tokenCount; i++) {
     const tok = tokens[i];
     const dLine = tok.line - prevLine;
     const dCol = tok.column - prevCol;
-    const dPos = tok.position - prevPos;
-    const len = Array.isArray(tok.range) && tok.range.length >= 2 ? tok.range[1] - tok.range[0] : 0;
+    const startRange = Array.isArray(tok.range) && tok.range.length >= 2 ? tok.range[0] : tok.position ?? i;
+    const endRange = Array.isArray(tok.range) && tok.range.length >= 2 ? tok.range[1] : startRange;
+    const len = Math.max(0, endRange - startRange);
+    const dRangeStart = startRange - prevRangeStart;
     dLinesBuf.writeInt32LE(dLine, i * 4);
     dColsBuf.writeInt32LE(dCol, i * 4);
-    dPosBuf.writeInt32LE(dPos, i * 4);
+    dPosBuf.writeInt32LE(dRangeStart, i * 4);
     dLenBuf.writeUInt32LE(len, i * 4);
     prevLine = tok.line;
     prevCol = tok.column;
-    prevPos = tok.position;
+    prevRangeStart = startRange;
   }
   const meta = {
     sourceId: shard.sourceId,
@@ -12975,7 +13068,7 @@ function unpackBinaryShard(compressed) {
 function unpackBinaryShardV3(buf) {
   try {
     const version = buf.readUInt16LE(4);
-    if (version < 3 || version > CACHE_FORMAT_VERSION)
+    if (version !== CACHE_FORMAT_VERSION)
       return null;
     const metaLen = buf.readUInt16LE(6);
     const tokenCount = buf.readUInt32LE(8);
@@ -13027,11 +13120,11 @@ function unpackBinaryShardV3(buf) {
     const tokens = new Array(tokenCount);
     let curLine = 0;
     let curCol = 0;
-    let curPos = 0;
+    let curRangeStart = 0;
     for (let i = 0;i < tokenCount; i++) {
       curLine += dLines[i];
       curCol += dCols[i];
-      curPos += dPos[i];
+      curRangeStart += dPos[i];
       const len = dLens[i];
       const dictIdx = indices[i];
       const hash2 = dictionary[dictIdx] ?? "";
@@ -13039,8 +13132,8 @@ function unpackBinaryShardV3(buf) {
         hash: hash2,
         line: curLine,
         column: curCol,
-        position: curPos,
-        range: [curPos, curPos + len]
+        position: i,
+        range: [curRangeStart, curRangeStart + len]
       };
     }
     const minTokens = meta.minTokens ?? 40;
@@ -13081,9 +13174,9 @@ class DiskCacheManager {
   #deleteAllStmt = null;
   #closed = false;
   constructor(options) {
-    this.rootDir = path3.resolve(options.rootDir);
-    this.repositoryKey = options.repositoryKey ?? crypto.createHash("sha256").update(this.rootDir).digest("hex").slice(0, 16);
-    this.baseCacheDir = options.cacheDir ? path3.resolve(options.cacheDir) : getDefaultCacheDir();
+    this.rootDir = path4.resolve(options.rootDir);
+    this.repositoryKey = options.repositoryKey ?? crypto2.createHash("sha256").update(this.rootDir).digest("hex").slice(0, 16);
+    this.baseCacheDir = options.cacheDir ? path4.resolve(options.cacheDir) : getDefaultCacheDir();
     this.configFingerprint = computeConfigFingerprint(options.config);
     this.dbPath = computeWorkspaceCachePath(this.baseCacheDir, this.repositoryKey, this.configFingerprint);
     this.workspaceCacheDir = this.baseCacheDir;
@@ -13096,9 +13189,9 @@ class DiskCacheManager {
       return this.#db;
     let db = null;
     try {
-      const dir = path3.dirname(this.dbPath);
-      if (!fsSync.existsSync(dir)) {
-        fsSync.mkdirSync(dir, { recursive: true });
+      const dir = path4.dirname(this.dbPath);
+      if (!fsSync2.existsSync(dir)) {
+        fsSync2.mkdirSync(dir, { recursive: true });
       }
       db = new Database(this.dbPath, { create: true });
       db.exec("PRAGMA busy_timeout = 2000;");
@@ -13177,7 +13270,7 @@ class DiskCacheManager {
       const db = this.#getDb();
       if (!db || !this.#saveStmt)
         return;
-      const targetRelPath = relPath ?? (path3.isAbsolute(shard.sourceId) ? path3.relative(this.rootDir, shard.sourceId) : shard.sourceId);
+      const targetRelPath = relPath ?? (path4.isAbsolute(shard.sourceId) ? path4.relative(this.rootDir, shard.sourceId) : shard.sourceId);
       const normalizedRelPath = targetRelPath.replace(/\\/g, "/");
       const payload = packBinaryShard(shard);
       this.#saveStmt.run(normalizedRelPath, shard.contentHash, payload, Date.now());
@@ -13213,7 +13306,7 @@ class DiskCacheManager {
       const now = Date.now();
       const prepared = [];
       for (const item of items) {
-        const targetRelPath = item.relPath ?? (path3.isAbsolute(item.shard.sourceId) ? path3.relative(root, item.shard.sourceId) : item.shard.sourceId);
+        const targetRelPath = item.relPath ?? (path4.isAbsolute(item.shard.sourceId) ? path4.relative(root, item.shard.sourceId) : item.shard.sourceId);
         const normalizedRelPath = targetRelPath.replace(/\\/g, "/");
         const payload = packBinaryShard(item.shard);
         prepared.push({
@@ -13295,108 +13388,19 @@ class DiskCacheManager {
 async function cleanupLegacyCacheFiles(customCacheDir) {
   const baseDir = customCacheDir ?? getDefaultCacheDir();
   try {
-    if (!fsSync.existsSync(baseDir))
+    if (!fsSync2.existsSync(baseDir))
       return;
-    const entries = await fs.readdir(baseDir);
+    const entries = await fs2.readdir(baseDir);
     for (const entry of entries) {
       if (entry.endsWith(".sqlite") && !entry.includes(`_v${CACHE_FORMAT_VERSION}.sqlite`)) {
-        await fs.unlink(path3.join(baseDir, entry)).catch(() => {});
-        await fs.unlink(path3.join(baseDir, `${entry}-wal`)).catch(() => {});
-        await fs.unlink(path3.join(baseDir, `${entry}-shm`)).catch(() => {});
+        await fs2.unlink(path4.join(baseDir, entry)).catch(() => {});
+        await fs2.unlink(path4.join(baseDir, `${entry}-wal`)).catch(() => {});
+        await fs2.unlink(path4.join(baseDir, `${entry}-shm`)).catch(() => {});
       }
     }
   } catch {}
 }
 
-// src/repo-context.ts
-import * as crypto2 from "crypto";
-import * as fsSync2 from "fs";
-import * as fs2 from "fs/promises";
-import * as path4 from "path";
-function canonicalizePath(targetPath) {
-  const resolved = path4.resolve(targetPath);
-  let current = resolved;
-  let suffix = "";
-  while (current && current !== path4.dirname(current)) {
-    try {
-      if (fsSync2.existsSync(current)) {
-        const real = fsSync2.realpathSync(current);
-        return suffix ? path4.join(real, suffix) : real;
-      }
-    } catch {}
-    suffix = suffix ? path4.join(path4.basename(current), suffix) : path4.basename(current);
-    current = path4.dirname(current);
-  }
-  return resolved;
-}
-function isOmpWorktreePath(targetPath) {
-  const normalized = targetPath.replace(/\\/g, "/");
-  return normalized.includes("/.omp/wt/") || normalized.includes("/.omp/worktrees/");
-}
-async function resolveRepositoryContext(cwd, signal) {
-  const canonicalCwd = canonicalizePath(cwd);
-  try {
-    const { stdout } = await execGit([
-      "rev-parse",
-      "--path-format=absolute",
-      "--show-toplevel",
-      "--git-dir",
-      "--git-common-dir"
-    ], canonicalCwd, { signal });
-    const lines = stdout.split(`
-`).map((l) => l.trim()).filter(Boolean);
-    const resolveEntry = (val) => {
-      if (!val)
-        return "";
-      return path4.isAbsolute(val) ? val : path4.resolve(canonicalCwd, val);
-    };
-    const workspaceRoot = canonicalizePath(resolveEntry(lines[0]));
-    const gitDir = canonicalizePath(resolveEntry(lines[1] || path4.join(workspaceRoot, ".git")));
-    const commonGitDir = canonicalizePath(resolveEntry(lines[2] || lines[1] || path4.join(workspaceRoot, ".git")));
-    let repositoryObjectDir = path4.join(commonGitDir, "objects");
-    const isOmpIsolation = isOmpWorktreePath(workspaceRoot) || isOmpWorktreePath(canonicalCwd);
-    if (isOmpIsolation && gitDir === commonGitDir) {
-      const alternatesFile = path4.join(gitDir, "objects", "info", "alternates");
-      try {
-        if (fsSync2.existsSync(alternatesFile)) {
-          const content = await fs2.readFile(alternatesFile, "utf-8");
-          const altLines = content.split(`
-`).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
-          for (const line of altLines) {
-            const resolvedAlt = path4.isAbsolute(line) ? line : path4.resolve(path4.join(gitDir, "objects"), line);
-            const canonicalAlt = canonicalizePath(resolvedAlt);
-            if (fsSync2.existsSync(canonicalAlt)) {
-              repositoryObjectDir = canonicalAlt;
-              break;
-            }
-          }
-        }
-      } catch {}
-    }
-    repositoryObjectDir = canonicalizePath(repositoryObjectDir);
-    const repositoryKey = crypto2.createHash("sha256").update(`git-object-dir\x00${repositoryObjectDir}`).digest("hex").slice(0, 16);
-    return {
-      workspaceRoot,
-      isGit: true,
-      gitDir,
-      commonGitDir,
-      repositoryObjectDir,
-      repositoryKey,
-      isOmpIsolation
-    };
-  } catch {
-    const repositoryObjectDir = path4.join(canonicalCwd, ".non-git");
-    const repositoryKey = crypto2.createHash("sha256").update(`directory\x00${canonicalCwd}`).digest("hex").slice(0, 16);
-    return {
-      workspaceRoot: canonicalCwd,
-      isGit: false,
-      repositoryObjectDir,
-      repositoryKey,
-      isOmpIsolation: false
-    };
-  }
-}
-
 // src/worker-protocol.ts
 var REQUEST_TYPES = {
   openWorkspace: true,
@@ -13763,7 +13767,8 @@ async function runBaselineIndexing(rootDir, options, signal) {
         totalSourceBytes,
         cloneCount: currentIndex.clones.length,
         durationMs: Date.now() - startTime,
-        status: baselineStatus
+        status: baselineStatus,
+        baselineClones: currentIndex.getClones()
       }));
       self.postMessage(createStatusEvent("ready", "Baseline indexing complete"));
       return { indexedCount, status: baselineStatus };
@@ -13906,6 +13911,15 @@ async function handleWorkerRequest(msg) {
           }
           activeAbortController = new AbortController;
           const recResult = await runIncrementalGitReconciliation(currentRootDir, options, activeAbortController.signal);
+          self.postMessage(createCompleteEvent({
+            indexedCount: recResult.indexedCount,
+            cachedCount: 0,
+            totalSourceBytes: 0,
+            cloneCount: currentIndex.clones.length,
+            durationMs: 0,
+            status: recResult.status,
+            baselineClones: currentIndex.getClones()
+          }));
           self.postMessage(createSuccessResponse(msg.id, {
             started: true,
             rootDir: currentRootDir,
@@ -13965,12 +13979,16 @@ async function handleWorkerRequest(msg) {
     }
     case "checkAndUpdate": {
       const { filePath, content, format, revision = 1 } = msg.payload;
-      const rawClones = currentIndex.updateSource(filePath, content, format);
       const canonicalFilePath = canonicalizePath(filePath);
       const resolvedPath = path5.resolve(filePath);
+      currentIndex.removeSource(canonicalFilePath);
+      currentIndex.removeSource(resolvedPath);
+      currentIndex.removeSource(filePath);
+      const rawClones = currentIndex.addSource(filePath, content, format);
+      cacheSourceShard(canonicalFilePath, content);
       cacheSourceShard(filePath, content);
       const clones = filterAndEvictStaleClones(rawClones, filePath);
-      const fileClones = clones.filter((c) => c.duplicationA.sourceId === filePath || c.duplicationB.sourceId === filePath || path5.resolve(c.duplicationA.sourceId) === resolvedPath || path5.resolve(c.duplicationB.sourceId) === resolvedPath || canonicalizePath(c.duplicationA.sourceId) === canonicalFilePath || canonicalizePath(c.duplicationB.sourceId) === canonicalFilePath);
+      const fileClones = clones.filter((c) => c.duplicationA.sourceId === filePath || c.duplicationB.sourceId === filePath || c.duplicationA.sourceId === canonicalFilePath || c.duplicationB.sourceId === canonicalFilePath || path5.resolve(c.duplicationA.sourceId) === resolvedPath || path5.resolve(c.duplicationB.sourceId) === resolvedPath || canonicalizePath(c.duplicationA.sourceId) === canonicalFilePath || canonicalizePath(c.duplicationB.sourceId) === canonicalFilePath);
       const watchEntry = {
         revision,
         lastKnownCloneCount: fileClones.length

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omp-plugin-duplicate-detector",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"description": "Code clone and duplication detector plugin for oh-my-pi powered by jscpd",
 	"type": "module",
 	"files": [

package/src/detector-worker.ts

@@ -466,6 +466,7 @@ async function runBaselineIndexing(
 					cloneCount: currentIndex.clones.length,
 					durationMs: Date.now() - startTime,
 					status: baselineStatus,
+					baselineClones: currentIndex.getClones(),
 				}),
 			);
 			self.postMessage(
@@ -649,6 +650,17 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 						options,
 						activeAbortController.signal,
 					);
+					self.postMessage(
+						createCompleteEvent({
+							indexedCount: recResult.indexedCount,
+							cachedCount: 0,
+							totalSourceBytes: 0,
+							cloneCount: currentIndex.clones.length,
+							durationMs: 0,
+							status: recResult.status,
+							baselineClones: currentIndex.getClones(),
+						}),
+					);
 					self.postMessage(
 						createSuccessResponse(msg.id, {
 							started: true,
@@ -731,24 +743,31 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 
 		case "checkAndUpdate": {
 			const { filePath, content, format, revision = 1 } = msg.payload;
-			const rawClones = currentIndex.updateSource(filePath, content, format);
 			const canonicalFilePath = canonicalizePath(filePath);
 			const resolvedPath = path.resolve(filePath);
 
+			// Remove all path variations to ensure no duplicate self-match across symlinks
+			currentIndex.removeSource(canonicalFilePath);
+			currentIndex.removeSource(resolvedPath);
+			currentIndex.removeSource(filePath);
+
+			const rawClones = currentIndex.addSource(filePath, content, format);
+
+			cacheSourceShard(canonicalFilePath, content);
 			cacheSourceShard(filePath, content);
 
 			const clones = filterAndEvictStaleClones(rawClones, filePath);
-
 			const fileClones = clones.filter(
 				(c) =>
 					c.duplicationA.sourceId === filePath ||
 					c.duplicationB.sourceId === filePath ||
+					c.duplicationA.sourceId === canonicalFilePath ||
+					c.duplicationB.sourceId === canonicalFilePath ||
 					path.resolve(c.duplicationA.sourceId) === resolvedPath ||
 					path.resolve(c.duplicationB.sourceId) === resolvedPath ||
 					canonicalizePath(c.duplicationA.sourceId) === canonicalFilePath ||
 					canonicalizePath(c.duplicationB.sourceId) === canonicalFilePath,
 			);
-
 			const watchEntry = {
 				revision,
 				lastKnownCloneCount: fileClones.length,

package/src/disk-cache.ts

@@ -21,7 +21,7 @@ import {
 import type { WorkspaceOptions } from "./worker-protocol";
 
 const DEFAULT_MAX_CACHE_BYTES = 250 * 1024 * 1024; // 250 MB
-const TOKENIZER_CACHE_VERSION = "4.0";
+const TOKENIZER_CACHE_VERSION = "5.0";
 
 export interface DiskCacheOptions {
 	/** Root directory of the workspace */
@@ -136,7 +136,7 @@ export function computeShardKey(
 export const CACHE_FORMAT_MAGIC = "DUP3";
 
 /** Current binary format & SQLite schema version */
-export const CACHE_FORMAT_VERSION = 4;
+export const CACHE_FORMAT_VERSION = 5;
 
 /**
  * Encodes a SerializedSourceShard into a high-density, zlib-compressed binary buffer (DUP3 format).
@@ -187,26 +187,31 @@ function packBinaryShardV3(
 
 	let prevLine = 0;
 	let prevCol = 0;
-	let prevPos = 0;
+	let prevRangeStart = 0;
 
 	for (let i = 0; i < tokenCount; i++) {
 		const tok = tokens[i]!;
 		const dLine = tok.line - prevLine;
 		const dCol = tok.column - prevCol;
-		const dPos = tok.position - prevPos;
-		const len =
+		const startRange =
 			Array.isArray(tok.range) && tok.range.length >= 2
-				? tok.range[1] - tok.range[0]
-				: 0;
+				? tok.range[0]
+				: (tok.position ?? i);
+		const endRange =
+			Array.isArray(tok.range) && tok.range.length >= 2
+				? tok.range[1]
+				: startRange;
+		const len = Math.max(0, endRange - startRange);
+		const dRangeStart = startRange - prevRangeStart;
 
 		dLinesBuf.writeInt32LE(dLine, i * 4);
 		dColsBuf.writeInt32LE(dCol, i * 4);
-		dPosBuf.writeInt32LE(dPos, i * 4);
+		dPosBuf.writeInt32LE(dRangeStart, i * 4);
 		dLenBuf.writeUInt32LE(len, i * 4);
 
 		prevLine = tok.line;
 		prevCol = tok.column;
-		prevPos = tok.position;
+		prevRangeStart = startRange;
 	}
 
 	const meta = {
@@ -267,7 +272,7 @@ export function unpackBinaryShard(
 function unpackBinaryShardV3(buf: Buffer): SerializedSourceShard | null {
 	try {
 		const version = buf.readUInt16LE(4);
-		if (version < 3 || version > CACHE_FORMAT_VERSION) return null;
+		if (version !== CACHE_FORMAT_VERSION) return null;
 
 		const metaLen = buf.readUInt16LE(6);
 		const tokenCount = buf.readUInt32LE(8);
@@ -329,12 +334,12 @@ function unpackBinaryShardV3(buf: Buffer): SerializedSourceShard | null {
 		const tokens: SerializedToken[] = new Array(tokenCount);
 		let curLine = 0;
 		let curCol = 0;
-		let curPos = 0;
+		let curRangeStart = 0;
 
 		for (let i = 0; i < tokenCount; i++) {
 			curLine += dLines[i]!;
 			curCol += dCols[i]!;
-			curPos += dPos[i]!;
+			curRangeStart += dPos[i]!;
 			const len = dLens[i]!;
 			const dictIdx = indices[i]!;
 			const hash = dictionary[dictIdx] ?? "";
@@ -343,8 +348,8 @@ function unpackBinaryShardV3(buf: Buffer): SerializedSourceShard | null {
 				hash,
 				line: curLine,
 				column: curCol,
-				position: curPos,
-				range: [curPos, curPos + len],
+				position: i,
+				range: [curRangeStart, curRangeStart + len],
 			};
 		}
 

package/src/duplicate-ledger.ts

@@ -1,6 +1,144 @@
 import type { IClone } from "@jscpd/core";
 import { toDisplayPath } from "./tui-notification";
 
+export interface LineRange {
+	start: number;
+	end: number;
+}
+
+/**
+ * Computes 1-indexed changed/added line ranges in newText relative to oldText.
+ * If oldText is null or undefined (e.g. newly created file), returns the full range of newText.
+ */
+export function computeChangedLineRanges(
+	oldText: string | null | undefined,
+	newText: string,
+): LineRange[] {
+	if (oldText == null) {
+		const lines = newText.split(/\r?\n/);
+		return [{ start: 1, end: Math.max(1, lines.length) }];
+	}
+	if (oldText === newText || newText.length === 0) {
+		return [];
+	}
+
+	const oldLines = oldText.split(/\r?\n/);
+	const newLines = newText.split(/\r?\n/);
+
+	if (oldLines.length === 0) {
+		return [{ start: 1, end: Math.max(1, newLines.length) }];
+	}
+	if (newLines.length === 0) {
+		return [];
+	}
+
+	// Trim common prefix
+	let prefix = 0;
+	while (
+		prefix < oldLines.length &&
+		prefix < newLines.length &&
+		oldLines[prefix] === newLines[prefix]
+	) {
+		prefix++;
+	}
+
+	// Trim common suffix
+	let oldSuffix = oldLines.length - 1;
+	let newSuffix = newLines.length - 1;
+	while (
+		oldSuffix >= prefix &&
+		newSuffix >= prefix &&
+		oldLines[oldSuffix] === newLines[newSuffix]
+	) {
+		oldSuffix--;
+		newSuffix--;
+	}
+
+	const oldTrimmed = oldLines.slice(prefix, oldSuffix + 1);
+	const newTrimmed = newLines.slice(prefix, newSuffix + 1);
+
+	// Pure deletions: lines were removed, but no new lines were introduced
+	if (newTrimmed.length === 0) {
+		return [];
+	}
+
+	// Compute LCS on the trimmed core if reasonably bounded (up to 500k cells)
+	if (
+		oldTrimmed.length > 0 &&
+		newTrimmed.length > 0 &&
+		oldTrimmed.length * newTrimmed.length <= 500000
+	) {
+		const m = oldTrimmed.length;
+		const n = newTrimmed.length;
+		const dp = Array.from({ length: m + 1 }, () => new Int32Array(n + 1));
+		for (let i = 1; i <= m; i++) {
+			for (let j = 1; j <= n; j++) {
+				if (oldTrimmed[i - 1] === newTrimmed[j - 1]) {
+					dp[i]![j] = dp[i - 1]![j - 1]! + 1;
+				} else {
+					dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
+				}
+			}
+		}
+
+		const matchedInNew = new Uint8Array(n);
+		let i = m;
+		let j = n;
+		while (i > 0 && j > 0) {
+			if (oldTrimmed[i - 1] === newTrimmed[j - 1]) {
+				matchedInNew[j - 1] = 1;
+				i--;
+				j--;
+			} else if (dp[i - 1]![j]! >= dp[i]![j - 1]!) {
+				i--;
+			} else {
+				j--;
+			}
+		}
+
+		const ranges: LineRange[] = [];
+		let rangeStart = -1;
+		for (let idx = 0; idx < n; idx++) {
+			if (!matchedInNew[idx]) {
+				if (rangeStart === -1) rangeStart = prefix + idx + 1;
+			} else {
+				if (rangeStart !== -1) {
+					ranges.push({ start: rangeStart, end: prefix + idx });
+					rangeStart = -1;
+				}
+			}
+		}
+		if (rangeStart !== -1) {
+			ranges.push({ start: rangeStart, end: prefix + n });
+		}
+
+		return ranges;
+	}
+
+	if (prefix <= newSuffix) {
+		return [{ start: prefix + 1, end: newSuffix + 1 }];
+	}
+	return [];
+}
+
+/**
+ * Checks whether a clone's target mutation span intersects any of the changed line ranges.
+ */
+export function cloneIntersectsRanges(
+	clone: IClone,
+	ranges: LineRange[],
+	side: "duplicationA" | "duplicationB" = "duplicationA",
+): boolean {
+	if (ranges.length === 0) return false;
+	const span =
+		side === "duplicationB" ? clone.duplicationB : clone.duplicationA;
+	const start = span.start.line;
+	const end = span.end.line;
+	return ranges.some(
+		(range) => Math.max(start, range.start) <= Math.min(end, range.end),
+	);
+}
+
 /**
  * Unique identifier for a duplicate match.
  */
@@ -31,28 +169,99 @@ function extractLineRange(
  */
 export class DuplicateLedger {
 	readonly #seen = new Map<string, Set<string>>();
+	readonly #baseline = new Map<string, Set<string>>();
+
+	#addBaseline(key: string, id: string): void {
+		if (!key) return;
+		let set = this.#baseline.get(key);
+		if (!set) {
+			set = new Set<string>();
+			this.#baseline.set(key, set);
+		}
+		set.add(id);
+	}
+
+	/**
+	 * Seed pre-existing baseline clones from workspace indexing so that legacy repository
+	 * duplications are treated as pre-existing and not flagged as newly introduced duplicates.
+	 */
+	seedBaseline(clones: IClone[], basePath?: string): void {
+		for (const clone of clones) {
+			const a = clone.duplicationA;
+			const b = clone.duplicationB;
+			const lenA = a.end.line - a.start.line + 1;
+			const lenB = b.end.line - b.start.line + 1;
+
+			const relA = toDisplayPath(a.sourceId, basePath);
+			const relB = toDisplayPath(b.sourceId, basePath);
+
+			const idA_raw = `${b.sourceId}:${b.start.line}-${b.end.line}::${a.sourceId}::${lenA}`;
+			const idA_rel = `${relB}:${b.start.line}-${b.end.line}::${relA}::${lenA}`;
+
+			const idB_raw = `${a.sourceId}:${a.start.line}-${a.end.line}::${b.sourceId}::${lenB}`;
+			const idB_rel = `${relA}:${a.start.line}-${a.end.line}::${relB}::${lenB}`;
+
+			// Register bidirectional identities under both files' raw and display keys
+			const allIds = [idA_raw, idA_rel, idB_raw, idB_rel];
+			const allKeys = [relA, a.sourceId, relB, b.sourceId];
+
+			for (const key of allKeys) {
+				for (const id of allIds) {
+					this.#addBaseline(key, id);
+				}
+			}
+		}
+	}
 
 	/**
 	 * Filter a list of clones, returning only those not yet seen for the target file.
 	 * Updates the ledger with newly seen identities.
 	 */
-	filterFreshClones(filePath: string, clones: IClone[]): IClone[] {
+	filterFreshClones(
+		filePath: string,
+		clones: IClone[],
+		basePath?: string,
+	): IClone[] {
+		const displayPath = toDisplayPath(filePath, basePath);
 		const previous = this.#seen.get(filePath);
+		const prevDisplay = this.#seen.get(displayPath);
+		const baseline = this.#baseline.get(filePath);
+		const baseDisplay = this.#baseline.get(displayPath);
 		const fresh: IClone[] = [];
 		const currentIdentities = new Set<string>();
 
 		for (const clone of clones) {
 			const id = cloneIdentity(clone);
-			currentIdentities.add(id);
-			if (!previous?.has(id)) {
-				fresh.push(clone);
+			const a = clone.duplicationA;
+			const b = clone.duplicationB;
+			const len = a.end.line - a.start.line + 1;
+			const relId = `${toDisplayPath(b.sourceId, basePath)}:${b.start.line}-${b.end.line}::${toDisplayPath(a.sourceId, basePath)}::${len}`;
+
+			if (!currentIdentities.has(id)) {
+				currentIdentities.add(id);
+				currentIdentities.add(relId);
+				const isBaseline =
+					baseline?.has(id) ||
+					baseline?.has(relId) ||
+					baseDisplay?.has(id) ||
+					baseDisplay?.has(relId);
+				const isPrevious =
+					previous?.has(id) ||
+					previous?.has(relId) ||
+					prevDisplay?.has(id) ||
+					prevDisplay?.has(relId);
+				if (!isBaseline && !isPrevious) {
+					fresh.push(clone);
+				}
 			}
 		}
 
 		if (currentIdentities.size === 0) {
 			this.#seen.delete(filePath);
+			this.#seen.delete(displayPath);
 		} else {
 			this.#seen.set(filePath, currentIdentities);
+			this.#seen.set(displayPath, currentIdentities);
 		}
 
 		return fresh;
@@ -137,8 +346,10 @@ export class DuplicateLedger {
 	clear(filePath?: string): void {
 		if (filePath) {
 			this.#seen.delete(filePath);
+			this.#baseline.delete(filePath);
 		} else {
 			this.#seen.clear();
+			this.#baseline.clear();
 		}
 	}
 }

package/src/index.ts

@@ -9,7 +9,12 @@ import {
 	type JscpdProjectConfig,
 } from "./config-loader";
 import { DuplicateDetectorCoordinator } from "./coordinator";
-import { DuplicateLedger } from "./duplicate-ledger";
+import {
+	cloneIntersectsRanges,
+	computeChangedLineRanges,
+	DuplicateLedger,
+	type LineRange,
+} from "./duplicate-ledger";
 import {
 	type BaselineStatus,
 	createIgnoreFilter,
@@ -231,6 +236,21 @@ function extractSettingsObject(
 	return undefined;
 }
 
+function extractPathFromToolInput(input: unknown): string | undefined {
+	if (!input || typeof input !== "object") return undefined;
+	const obj = input as Record<string, unknown>;
+	if (typeof obj.path === "string" && obj.path) {
+		return obj.path;
+	}
+	if (typeof obj.input === "string" && obj.input) {
+		const match = obj.input.match(/^\[([^#\]\r\n]+)(?:#[a-zA-Z0-9_-]+)?\]/m);
+		if (match?.[1]) {
+			return match[1].trim();
+		}
+	}
+	return undefined;
+}
+
 export function formatBaselineMessage(
 	status: BaselineStatus,
 	count: number,
@@ -337,6 +357,8 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 	let lastCtx: ExtensionContext | undefined;
 	const ledger = new DuplicateLedger();
 	const fileRevisions = new Map<string, number>();
+	const fileChangedRanges = new Map<string, LineRange[]>();
+	const preMutationContent = new Map<string, string | null>();
 	const coordinator = new DuplicateDetectorCoordinator();
 	let lastKnownHead: string | null = null;
 	let workerFailureNotified = false;
@@ -474,6 +496,9 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 			notifyWorkerFailure(payload.error ?? "Baseline indexing failed");
 			return;
 		}
+		if (payload.baselineClones && payload.baselineClones.length > 0) {
+			ledger.seedBaseline(payload.baselineClones, currentCwd);
+		}
 		workerFailureNotified = false;
 		notifyBaselineStatus(
 			pi,
@@ -527,8 +552,25 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 				: undefined;
 
 		if (!targetRel) return;
+		const targetRanges = fileChangedRanges.get(targetRel);
+		if (targetRanges) {
+			const isIntraFile = relA === relB;
+			const intersects = isIntraFile
+				? cloneIntersectsRanges(clone, targetRanges, "duplicationA") ||
+					cloneIntersectsRanges(clone, targetRanges, "duplicationB")
+				: cloneIntersectsRanges(
+						clone,
+						targetRanges,
+						targetRel === relB ? "duplicationB" : "duplicationA",
+					);
+			if (!intersects) return;
+		}
 
-		const freshClones = ledger.filterFreshClones(targetRel, [clone]);
+		const freshClones = ledger.filterFreshClones(
+			targetRel,
+			[clone],
+			currentCwd,
+		);
 		if (freshClones.length > 0) {
 			const fullPath = path.isAbsolute(targetRel)
 				? targetRel
@@ -573,6 +615,8 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 	pi.on("session_switch", async (event, ctx) => {
 		ledger.clear();
 		fileRevisions.clear();
+		fileChangedRanges.clear();
+		preMutationContent.clear();
 		workerFailureNotified = false;
 		lastKnownHead = null;
 		if (ctx?.cwd) {
@@ -615,6 +659,8 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 	pi.on("session_branch", async () => {
 		ledger.clear();
 		fileRevisions.clear();
+		fileChangedRanges.clear();
+		preMutationContent.clear();
 	});
 
 	pi.on("session_shutdown", async () => {
@@ -687,9 +733,44 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 	});
 
 	// Intercept write and edit tool executions to detect clones in newly added/modified code
+	// Pre-capture file content before write or edit mutation so diff calculation on tool_result
+	// knows exactly which line ranges were newly introduced vs pre-existing.
+	pi.on("tool_call", async (event, ctx) => {
+		if (event.toolName !== "write" && event.toolName !== "edit") return;
+		const rawPath = extractPathFromToolInput(event.input);
+		if (!rawPath || rawPath.includes("://")) return;
+		const fullPath = path.isAbsolute(rawPath)
+			? path.resolve(rawPath)
+			: path.resolve(ctx.cwd, rawPath);
+		try {
+			const file = Bun.file(fullPath);
+			if (await file.exists()) {
+				preMutationContent.set(fullPath, await file.text());
+			} else {
+				preMutationContent.set(fullPath, null);
+			}
+		} catch {
+			preMutationContent.set(fullPath, null);
+		}
+	});
+
 	pi.on(
 		"tool_result",
 		async (event, ctx): Promise<ToolResultEventResult | void> => {
+			let capturedOldContent: string | null | undefined;
+			let resolvedFullPath: string | undefined;
+
+			if (event.toolName === "write" || event.toolName === "edit") {
+				const rawPath = extractPathFromToolInput(event.input);
+				if (rawPath && !rawPath.includes("://") && ctx?.cwd) {
+					resolvedFullPath = path.isAbsolute(rawPath)
+						? path.resolve(rawPath)
+						: path.resolve(ctx.cwd, rawPath);
+					capturedOldContent = preMutationContent.get(resolvedFullPath);
+					preMutationContent.delete(resolvedFullPath);
+				}
+			}
+
 			if (event.isError) return;
 			if (!isEnabledForProject) return;
 			if (!config.checkOnMutation) return;
@@ -699,15 +780,9 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 				return;
 			}
 			if (event.toolName !== "write" && event.toolName !== "edit") return;
-			const input = event.input as { path?: string };
-			const rawPath = input?.path;
-			if (!rawPath || typeof rawPath !== "string") return;
-			// Skip internal protocol URLs (e.g. xd://, local://)
-			if (rawPath.includes("://")) return;
-
-			const fullPath = path.isAbsolute(rawPath)
-				? path.resolve(rawPath)
-				: path.resolve(ctx.cwd, rawPath);
+			if (!resolvedFullPath) return;
+
+			const fullPath = resolvedFullPath;
 			const relPath = path.relative(ctx.cwd, fullPath);
 			const normalizedRelPath = relPath.replace(/\\/g, "/");
 
@@ -720,7 +795,6 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 			) {
 				return;
 			}
-
 			try {
 				// Skip ignored files (matching ignore patterns, noise files, or test files)
 				const ignoreFilter = createIgnoreFilter(config.ignorePatterns, {
@@ -737,6 +811,27 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 				// Skip generated files
 				if (isGeneratedContent(content)) return;
 
+				let oldContent = capturedOldContent;
+				if (oldContent === undefined && ctx?.cwd) {
+					try {
+						const isGit = await isInsideGitWorkTree(ctx.cwd);
+						if (isGit) {
+							const { stdout } = await execGit(
+								["show", `HEAD:${normalizedRelPath}`],
+								ctx.cwd,
+							);
+							oldContent = stdout;
+						} else {
+							oldContent = null;
+						}
+					} catch {
+						oldContent = null;
+					}
+				}
+
+				const changedRanges = computeChangedLineRanges(oldContent, content);
+				fileChangedRanges.set(normalizedRelPath, changedRanges);
+
 				const revision = (fileRevisions.get(normalizedRelPath) ?? 0) + 1;
 				fileRevisions.set(normalizedRelPath, revision);
 
@@ -745,7 +840,24 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 					content,
 					revision,
 				);
-				const freshClones = ledger.filterFreshClones(normalizedRelPath, clones);
+				const mutatingClones = clones.filter((c) => {
+					if (cloneIntersectsRanges(c, changedRanges, "duplicationA")) {
+						return true;
+					}
+					const isIntraFile =
+						c.duplicationA.sourceId === c.duplicationB.sourceId ||
+						path.resolve(c.duplicationA.sourceId) ===
+							path.resolve(c.duplicationB.sourceId);
+					return (
+						isIntraFile &&
+						cloneIntersectsRanges(c, changedRanges, "duplicationB")
+					);
+				});
+				const freshClones = ledger.filterFreshClones(
+					normalizedRelPath,
+					mutatingClones,
+					currentCwd,
+				);
 
 				if (freshClones.length > 0) {
 					const fullReminder = ledger.formatReminder(
@@ -872,6 +984,8 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 				isEnabledForProject = false;
 				ledger.clear();
 				fileRevisions.clear();
+				fileChangedRanges.clear();
+				preMutationContent.clear();
 				ctx.ui.notify("Duplicate detector disabled for this project.", "info");
 				notifyBaselineStatus(pi, ctx as ExtensionContext, "disabled", 0);
 			} else if (action === "status" || action === "") {

package/src/source-aware-index.ts

@@ -14,6 +14,7 @@ import {
 } from "@jscpd/core";
 import { Tokenizer } from "@jscpd/tokenizer";
 import { getSupportedCodeFormat } from "./jscpd-engine";
+import { canonicalizePath } from "./repo-context";
 export class CompactSourceFrame {
 	constructor(
 		public readonly id: string,
@@ -689,6 +690,7 @@ export class SourceAwareCloneIndex {
 		const { insertFrames = false } = options;
 		let activeClones = new Map<string, ActiveCloneCandidate>();
 
+		const canonicalSourceId = canonicalizePath(sourceId);
 		for (const frame of frames) {
 			const frameStartLine =
 				"startLine" in frame
@@ -793,8 +795,11 @@ export class SourceAwareCloneIndex {
 				const targetEndRange = targetFrame.endRange;
 
 				// Disallow exact self-match at identical line/column position
+				const isSameSource =
+					targetFrame.sourceId === sourceId ||
+					canonicalizePath(targetFrame.sourceId) === canonicalSourceId;
 				if (
-					targetFrame.sourceId === sourceId &&
+					isSameSource &&
 					targetStartLine === frameStartLine &&
 					targetStartCol === frameStartCol
 				) {

package/src/tui-notification.ts

@@ -132,8 +132,14 @@ export function toDisplayPath(sourceId: string, basePath?: string): string {
 		(typeof process !== "undefined" && process.cwd ? process.cwd() : "")
 	)?.replace(/\\/g, "/");
 
-	if (root && clean.startsWith(root)) {
-		clean = clean.slice(root.length);
+	if (root) {
+		if (clean.startsWith(root)) {
+			clean = clean.slice(root.length);
+		} else if (clean.startsWith(`/private${root}`)) {
+			clean = clean.slice(`/private${root}`.length);
+		} else if (root.startsWith("/private") && clean.startsWith(root.slice(8))) {
+			clean = clean.slice(root.slice(8).length);
+		}
 		if (clean.startsWith("/")) clean = clean.slice(1);
 	}
 	return clean || sourceId;

package/src/worker-protocol.ts

@@ -180,6 +180,7 @@ export interface WorkerCompletePayload {
 	durationMs: number;
 	status?: BaselineStatus;
 	error?: string;
+	baselineClones?: IClone[];
 }
 
 export interface WorkerCompleteEvent {