omp-plugin-duplicate-detector 0.1.0 → 0.2.0

package/src/index.ts

@@ -13,7 +13,9 @@ import { DuplicateLedger } from "./duplicate-ledger";
 import {
 	type BaselineStatus,
 	createIgnoreFilter,
+	execGit,
 	isGeneratedContent,
+	isInsideGitWorkTree,
 	MAX_INDEXED_FILES,
 } from "./jscpd-engine";
 import { isProjectEnabled, setProjectEnabled } from "./project-state";
@@ -335,7 +337,105 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 	const ledger = new DuplicateLedger();
 	const fileRevisions = new Map<string, number>();
 	const coordinator = new DuplicateDetectorCoordinator();
+	let lastKnownHead: string | null = null;
 	let workerFailureNotified = false;
+
+	const reconcileParentGitState = async (cwd: string): Promise<void> => {
+		if (!isEnabledForProject) return;
+		try {
+			const isGit = await isInsideGitWorkTree(cwd);
+			if (!isGit) return;
+
+			const { stdout: currentHeadRaw } = await execGit(
+				["rev-parse", "HEAD"],
+				cwd,
+			).catch(() => ({ stdout: "" }));
+			const currentHead = currentHeadRaw.trim();
+
+			const modifiedFiles: string[] = [];
+			let reconciliationSucceeded = true;
+
+			if (lastKnownHead && currentHead && lastKnownHead !== currentHead) {
+				try {
+					const { stdout: diffOut } = await execGit(
+						[
+							"diff",
+							"--name-status",
+							"-z",
+							lastKnownHead,
+							currentHead,
+							"--",
+							".",
+						],
+						cwd,
+					);
+
+					const tokens = diffOut.split("\0");
+					let t = 0;
+					while (t < tokens.length) {
+						const status = tokens[t]?.trim();
+						t++;
+						if (!status) continue;
+						if (status.startsWith("R") || status.startsWith("C")) {
+							const oldPath = tokens[t]?.trim();
+							t++;
+							const newPath = tokens[t]?.trim();
+							t++;
+							if (oldPath) modifiedFiles.push(path.resolve(cwd, oldPath));
+							if (newPath) modifiedFiles.push(path.resolve(cwd, newPath));
+						} else {
+							const filePath = tokens[t]?.trim();
+							t++;
+							if (filePath) modifiedFiles.push(path.resolve(cwd, filePath));
+						}
+					}
+				} catch {
+					reconciliationSucceeded = false;
+				}
+			}
+			const { stdout: statusOut } = await execGit(
+				["status", "--porcelain", "-z", "--untracked-files=no", "--", "."],
+				cwd,
+			).catch(() => ({ stdout: "" }));
+
+			const statusEntries = statusOut.split("\0");
+			let i = 0;
+			while (i < statusEntries.length) {
+				const entry = statusEntries[i];
+				i++;
+				if (!entry || entry.length < 4) continue;
+				const statusCode = entry.slice(0, 2);
+				const relPath = entry.slice(3).trim();
+				if (statusCode.includes("R") && i < statusEntries.length) {
+					const oldRelPath = statusEntries[i]?.trim();
+					i++;
+					if (oldRelPath) {
+						modifiedFiles.push(path.resolve(cwd, oldRelPath));
+					}
+				}
+				if (relPath) {
+					modifiedFiles.push(path.resolve(cwd, relPath));
+				}
+			}
+			if (modifiedFiles.length > 0) {
+				const uniqueFiles = [...new Set(modifiedFiles)];
+				try {
+					await coordinator.reconcile(
+						uniqueFiles.map((filePath) => ({ filePath })),
+					);
+				} catch {
+					reconciliationSucceeded = false;
+				}
+			}
+
+			// Only advance the watermark when reconciliation succeeded
+			if (reconciliationSucceeded && currentHead) {
+				lastKnownHead = currentHead;
+			}
+		} catch {
+			// Fail open
+		}
+	};
 	const notifyWorkerFailure = (error: unknown): void => {
 		if (workerFailureNotified || !lastCtx) return;
 		workerFailureNotified = true;
@@ -473,17 +573,26 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 		ledger.clear();
 		fileRevisions.clear();
 		workerFailureNotified = false;
+		lastKnownHead = null;
 		if (ctx?.cwd) {
 			currentCwd = ctx.cwd;
+			execGit(["rev-parse", "HEAD"], ctx.cwd)
+				.then(({ stdout }) => {
+					lastKnownHead = stdout.trim() || null;
+				})
+				.catch(() => {
+					lastKnownHead = null;
+				});
 		}
 		lastCtx = ctx as ExtensionContext;
-
 		activeRawSettings = extractSettingsObject(event, ctx);
+		config = resolveConfig(activeRawSettings, null);
 		const projectConfig = ctx?.cwd
 			? await findProjectJscpdConfig(ctx.cwd)
 			: null;
-		config = resolveConfig(activeRawSettings, projectConfig);
-
+		if (projectConfig) {
+			config = resolveConfig(activeRawSettings, projectConfig);
+		}
 		if (ctx?.cwd) {
 			isEnabledForProject = await isProjectEnabled(ctx.cwd);
 			if (!isEnabledForProject) {
@@ -517,6 +626,13 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 		});
 	}
 
