omp-plugin-duplicate-detector 0.1.1 → 0.2.1

package/package.json

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

package/src/coordinator.ts

@@ -473,15 +473,19 @@ export class DuplicateDetectorCoordinator extends EventEmitter<CoordinatorEvents
 	/**
 	 * Reconcile multiple modified or removed files with the index.
 	 */
-	async reconcile(files: ReconcileFileEntry[]): Promise<void> {
+	async reconcile(
+		files: ReconcileFileEntry[],
+	): Promise<{ reconciledCount: number }> {
 		try {
 			const payload: ReconcilePayload = { files };
-			await this.#sendRequest<{ reconciledCount: number }>(
+			return await this.#sendRequest<{ reconciledCount: number }>(
 				"reconcile",
 				payload,
 			);
 		} catch (err) {
-			this.emit("error", err instanceof Error ? err : new Error(String(err)));
+			const error = err instanceof Error ? err : new Error(String(err));
+			this.emit("error", error);
+			throw error;
 		}
 	}
 

package/src/detector-worker.ts

@@ -5,10 +5,11 @@
  */
 
 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";
-import { DiskCacheManager } from "./disk-cache";
+import { cleanupLegacyCacheFiles, DiskCacheManager } from "./disk-cache";
 import {
 	type BaselineStatus,
 	createIgnoreFilter,
@@ -22,6 +23,7 @@ import {
 	MAX_INDEXED_FILES,
 	MAX_TOTAL_SOURCE_BYTES,
 } from "./jscpd-engine";
+import { canonicalizePath, resolveRepositoryContext } from "./repo-context";
 import {
 	type SerializedSourceShard,
 	SourceAwareCloneIndex,
@@ -87,24 +89,100 @@ 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;
 		const srcB = clone.duplicationB.sourceId;
 		const resA = path.resolve(srcA);
 		const resB = path.resolve(srcB);
-
-		const isWatchedA = watchedRevisions.has(srcA) || watchedRevisions.has(resA);
-		const isWatchedB = watchedRevisions.has(srcB) || watchedRevisions.has(resB);
+		const canA = canonicalizePath(srcA);
+		const canB = canonicalizePath(srcB);
+		const isWatchedA =
+			watchedRevisions.has(srcA) ||
+			watchedRevisions.has(resA) ||
+			watchedRevisions.has(canA);
+		const isWatchedB =
+			watchedRevisions.has(srcB) ||
+			watchedRevisions.has(resB) ||
+			watchedRevisions.has(canB);
 
 		if (isWatchedA || isWatchedB) {
 			if (isWatchedA) {
-				const entry = watchedRevisions.get(srcA) ?? watchedRevisions.get(resA);
+				const entry =
+					watchedRevisions.get(srcA) ??
+					watchedRevisions.get(resA) ??
+					watchedRevisions.get(canA);
 				if (entry) entry.lastKnownCloneCount++;
 			}
 			if (isWatchedB) {
-				const entry = watchedRevisions.get(srcB) ?? watchedRevisions.get(resB);
+				const entry =
+					watchedRevisions.get(srcB) ??
+					watchedRevisions.get(resB) ??
+					watchedRevisions.get(canB);
 				if (entry) entry.lastKnownCloneCount++;
 			}
 			self.postMessage(createLateFindingEvent(clone));
@@ -307,6 +385,10 @@ async function runBaselineIndexing(
 			if (signal.aborted) return { indexedCount, status: "cancelled" };
 
 			// Ingest items into index and notify late findings
+			const shardsToSave: Array<{
+				shard: SerializedSourceShard;
+				relPath: string;
+			}> = [];
 			for (const item of fileItems) {
 				if (!item) continue;
 
@@ -323,9 +405,10 @@ async function runBaselineIndexing(
 					newClones = currentIndex.hydrateSourceShard(item.cachedShard);
 					if (item.isNewlyTokenized) {
 						if (currentDiskCache && item.contentHash && item.relPath) {
-							currentDiskCache
-								.saveShard(item.cachedShard, item.relPath)
-								.catch(() => {});
+							shardsToSave.push({
+								shard: item.cachedShard,
+								relPath: item.relPath,
+							});
 						}
 					} else {
 						cachedCount++;
@@ -338,7 +421,7 @@ async function runBaselineIndexing(
 							item.contentHash,
 						);
 						if (shard) {
-							currentDiskCache.saveShard(shard, item.relPath).catch(() => {});
+							shardsToSave.push({ shard, relPath: item.relPath });
 						}
 					}
 				}
@@ -350,6 +433,10 @@ async function runBaselineIndexing(
 				}
 			}
 
+			if (shardsToSave.length > 0 && currentDiskCache) {
+				await currentDiskCache.saveShards(shardsToSave);
+			}
+
 			const processedCount = Math.min(i + batch.length, totalFiles);
 			const percentage =
 				totalFiles > 0 ? Math.round((processedCount / totalFiles) * 100) : 100;
@@ -543,11 +630,12 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 	switch (msg.type) {
 		case "openWorkspace": {
 			const { rootDir, options } = msg.payload;
+			const canonicalRootDir = canonicalizePath(rootDir);
 
-			// If rootDir === currentRootDir and options match and baseline is already complete or indexing,
+			// If canonicalRootDir === currentRootDir and options match and baseline is already complete or indexing,
 			// avoid total reset; trigger an incremental git status check instead.
 			if (
-				currentRootDir === rootDir &&
+				(currentRootDir === canonicalRootDir || currentRootDir === rootDir) &&
 				areOptionsEqual(currentOptions, options) &&
 				(isBaselineComplete || isBaselineIndexing)
 			) {
@@ -557,14 +645,14 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 					}
 					activeAbortController = new AbortController();
 					const recResult = await runIncrementalGitReconciliation(
-						rootDir,
+						currentRootDir,
 						options,
 						activeAbortController.signal,
 					);
 					self.postMessage(
 						createSuccessResponse(msg.id, {
 							started: true,
-							rootDir,
+							rootDir: currentRootDir,
 							reused: true,
 							indexedCount: recResult.indexedCount,
 							status: recResult.status,
@@ -574,7 +662,7 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 					self.postMessage(
 						createSuccessResponse(msg.id, {
 							started: true,
-							rootDir,
+							rootDir: currentRootDir,
 							reused: true,
 							indexedCount: currentIndex.stats().sourceCount,
 							status: "complete" as BaselineStatus,
@@ -594,11 +682,17 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 				currentDiskCache = null;
 			}
 
-			currentRootDir = rootDir;
+			const repoContext = await resolveRepositoryContext(
+				rootDir,
+				activeAbortController.signal,
+			);
+			const effectiveRoot = repoContext.workspaceRoot;
+			currentRootDir = effectiveRoot;
 			currentOptions = options;
 			currentIndex = new SourceAwareCloneIndex(options);
 			currentDiskCache = new DiskCacheManager({
-				rootDir,
+				rootDir: effectiveRoot,
+				repositoryKey: repoContext.repositoryKey,
 				cacheDir: options?.cacheDir,
 				config: options,
 				maxBytes: options?.maxCacheBytes,
@@ -607,41 +701,52 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 			isBaselineIndexing = true;
 			isBaselineComplete = false;
 
+			// Clean up legacy pre-v4 caches in background
+			cleanupLegacyCacheFiles(options?.cacheDir).catch(() => {});
+
 			self.postMessage(
 				createSuccessResponse(msg.id, {
 					started: true,
-					rootDir,
+					rootDir: effectiveRoot,
 					reused: false,
 				}),
 			);
 
 			// Run background indexing task (posts complete event when finished)
-			runBaselineIndexing(rootDir, options, activeAbortController.signal).catch(
-				() => {},
-			);
+			runBaselineIndexing(
+				effectiveRoot,
+				options,
+				activeAbortController.signal,
+			).catch(() => {});
 			break;
 		}
 
 		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 ||
 					c.duplicationB.sourceId === filePath ||
 					path.resolve(c.duplicationA.sourceId) === resolvedPath ||
-					path.resolve(c.duplicationB.sourceId) === resolvedPath,
+					path.resolve(c.duplicationB.sourceId) === resolvedPath ||
+					canonicalizePath(c.duplicationA.sourceId) === canonicalFilePath ||
+					canonicalizePath(c.duplicationB.sourceId) === canonicalFilePath,
 			);
 
 			const watchEntry = {
@@ -650,10 +755,11 @@ async function handleWorkerRequest(msg: WorkerRequestMessage): Promise<void> {
 			};
 			watchedRevisions.set(filePath, watchEntry);
 			watchedRevisions.set(resolvedPath, watchEntry);
+			watchedRevisions.set(canonicalFilePath, watchEntry);
 
 			self.postMessage(
 				createSuccessResponse(msg.id, {
-					clones,
+					clones: fileClones,
 					isComplete: isBaselineComplete,
 				}),
 			);
@@ -662,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;
 		}
@@ -671,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;
 		}
@@ -693,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);
@@ -706,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(() => {});
+					}
 				}
 			}
 
@@ -764,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));