omp-plugin-duplicate-detector 0.2.0 → 0.2.1

package/dist/detector-worker.js

@@ -971,6 +971,7 @@ var require_ignore = __commonJS(function(exports, module) {
 
 // src/detector-worker.ts
 import * as crypto3 from "crypto";
+import * as fsSync3 from "fs";
 import * as fs3 from "fs/promises";
 import * as path5 from "path";
 
@@ -13074,6 +13075,7 @@ class DiskCacheManager {
   #getStmt = null;
   #saveStmt = null;
   #deleteStmt = null;
+  #deleteByRelPathStmt = null;
   #totalSizeStmt = null;
   #oldestShardsStmt = null;
   #deleteAllStmt = null;
@@ -13135,6 +13137,7 @@ class DiskCacheManager {
 					mtime = excluded.mtime
 			`);
       this.#deleteStmt = db.prepare("DELETE FROM shards WHERE rel_path = ?1 AND content_hash = ?2");
+      this.#deleteByRelPathStmt = db.prepare("DELETE FROM shards WHERE rel_path = ?1");
       this.#totalSizeStmt = db.prepare("SELECT COALESCE(SUM(LENGTH(payload)), 0) as total FROM shards");
       this.#oldestShardsStmt = db.prepare("SELECT rowid, LENGTH(payload) as size FROM shards ORDER BY mtime ASC LIMIT ?1");
       this.#deleteAllStmt = db.prepare("DELETE FROM shards");
@@ -13189,6 +13192,15 @@ class DiskCacheManager {
       this.#deleteStmt.run(normalizedRelPath, contentHash);
     } catch {}
   }
+  async deleteByRelPath(relPath) {
+    try {
+      const db = this.#getDb();
+      if (!db || !this.#deleteByRelPathStmt)
+        return;
+      const normalizedRelPath = relPath.replace(/\\/g, "/");
+      this.#deleteByRelPathStmt.run(normalizedRelPath);
+    } catch {}
+  }
   async saveShards(items) {
     if (items.length === 0)
       return;
@@ -13273,6 +13285,7 @@ class DiskCacheManager {
       this.#getStmt = null;
       this.#saveStmt = null;
       this.#deleteStmt = null;
+      this.#deleteByRelPathStmt = null;
       this.#totalSizeStmt = null;
       this.#oldestShardsStmt = null;
       this.#deleteAllStmt = null;
@@ -13302,11 +13315,18 @@ import * as fs2 from "fs/promises";
 import * as path4 from "path";
 function canonicalizePath(targetPath) {
   const resolved = path4.resolve(targetPath);
-  try {
-    if (fsSync2.existsSync(resolved)) {
-      return fsSync2.realpathSync(resolved);
-    }
-  } catch {}
+  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) {
@@ -13481,6 +13501,56 @@ function areOptionsEqual(a, b) {
   const bFormats = b.formatsExts ? JSON.stringify(b.formatsExts) : "";
   return aFormats === bFormats;
 }
+function filterAndEvictStaleClones(clones, activeFilePath) {
+  if (!currentRootDir || !fsSync3.existsSync(currentRootDir)) {
+    return clones;
+  }
+  const validClones = [];
+  const evictedSources = new Set;
+  const activeRes = activeFilePath ? path5.resolve(activeFilePath) : null;
+  const activeCan = activeFilePath ? canonicalizePath(activeFilePath) : null;
+  const isActive = (src) => {
+    if (!activeFilePath)
+      return false;
+    if (src === activeFilePath)
+      return true;
+    if (activeRes && path5.resolve(src) === activeRes)
+      return true;
+    if (activeCan && canonicalizePath(src) === activeCan)
+      return true;
+    return false;
+  };
+  const isStaleSource = (src) => {
+    if (isActive(src))
+      return false;
+    if (evictedSources.has(src))
+      return true;
+    const can = canonicalizePath(path5.isAbsolute(src) ? src : path5.resolve(currentRootDir, src));
+    const rel = path5.relative(currentRootDir, can);
+    const isInside = !rel.startsWith("..") && !path5.isAbsolute(rel);
+    if (isInside && !fsSync3.existsSync(can)) {
+      evictedSources.add(src);
+      currentIndex.removeSource(src);
+      watchedRevisions.delete(src);
+      watchedRevisions.delete(can);
+      watchedRevisions.delete(path5.resolve(src));
+      if (currentDiskCache) {
+        currentDiskCache.deleteByRelPath(rel).catch(() => {});
+      }
+      return true;
+    }
+    return false;
+  };
+  for (const clone2 of clones) {
+    const srcA = clone2.duplicationA.sourceId;
+    const srcB = clone2.duplicationB.sourceId;
+    if (isStaleSource(srcA) || isStaleSource(srcB)) {
+      continue;
+    }
+    validClones.push(clone2);
+  }
+  return validClones;
+}
 function notifyLateFindings(clones) {
   for (const clone2 of clones) {
     const srcA = clone2.duplicationA.sourceId;
@@ -13888,16 +13958,18 @@ async function handleWorkerRequest(msg) {
     }
     case "checkSnippet": {
       const { filePath, content, format } = msg.payload;
-      const clones = currentIndex.checkSnippet(filePath, content, format);
+      const rawClones = currentIndex.checkSnippet(filePath, content, format);
+      const clones = filterAndEvictStaleClones(rawClones, filePath);
       self.postMessage(createSuccessResponse(msg.id, clones));
       break;
     }
     case "checkAndUpdate": {
       const { filePath, content, format, revision = 1 } = msg.payload;
-      const clones = currentIndex.updateSource(filePath, content, format);
+      const rawClones = currentIndex.updateSource(filePath, content, format);
       const canonicalFilePath = canonicalizePath(filePath);
       const resolvedPath = path5.resolve(filePath);
       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 watchEntry = {
         revision,
@@ -13914,14 +13986,19 @@ async function handleWorkerRequest(msg) {
     }
     case "updateFile": {
       const { filePath, content, format } = msg.payload;
-      const clones = currentIndex.updateSource(filePath, content, format);
+      const rawClones = currentIndex.updateSource(filePath, content, format);
       cacheSourceShard(filePath, content);
+      const clones = filterAndEvictStaleClones(rawClones, filePath);
       self.postMessage(createSuccessResponse(msg.id, { clones }));
       break;
     }
     case "removeFile": {
       const { filePath } = msg.payload;
       currentIndex.removeSource(filePath);
+      if (currentDiskCache) {
+        const relPath = path5.isAbsolute(filePath) && currentRootDir ? path5.relative(currentRootDir, filePath) : filePath;
+        currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+      }
       self.postMessage(createSuccessResponse(msg.id, { removed: true }));
       break;
     }
@@ -13937,6 +14014,10 @@ async function handleWorkerRequest(msg) {
           } else {
             if (!getSupportedCodeFormat(fileEntry.filePath, currentOptions?.formatsExts)) {
               currentIndex.removeSource(fileEntry.filePath);
+              if (currentDiskCache) {
+                const relPath = path5.isAbsolute(fileEntry.filePath) && currentRootDir ? path5.relative(currentRootDir, fileEntry.filePath) : fileEntry.filePath;
+                currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+              }
               continue;
             }
             const stat2 = await fs3.stat(fileEntry.filePath);
@@ -13951,6 +14032,10 @@ async function handleWorkerRequest(msg) {
           }
         } catch {
           currentIndex.removeSource(fileEntry.filePath);
+          if (currentDiskCache) {
+            const relPath = path5.isAbsolute(fileEntry.filePath) && currentRootDir ? path5.relative(currentRootDir, fileEntry.filePath) : fileEntry.filePath;
+            currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+          }
         }
       }
       self.postMessage(createSuccessResponse(msg.id, { reconciledCount }));
@@ -13999,7 +14084,7 @@ async function handleWorkerRequest(msg) {
           clones = currentIndex.getClones();
         }
       } else {
-        clones = currentIndex.getClones();
+        clones = filterAndEvictStaleClones(currentIndex.getClones());
       }
       self.postMessage(createSuccessResponse(msg.id, clones));
       break;

package/package.json

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

package/src/detector-worker.ts

@@ -5,6 +5,7 @@
  */
 
 import * as crypto from "node:crypto";
+import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { IClone } from "@jscpd/core";
@@ -88,6 +89,70 @@ function areOptionsEqual(a?: WorkspaceOptions, b?: WorkspaceOptions): boolean {
 	const bFormats = b.formatsExts ? JSON.stringify(b.formatsExts) : "";
 	return aFormats === bFormats;
 }
+/**
+ * Verifies that source files involved in detected clones exist on disk.
+ * If an indexed repository source has been deleted or moved, it is evicted from currentIndex,
+ * disk cache, and watchedRevisions, and the stale clone is filtered out.
+ *
+ * activeFilePath: the file currently being queried or updated in memory (exempt from disk check).
+ */
+function filterAndEvictStaleClones(
+	clones: IClone[],
+	activeFilePath?: string,
+): IClone[] {
+	if (!currentRootDir || !fsSync.existsSync(currentRootDir)) {
+		return clones;
+	}
+
+	const validClones: IClone[] = [];
+	const evictedSources = new Set<string>();
+	const activeRes = activeFilePath ? path.resolve(activeFilePath) : null;
+	const activeCan = activeFilePath ? canonicalizePath(activeFilePath) : null;
+
+	const isActive = (src: string): boolean => {
+		if (!activeFilePath) return false;
+		if (src === activeFilePath) return true;
+		if (activeRes && path.resolve(src) === activeRes) return true;
+		if (activeCan && canonicalizePath(src) === activeCan) return true;
+		return false;
+	};
+
+	const isStaleSource = (src: string): boolean => {
+		if (isActive(src)) return false;
+		if (evictedSources.has(src)) return true;
+
+		const can = canonicalizePath(
+			path.isAbsolute(src) ? src : path.resolve(currentRootDir, src),
+		);
+		const rel = path.relative(currentRootDir, can);
+		const isInside = !rel.startsWith("..") && !path.isAbsolute(rel);
+		if (isInside && !fsSync.existsSync(can)) {
+			evictedSources.add(src);
+			currentIndex.removeSource(src);
+			watchedRevisions.delete(src);
+			watchedRevisions.delete(can);
+			watchedRevisions.delete(path.resolve(src));
+			if (currentDiskCache) {
+				currentDiskCache.deleteByRelPath(rel).catch(() => {});
+			}
+			return true;
+		}
+		return false;
+	};
+
+	for (const clone of clones) {
+		const srcA = clone.duplicationA.sourceId;
+		const srcB = clone.duplicationB.sourceId;
+
+		if (isStaleSource(srcA) || isStaleSource(srcB)) {
+			continue;
+		}
+
+		validClones.push(clone);
+	}
+
+	return validClones;
+}
 function notifyLateFindings(clones: IClone[]): void {
 	for (const clone of clones) {
 		const srcA = clone.duplicationA.sourceId;
@@ -96,7 +161,6 @@ function notifyLateFindings(clones: IClone[]): void {
 		const resB = path.resolve(srcB);
 		const canA = canonicalizePath(srcA);
 		const canB = canonicalizePath(srcB);
-
 		const isWatchedA =
 			watchedRevisions.has(srcA) ||
 			watchedRevisions.has(resA) ||
@@ -659,19 +723,22 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 
 		case "checkSnippet": {
 			const { filePath, content, format } = msg.payload;
-			const clones = currentIndex.checkSnippet(filePath, content, format);
+			const rawClones = currentIndex.checkSnippet(filePath, content, format);
+			const clones = filterAndEvictStaleClones(rawClones, filePath);
 			self.postMessage(createSuccessResponse(msg.id, clones));
 			break;
 		}
 
 		case "checkAndUpdate": {
 			const { filePath, content, format, revision = 1 } = msg.payload;
-			const clones = currentIndex.updateSource(filePath, content, format);
+			const rawClones = currentIndex.updateSource(filePath, content, format);
 			const canonicalFilePath = canonicalizePath(filePath);
 			const resolvedPath = path.resolve(filePath);
 
 			cacheSourceShard(filePath, content);
 
+			const clones = filterAndEvictStaleClones(rawClones, filePath);
+
 			const fileClones = clones.filter(
 				(c) =>
 					c.duplicationA.sourceId === filePath ||
@@ -701,8 +768,9 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 
 		case "updateFile": {
 			const { filePath, content, format } = msg.payload;
-			const clones = currentIndex.updateSource(filePath, content, format);
+			const rawClones = currentIndex.updateSource(filePath, content, format);
 			cacheSourceShard(filePath, content);
+			const clones = filterAndEvictStaleClones(rawClones, filePath);
 			self.postMessage(createSuccessResponse(msg.id, { clones }));
 			break;
 		}
@@ -710,6 +778,13 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 		case "removeFile": {
 			const { filePath } = msg.payload;
 			currentIndex.removeSource(filePath);
+			if (currentDiskCache) {
+				const relPath =
+					path.isAbsolute(filePath) && currentRootDir
+						? path.relative(currentRootDir, filePath)
+						: filePath;
+				currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+			}
 			self.postMessage(createSuccessResponse(msg.id, { removed: true }));
 			break;
 		}
@@ -732,6 +807,13 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 							)
 						) {
 							currentIndex.removeSource(fileEntry.filePath);
+							if (currentDiskCache) {
+								const relPath =
+									path.isAbsolute(fileEntry.filePath) && currentRootDir
+										? path.relative(currentRootDir, fileEntry.filePath)
+										: fileEntry.filePath;
+								currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+							}
 							continue;
 						}
 						const stat = await fs.stat(fileEntry.filePath);
@@ -745,8 +827,15 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 						}
 					}
 				} catch {
-					// If file cannot be read or no longer exists, remove from index
+					// If file cannot be read or no longer exists, remove from index and disk cache
 					currentIndex.removeSource(fileEntry.filePath);
+					if (currentDiskCache) {
+						const relPath =
+							path.isAbsolute(fileEntry.filePath) && currentRootDir
+								? path.relative(currentRootDir, fileEntry.filePath)
+								: fileEntry.filePath;
+						currentDiskCache.deleteByRelPath(relPath).catch(() => {});
+					}
 				}
 			}
 
@@ -803,7 +892,7 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 					clones = currentIndex.getClones();
 				}
 			} else {
-				clones = currentIndex.getClones();
+				clones = filterAndEvictStaleClones(currentIndex.getClones());
 			}
 
 			self.postMessage(createSuccessResponse(msg.id, clones));

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
-export const TOKENIZER_CACHE_VERSION = "4.0";
+const TOKENIZER_CACHE_VERSION = "4.0";
 
 export interface DiskCacheOptions {
 	/** Root directory of the workspace */
@@ -389,6 +389,7 @@ export class DiskCacheManager {
 	#getStmt: Statement | null = null;
 	#saveStmt: Statement | null = null;
 	#deleteStmt: Statement | null = null;
+	#deleteByRelPathStmt: Statement | null = null;
 	#totalSizeStmt: Statement | null = null;
 	#oldestShardsStmt: Statement | null = null;
 	#deleteAllStmt: Statement | null = null;
@@ -473,6 +474,9 @@ export class DiskCacheManager {
 			this.#deleteStmt = db.prepare(
 				"DELETE FROM shards WHERE rel_path = ?1 AND content_hash = ?2",
 			);
+			this.#deleteByRelPathStmt = db.prepare(
+				"DELETE FROM shards WHERE rel_path = ?1",
+			);
 			this.#totalSizeStmt = db.prepare(
 				"SELECT COALESCE(SUM(LENGTH(payload)), 0) as total FROM shards",
 			);
@@ -587,6 +591,19 @@ export class DiskCacheManager {
 			// Fail open
 		}
 	}
+	/**
+	 * Deletes all cached shards for a given relPath regardless of contentHash.
+	 */
+	async deleteByRelPath(relPath: string): Promise<void> {
+		try {
+			const db = this.#getDb();
+			if (!db || !this.#deleteByRelPathStmt) return;
+			const normalizedRelPath = relPath.replace(/\\/g, "/");
+			this.#deleteByRelPathStmt.run(normalizedRelPath);
+		} catch {
+			// Fail open
+		}
+	}
 
 	/**
 	 * Atomically saves a batch of pre-tokenized shards inside a single SQLite transaction.
@@ -721,6 +738,7 @@ export class DiskCacheManager {
 			this.#getStmt = null;
 			this.#saveStmt = null;
 			this.#deleteStmt = null;
+			this.#deleteByRelPathStmt = null;
 			this.#totalSizeStmt = null;
 			this.#oldestShardsStmt = null;
 			this.#deleteAllStmt = null;

package/src/index.ts

@@ -394,7 +394,7 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 				}
 			}
 			const { stdout: statusOut } = await execGit(
-				["status", "--porcelain", "-z", "--untracked-files=no", "--", "."],
+				["status", "--porcelain", "-z", "-uall", "--", "."],
 				cwd,
 			).catch(() => ({ stdout: "" }));
 

package/src/repo-context.ts

@@ -26,12 +26,21 @@ export interface RepositoryContext {
  */
 export function canonicalizePath(targetPath: string): string {
 	const resolved = path.resolve(targetPath);
-	try {
-		if (fsSync.existsSync(resolved)) {
-			return fsSync.realpathSync(resolved);
+	let current = resolved;
+	let suffix = "";
+	while (current && current !== path.dirname(current)) {
+		try {
+			if (fsSync.existsSync(current)) {
+				const real = fsSync.realpathSync(current);
+				return suffix ? path.join(real, suffix) : real;
+			}
+		} catch {
+			// Fall back to walking up
 		}
-	} catch {
-		// Fall back to resolved
+		suffix = suffix
+			? path.join(path.basename(current), suffix)
+			: path.basename(current);
+		current = path.dirname(current);
 	}
 	return resolved;
 }