+	// Trigger parent git reconciliation on turn start
+	pi.on("before_agent_start", async (_event, ctx) => {
+		if (ctx?.cwd) {
+			await reconcileParentGitState(ctx.cwd);
+		}
+	});
+
 	// Initialize repository index in background on session start (non-blocking)
 	pi.on("session_start", async (event, ctx) => {
 		currentCwd = ctx.cwd;
@@ -524,14 +640,23 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 		fileRevisions.clear();
 		workerFailureNotified = false;
 
+		execGit(["rev-parse", "HEAD"], ctx.cwd)
+			.then(({ stdout }) => {
+				lastKnownHead = stdout.trim() || null;
+			})
+			.catch(() => {
+				lastKnownHead = null;
+			});
 		pi.logger.debug("Duplicate detector initializing workspace index", {
 			cwd: ctx.cwd,
 		});
 
 		activeRawSettings = extractSettingsObject(event, ctx);
+		config = resolveConfig(activeRawSettings, null);
 		const projectConfig = await findProjectJscpdConfig(ctx.cwd);
-		config = resolveConfig(activeRawSettings, projectConfig);
-
+		if (projectConfig) {
+			config = resolveConfig(activeRawSettings, projectConfig);
+		}
 		if (config.configSource) {
 			pi.logger.info("Duplicate detector loaded project configuration", {
 				source: config.configSource,
@@ -568,12 +693,14 @@ export default function duplicateDetectorExtension(pi: ExtensionAPI): void {
 			if (!isEnabledForProject) return;
 			if (!config.checkOnMutation) return;
 			if (config.reminderMode === "none") return;
+			if (event.toolName === "task" || event.toolName === "bash") {
+				await reconcileParentGitState(ctx.cwd);
+				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;
 

package/src/project-state.ts

@@ -2,10 +2,12 @@ import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getDefaultCacheDir } from "./disk-cache";
+import { resolveRepositoryContext } from "./repo-context";
 
 interface ProjectStateEntry {
 	enabled: boolean;
 	updatedAt?: string;
+	displayPath?: string;
 }
 
 export interface ProjectsStateFile {
@@ -102,9 +104,11 @@ export async function isProjectEnabled(
 	projectDir: string,
 	customCacheDir?: string,
 ): Promise<boolean> {
-	const normalized = normalizeProjectPath(projectDir);
+	const ctx = await resolveRepositoryContext(projectDir).catch(() => null);
+	const key = ctx?.repositoryKey ?? normalizeProjectPath(projectDir);
 	const state = await loadProjectsState(customCacheDir);
-	const entry = state.projects[normalized];
+	const entry =
+		state.projects[key] ?? state.projects[normalizeProjectPath(projectDir)];
 	if (entry && typeof entry.enabled === "boolean") {
 		return entry.enabled;
 	}
@@ -119,11 +123,13 @@ export async function setProjectEnabled(
 	enabled: boolean,
 	customCacheDir?: string,
 ): Promise<void> {
-	const normalized = normalizeProjectPath(projectDir);
+	const ctx = await resolveRepositoryContext(projectDir).catch(() => null);
+	const key = ctx?.repositoryKey ?? normalizeProjectPath(projectDir);
 	const state = await loadProjectsState(customCacheDir);
-	state.projects[normalized] = {
+	state.projects[key] = {
 		enabled,
 		updatedAt: new Date().toISOString(),
+		displayPath: normalizeProjectPath(projectDir),
 	};
 	await saveProjectsState(state, customCacheDir);
 }

package/src/repo-context.ts

@@ -0,0 +1,158 @@
+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 { execGit } from "./jscpd-engine";
+
+export interface RepositoryContext {
+	/** Canonical absolute workspace root (used for file enumeration and relative path calculation) */
+	workspaceRoot: string;
+	/** Whether the workspace is inside a Git repository */
+	isGit: boolean;
+	/** Canonical absolute .git directory */
+	gitDir?: string;
+	/** Canonical absolute common .git directory */
+	commonGitDir?: string;
+	/** Canonical absolute object directory defining the repository storage identity */
+	repositoryObjectDir: string;
+	/** 16-hex deterministic hash of the repository identity (used for cache DB & project state keying) */
+	repositoryKey: string;
+	/** Whether this workspace is an Oh My Pi isolated CoW worktree */
+	isOmpIsolation: boolean;
+}
+
+/**
+ * Normalizes a path by resolving symlinks if the target exists, falling back to path.resolve.
+ */
+export function canonicalizePath(targetPath: string): string {
+	const resolved = path.resolve(targetPath);
+	try {
+		if (fsSync.existsSync(resolved)) {
+			return fsSync.realpathSync(resolved);
+		}
+	} catch {
+		// Fall back to resolved
+	}
+	return resolved;
+}
+
+/**
+ * Checks if a path is located inside an Oh My Pi worktree hierarchy (~/.omp/wt/...).
+ */
+export function isOmpWorktreePath(targetPath: string): boolean {
+	const normalized = targetPath.replace(/\\/g, "/");
+	return (
+		normalized.includes("/.omp/wt/") || normalized.includes("/.omp/worktrees/")
+	);
+}
+
+/**
+ * Resolves repository context for a workspace directory.
+ * Separates workspaceRoot (file scanning and relative paths) from repositoryIdentity (cache DB keying).
+ */
+export async function resolveRepositoryContext(
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<RepositoryContext> {
+	const canonicalCwd = canonicalizePath(cwd);
+
+	try {
+		// Query Git for toplevel, git-dir, and git-common-dir in a single batch
+		const { stdout } = await execGit(
+			[
+				"rev-parse",
+				"--path-format=absolute",
+				"--show-toplevel",
+				"--git-dir",
+				"--git-common-dir",
+			],
+			canonicalCwd,
+			{ signal },
+		);
+
+		const lines = stdout
+			.split("\n")
+			.map((l) => l.trim())
+			.filter(Boolean);
+
+		const resolveEntry = (val?: string): string => {
+			if (!val) return "";
+			return path.isAbsolute(val) ? val : path.resolve(canonicalCwd, val);
+		};
+
+		const workspaceRoot = canonicalizePath(resolveEntry(lines[0]));
+		const gitDir = canonicalizePath(
+			resolveEntry(lines[1] || path.join(workspaceRoot, ".git")),
+		);
+		const commonGitDir = canonicalizePath(
+			resolveEntry(lines[2] || lines[1] || path.join(workspaceRoot, ".git")),
+		);
+
+		let repositoryObjectDir = path.join(commonGitDir, "objects");
+		const isOmpIsolation =
+			isOmpWorktreePath(workspaceRoot) || isOmpWorktreePath(canonicalCwd);
+
+		// Check for detached CoW worktrees (e.g. oh-my-pi pi-iso detachGitDir)
+		// Only replace object store identity when positively identified as an Oh My Pi CoW worktree
+		if (isOmpIsolation && gitDir === commonGitDir) {
+			const alternatesFile = path.join(gitDir, "objects", "info", "alternates");
+			try {
+				if (fsSync.existsSync(alternatesFile)) {
+					const content = await fs.readFile(alternatesFile, "utf-8");
+					const altLines = content
+						.split("\n")
+						.map((l) => l.trim())
+						.filter((l) => l && !l.startsWith("#"));
+
+					for (const line of altLines) {
+						// Git alternates paths are relative to the object directory ($GIT_DIR/objects)
+						const resolvedAlt = path.isAbsolute(line)
+							? line
+							: path.resolve(path.join(gitDir, "objects"), line);
+
+						const canonicalAlt = canonicalizePath(resolvedAlt);
+						if (fsSync.existsSync(canonicalAlt)) {
+							repositoryObjectDir = canonicalAlt;
+							break;
+						}
+					}
+				}
+			} catch {
+				// Fail open to standard commonGitDir objects
+			}
+		}
+
+		repositoryObjectDir = canonicalizePath(repositoryObjectDir);
+		const repositoryKey = crypto
+			.createHash("sha256")
+			.update(`git-object-dir\0${repositoryObjectDir}`)
+			.digest("hex")
+			.slice(0, 16);
+
+		return {
+			workspaceRoot,
+			isGit: true,
+			gitDir,
+			commonGitDir,
+			repositoryObjectDir,
+			repositoryKey,
+			isOmpIsolation,
+		};
+	} catch {
+		// Non-Git directory fallback
+		const repositoryObjectDir = path.join(canonicalCwd, ".non-git");
+		const repositoryKey = crypto
+			.createHash("sha256")
+			.update(`directory\0${canonicalCwd}`)
+			.digest("hex")
+			.slice(0, 16);
+
+		return {
+			workspaceRoot: canonicalCwd,
+			isGit: false,
+			repositoryObjectDir,
+			repositoryKey,
+			isOmpIsolation: false,
+		};
+	}
+}

package/src/source-aware-index.ts

@@ -478,7 +478,20 @@ export class SourceAwareCloneIndex {
 		let normalizedFrames: CompactSourceFrame[];
 		const shardTokens = shard.tokens;
 
-		if (shard.frames && shard.frames.length > 0) {
+		if (
+			shardTokens &&
+			shardTokens.length > 0 &&
+			(shard.minTokens !== this.#minTokens ||
+				!shard.frames ||
+				shard.frames.length === 0)
+		) {
+			normalizedFrames = reconstructFramesFromTokens(
+				shardTokens,
+				sourceId,
+				this.#minTokens,
+				this.#hashFunction,
+			);
+		} else if (shard.frames && shard.frames.length > 0) {
 			normalizedFrames = shard.frames.map((f) => {
 				if (f instanceof CompactSourceFrame && f.sourceId === sourceId) {
 					return f;