deep-slop 1.4.1

package/dist/dup-detect-DKRXM04q.js

@@ -0,0 +1,709 @@
+import { t as collectFiles } from "./discover-B_S_Fy2S.js";
+import { i as toLines, n as extractImports, r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { extname, relative } from "node:path";
+
+//#region src/engines/dup-detect/index.ts
+const IDENTICAL_BLOCK_MIN_LINES = 10;
+const SIMILARITY_THRESHOLD = .9;
+const DUPLICATE_IMPORT_MIN_FILES = 15;
+const REPEATED_CONSTANT_MIN_CHARS = 8;
+const REPEATED_CONSTANT_MIN_OCCURRENCES = 3;
+const BLOCK_OVERLAP_STEP = 5;
+const LARGE_FILE_LINE_LIMIT = 2e3;
+const FILE_BATCH_SIZE = 50;
+const COPY_PASTE_MIN_BODY_LINES = 5;
+const COPY_PASTE_NAME_WHITELIST = new Set([
+	"run",
+	"fix",
+	"constructor",
+	"get",
+	"set",
+	"init",
+	"handle",
+	"process",
+	"execute",
+	"dispose",
+	"close",
+	"open",
+	"start",
+	"stop",
+	"reset",
+	"validate"
+]);
+const SUPPORTED_EXTS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py"
+]);
+/** Build a diagnostic with common fields filled */
+function diag(opts) {
+	return {
+		filePath: opts.filePath,
+		engine: "dup-detect",
+		rule: opts.rule,
+		severity: opts.severity,
+		message: opts.message,
+		help: opts.help,
+		line: opts.line,
+		column: opts.column,
+		category: "duplication",
+		fixable: opts.fixable,
+		suggestion: opts.suggestion,
+		detail: opts.detail
+	};
+}
+/** Determine language from file extension */
+const LANG_MAP = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".py": "python"
+};
+function languageFromPath(filePath) {
+	return LANG_MAP[extname(filePath)] ?? null;
+}
+/** Normalize a line: strip leading/trailing whitespace, remove comments */
+function normalizeLine(line, lang) {
+	let trimmed = line.trim();
+	if (lang === "python") {
+		const hashIdx = trimmed.indexOf("#");
+		if (hashIdx >= 0) trimmed = trimmed.slice(0, hashIdx).trimEnd();
+	} else {
+		const slashIdx = trimmed.indexOf("//");
+		if (slashIdx >= 0) trimmed = trimmed.slice(0, slashIdx).trimEnd();
+	}
+	return trimmed;
+}
+/** Normalize a block of lines into a single string */
+function normalizeBlock(lines, lang) {
+	return lines.map((l) => normalizeLine(l, lang)).filter((l) => l.length > 0).join("\n");
+}
+/** Tokenize a line into meaningful tokens (identifiers, operators, literals) */
+function tokenizeLine(line) {
+	return line.split(/[\s{}()\[\];,.<>:=+\-*/&|!~^%]+/).filter((t) => t.length > 0);
+}
+/** Compute Jaccard similarity between two sets */
+function jaccardSimilarity(a, b) {
+	if (a.size === 0 && b.size === 0) return 1;
+	if (a.size === 0 || b.size === 0) return 0;
+	let intersection = 0;
+	for (const item of a) if (b.has(item)) intersection++;
+	const union = a.size + b.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
+/** Extract all code blocks of a given size from lines using a sliding window */
+function extractBlocks(lines, blockSize, step, filePath, lang, includeTokenSets) {
+	const blocks = [];
+	for (let i = 0; i <= lines.length - blockSize; i += step) {
+		const slice = lines.slice(i, i + blockSize);
+		const rawLines = slice.map((l) => l.text);
+		const normalizedText = normalizeBlock(rawLines, lang);
+		if (normalizedText.length < 10) continue;
+		let tokenSet;
+		if (includeTokenSets) {
+			tokenSet = /* @__PURE__ */ new Set();
+			for (const line of rawLines) {
+				const normalized = normalizeLine(line, lang);
+				if (normalized.length > 0) for (const tok of tokenizeLine(normalized)) tokenSet.add(tok);
+			}
+		}
+		blocks.push({
+			filePath,
+			startLine: slice[0].num,
+			endLine: slice[slice.length - 1].num,
+			normalizedText,
+			tokenSet
+		});
+	}
+	return blocks;
+}
+/** Extract function definitions using regex (JS/TS/Python) */
+function extractFunctions(content, filePath, lang) {
+	const lines = toLines(content);
+	const functions = [];
+	if (lang === "typescript" || lang === "javascript") {
+		const funcStartRe = /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/;
+		const arrowFuncRe = /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/;
+		const methodRe = /^\s*(?:(?:public|private|protected|static|async|abstract)\s+)*(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\{/;
+		for (let i = 0; i < lines.length; i++) {
+			const { num, text } = lines[i];
+			const trimmed = text.trim();
+			let funcName = null;
+			const funcMatch = trimmed.match(funcStartRe);
+			const arrowMatch = trimmed.match(arrowFuncRe);
+			const methodMatch = trimmed.match(methodRe);
+			if (funcMatch) funcName = funcMatch[1];
+			else if (arrowMatch) funcName = arrowMatch[1];
+			else if (methodMatch && !trimmed.startsWith("if") && !trimmed.startsWith("for") && !trimmed.startsWith("while") && !trimmed.startsWith("switch") && !trimmed.startsWith("catch") && !trimmed.startsWith("class") && !trimmed.startsWith("constructor")) funcName = methodMatch[1];
+			if (funcName) {
+				const { endLine, bodyLines } = extractBraceBody(lines, i);
+				const bodyLineCount = bodyLines.filter((l) => l.trim().length > 0).length;
+				const bodyNormalized = bodyLines.map((l) => normalizeLine(l, lang)).filter((l) => l.length > 0).join("\n");
+				if (bodyNormalized.length > 20) functions.push({
+					filePath,
+					name: funcName,
+					startLine: num,
+					endLine,
+					bodyLineCount,
+					bodyNormalized
+				});
+			}
+		}
+	}
+	if (lang === "python") {
+		const defRe = /^\s*def\s+(\w+)\s*\(/;
+		for (let i = 0; i < lines.length; i++) {
+			const { num, text } = lines[i];
+			const match = text.match(defRe);
+			if (match) {
+				const funcName = match[1];
+				const { endLine, bodyLines } = extractPythonBody(lines, i);
+				const bodyLineCount = bodyLines.filter((l) => l.trim().length > 0).length;
+				const bodyNormalized = bodyLines.map((l) => normalizeLine(l, lang)).filter((l) => l.length > 0).join("\n");
+				if (bodyNormalized.length > 20) functions.push({
+					filePath,
+					name: funcName,
+					startLine: num,
+					endLine,
+					bodyLineCount,
+					bodyNormalized
+				});
+			}
+		}
+	}
+	return functions;
+}
+/** Extract brace-delimited body from JS/TS starting at given line index */
+function extractBraceBody(lines, startIdx) {
+	let depth = 0;
+	let started = false;
+	const bodyLines = [];
+	let endLine = lines[startIdx].num;
+	for (let i = startIdx; i < lines.length; i++) {
+		const text = lines[i].text;
+		for (const ch of text) if (ch === "{") {
+			depth++;
+			started = true;
+		} else if (ch === "}") {
+			depth--;
+			if (started && depth === 0) {
+				endLine = lines[i].num;
+				return {
+					endLine,
+					bodyLines
+				};
+			}
+		}
+		if (started && i > startIdx) bodyLines.push(text);
+		endLine = lines[i].num;
+	}
+	return {
+		endLine,
+		bodyLines
+	};
+}
+/** Extract indented body from Python starting at given line index */
+function extractPythonBody(lines, startIdx) {
+	const defLine = lines[startIdx].text;
+	const defIndent = defLine.length - defLine.trimStart().length;
+	const bodyLines = [];
+	let endLine = lines[startIdx].num;
+	for (let i = startIdx + 1; i < lines.length; i++) {
+		const text = lines[i].text;
+		const trimmed = text.trim();
+		if (trimmed.length === 0) {
+			bodyLines.push(text);
+			continue;
+		}
+		if (text.length - text.trimStart().length <= defIndent && trimmed.length > 0) break;
+		bodyLines.push(text);
+		endLine = lines[i].num;
+	}
+	return {
+		endLine,
+		bodyLines
+	};
+}
+/** Extract named import symbols from raw import text */
+function extractNamedSymbols(raw, lang) {
+	if (lang === "typescript" || lang === "javascript") {
+		const namedMatch = raw.match(/\{([^}]+)\}/);
+		if (namedMatch) return namedMatch[1].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter((s) => s.length > 0);
+		const defaultMatch = raw.match(/^import\s+(?:type\s+)?(\w+)\s+from/);
+		if (defaultMatch) return [defaultMatch[1]];
+		const nsMatch = raw.match(/^import\s+\*\s+as\s+(\w+)\s+from/);
+		if (nsMatch) return [nsMatch[1]];
+	}
+	if (lang === "python") {
+		const fromMatch = raw.match(/^from\s+[^\s]+\s+import\s+(.+)/);
+		if (fromMatch) return fromMatch[1].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter((s) => s.length > 0);
+		const importMatch = raw.match(/^import\s+(.+)/);
+		if (importMatch) return importMatch[1].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter((s) => s.length > 0);
+	}
+	return [];
+}
+/** Extract string literals from a line */
+function extractStringLiterals(line, lang) {
+	const results = [];
+	if (lang === "python") {
+		const stringRe = /(?<!\\)(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/g;
+		let m;
+		while ((m = stringRe.exec(line)) !== null) {
+			const value = m[1] ?? m[2] ?? "";
+			const col = m.index + 1;
+			if (value.length >= REPEATED_CONSTANT_MIN_CHARS) results.push({
+				value,
+				col
+			});
+		}
+	} else {
+		const stringRe = /(?<!\\)(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/g;
+		let m;
+		while ((m = stringRe.exec(line)) !== null) {
+			const value = m[1] ?? m[2] ?? "";
+			const col = m.index + 1;
+			if (value.length >= REPEATED_CONSTANT_MIN_CHARS) results.push({
+				value,
+				col
+			});
+		}
+		const templateRe = /`((?:[^`\\]|\\.)*)`/g;
+		while ((m = templateRe.exec(line)) !== null) {
+			const value = m[1] ?? "";
+			const col = m.index + 1;
+			if (value.length >= REPEATED_CONSTANT_MIN_CHARS && !value.includes("${")) results.push({
+				value,
+				col
+			});
+		}
+	}
+	return results;
+}
+/** Check if a string looks like a meaningful constant (not a URL, path, import, etc.) */
+function isConstantCandidate(value) {
+	if (/^https?:\/\//.test(value)) return false;
+	if (/^\/|^\.\.?\//.test(value)) return false;
+	if (/^\d+$/.test(value)) return false;
+	if (/^[.\[]/.test(value)) return false;
+	if (/^node_modules/.test(value)) return false;
+	if (/^[@a-z0-9][-a-z0-9.]*\/[-a-z0-9.@/]*$/i.test(value)) return false;
+	if (/^[a-z][-a-z0-9]{1,20}$/.test(value) && value.length <= 20) return false;
+	if (/\bimport\b|\bfrom\b|\brequire\b/.test(value)) return false;
+	if (/^\.[a-z]{1,4}$/.test(value)) return false;
+	return true;
+}
+function detectIdenticalBlocks(allBlocks, rootDir) {
+	const diagnostics = [];
+	const groups = /* @__PURE__ */ new Map();
+	for (const block of allBlocks) {
+		let group = groups.get(block.normalizedText);
+		if (!group) {
+			group = [];
+			groups.set(block.normalizedText, group);
+		}
+		group.push(block);
+	}
+	for (const [, group] of groups) {
+		const uniqueFiles = new Set(group.map((b) => b.filePath));
+		if (group.length < 2 || uniqueFiles.size < 2) continue;
+		const merged = mergeOverlappingBlocks(group);
+		if (merged.length < 2) continue;
+		const reportedPairs = /* @__PURE__ */ new Set();
+		for (let i = 0; i < merged.length; i++) for (let j = i + 1; j < merged.length; j++) {
+			const a = merged[i];
+			const b = merged[j];
+			if (a.filePath === b.filePath) continue;
+			const pairKey = a.filePath < b.filePath ? `${a.filePath}:${a.startLine}-${a.endLine}|${b.filePath}:${b.startLine}-${b.endLine}` : `${b.filePath}:${b.startLine}-${b.endLine}|${a.filePath}:${a.startLine}-${a.endLine}`;
+			if (reportedPairs.has(pairKey)) continue;
+			reportedPairs.add(pairKey);
+			const relA = relative(rootDir, a.filePath);
+			const relB = relative(rootDir, b.filePath);
+			diagnostics.push(diag({
+				filePath: relA,
+				rule: "dup-detect/identical-block",
+				severity: "warning",
+				message: `Identical code block (${a.endLine - a.startLine + 1} lines) duplicated in ${relB}:${b.startLine}`,
+				help: "Extract the duplicated block into a shared utility function or module to reduce maintenance burden.",
+				line: a.startLine,
+				column: 1,
+				fixable: false,
+				suggestion: {
+					type: "refactor",
+					text: `Extract shared logic from ${relA}:${a.startLine}-${a.endLine} and ${relB}:${b.startLine}-${b.endLine} into a common utility.`,
+					confidence: .85,
+					reason: "Identical code blocks across files indicate copy-paste duplication that should be consolidated."
+				},
+				detail: {
+					duplicateLocations: [{
+						file: relA,
+						startLine: a.startLine,
+						endLine: a.endLine
+					}, {
+						file: relB,
+						startLine: b.startLine,
+						endLine: b.endLine
+					}],
+					lineCount: a.endLine - a.startLine + 1
+				}
+			}));
+		}
+	}
+	return diagnostics;
+}
+/** Merge overlapping blocks within each file into single regions.
+*  Two blocks overlap if they share >50% of their lines. */
+function mergeOverlappingBlocks(blocks) {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const b of blocks) {
+		let arr = byFile.get(b.filePath);
+		if (!arr) {
+			arr = [];
+			byFile.set(b.filePath, arr);
+		}
+		arr.push(b);
+	}
+	const result = [];
+	for (const [, fileBlocks] of byFile) {
+		if (fileBlocks.length === 0) continue;
+		fileBlocks.sort((a, b) => a.startLine - b.startLine);
+		const merged = [{ ...fileBlocks[0] }];
+		for (let i = 1; i < fileBlocks.length; i++) {
+			const block = fileBlocks[i];
+			const last = merged[merged.length - 1];
+			const overlapStart = Math.max(block.startLine, last.startLine);
+			const overlapEnd = Math.min(block.endLine, last.endLine);
+			const overlapLines = Math.max(0, overlapEnd - overlapStart + 1);
+			const blockLines = block.endLine - block.startLine + 1;
+			const lastLines = last.endLine - last.startLine + 1;
+			if (overlapLines > blockLines * .5 || overlapLines > lastLines * .5) last.endLine = Math.max(last.endLine, block.endLine);
+			else merged.push({ ...block });
+		}
+		result.push(...merged);
+	}
+	return result;
+}
+function detectSimilarBlocks(allBlocks, rootDir) {
+	const diagnostics = [];
+	const reported = /* @__PURE__ */ new Set();
+	const blocksWithTokens = allBlocks.filter((b) => b.tokenSet);
+	if (blocksWithTokens.length === 0) return diagnostics;
+	const byFile = /* @__PURE__ */ new Map();
+	for (const block of blocksWithTokens) {
+		let arr = byFile.get(block.filePath);
+		if (!arr) {
+			arr = [];
+			byFile.set(block.filePath, arr);
+		}
+		arr.push(block);
+	}
+	const files = [...byFile.keys()];
+	const normalizedKeys = /* @__PURE__ */ new Map();
+	for (const block of blocksWithTokens) normalizedKeys.set(block, block.normalizedText);
+	for (let fi = 0; fi < files.length; fi++) for (let fj = fi + 1; fj < files.length; fj++) {
+		const blocksA = byFile.get(files[fi]);
+		const blocksB = byFile.get(files[fj]);
+		for (const a of blocksA) for (const b of blocksB) {
+			if (normalizedKeys.get(a) === normalizedKeys.get(b)) continue;
+			const similarity = jaccardSimilarity(a.tokenSet, b.tokenSet);
+			if (similarity >= SIMILARITY_THRESHOLD) {
+				const key = [
+					a.filePath,
+					a.startLine,
+					b.filePath,
+					b.startLine
+				].sort().join(":");
+				if (reported.has(key)) continue;
+				reported.add(key);
+				const relA = relative(rootDir, a.filePath);
+				const relB = relative(rootDir, b.filePath);
+				const pct = Math.round(similarity * 100);
+				diagnostics.push(diag({
+					filePath: relA,
+					rule: "dup-detect/similar-block",
+					severity: "info",
+					message: `Similar code block (${pct}% token overlap) found in ${relB}:${b.startLine}`,
+					help: "Consider extracting shared logic into a common utility. Similar blocks often diverge over time, creating maintenance issues.",
+					line: a.startLine,
+					column: 1,
+					fixable: false,
+					suggestion: {
+						type: "refactor",
+						text: `Extract shared logic from ${relA}:${a.startLine}-${a.endLine} and ${relB}:${b.startLine}-${b.endLine} into a parameterized utility.`,
+						confidence: .6,
+						reason: `Jaccard similarity of ${pct}% suggests substantial code overlap that could be consolidated.`
+					},
+					detail: {
+						similarity: pct,
+						duplicateLocations: [{
+							file: relA,
+							startLine: a.startLine,
+							endLine: a.endLine
+						}, {
+							file: relB,
+							startLine: b.startLine,
+							endLine: b.endLine
+						}]
+					}
+				}));
+			}
+		}
+	}
+	return diagnostics;
+}
+function detectDuplicateImports(allImports, rootDir) {
+	const diagnostics = [];
+	const byModule = /* @__PURE__ */ new Map();
+	for (const imp of allImports) {
+		let arr = byModule.get(imp.source);
+		if (!arr) {
+			arr = [];
+			byModule.set(imp.source, arr);
+		}
+		arr.push(imp);
+	}
+	for (const [source, occurrences] of byModule) {
+		const uniqueFiles = new Set(occurrences.map((o) => o.filePath));
+		if (uniqueFiles.size < DUPLICATE_IMPORT_MIN_FILES) continue;
+		const symbolCounts = /* @__PURE__ */ new Map();
+		for (const occ of occurrences) for (const sym of occ.symbols) symbolCounts.set(sym, (symbolCounts.get(sym) ?? 0) + 1);
+		const threshold = uniqueFiles.size * .3;
+		const commonSymbols = [];
+		for (const [sym, count] of symbolCounts) if (count >= threshold) commonSymbols.push(sym);
+		commonSymbols.sort();
+		if (commonSymbols.length === 0) continue;
+		const representative = occurrences[0];
+		const relPath = relative(rootDir, representative.filePath);
+		diagnostics.push(diag({
+			filePath: relPath,
+			rule: "dup-detect/duplicate-import-across-files",
+			severity: "info",
+			message: `Module "${source}" imported in ${uniqueFiles.size} files with common symbols: ${commonSymbols.join(", ")}`,
+			help: `Create a shared re-export (barrel) file for "${source}" that re-exports the common symbols, then import from the barrel in each consumer.`,
+			line: representative.line,
+			column: 1,
+			fixable: false,
+			suggestion: {
+				type: "refactor",
+				text: `Create a barrel file (e.g., shared/${source.replace(/[/@]/g, "_")}.ts) with:\nexport { ${commonSymbols.join(", ")} } from "${source}";`,
+				confidence: .7,
+				reason: `${uniqueFiles.size} files import the same common symbols from "${source}". A barrel file reduces duplication and simplifies future refactoring.`
+			},
+			detail: {
+				module: source,
+				fileCount: uniqueFiles.size,
+				commonSymbols,
+				files: [...uniqueFiles].map((f) => relative(rootDir, f))
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectRepeatedConstants(allStrings, rootDir) {
+	const diagnostics = [];
+	const byValue = /* @__PURE__ */ new Map();
+	for (const occ of allStrings) {
+		if (!isConstantCandidate(occ.value)) continue;
+		let arr = byValue.get(occ.value);
+		if (!arr) {
+			arr = [];
+			byValue.set(occ.value, arr);
+		}
+		arr.push(occ);
+	}
+	for (const [value, occurrences] of byValue) {
+		if (occurrences.length < REPEATED_CONSTANT_MIN_OCCURRENCES) continue;
+		const uniqueFiles = new Set(occurrences.map((o) => o.filePath));
+		if (uniqueFiles.size < REPEATED_CONSTANT_MIN_OCCURRENCES) continue;
+		const first = occurrences[0];
+		const relPath = relative(rootDir, first.filePath);
+		const locations = occurrences.slice(0, 10).map((o) => ({
+			file: relative(rootDir, o.filePath),
+			line: o.line,
+			column: o.col
+		}));
+		const suggestedName = toConstantName(value);
+		diagnostics.push(diag({
+			filePath: relPath,
+			rule: "dup-detect/repeated-constant",
+			severity: "warning",
+			message: `String "${value.length > 40 ? value.slice(0, 40) + "..." : value}" repeated ${occurrences.length} times across ${uniqueFiles.size} files`,
+			help: `Extract this string to a shared constant (e.g., ${suggestedName}) to avoid duplication and ensure consistency.`,
+			line: first.line,
+			column: first.col,
+			fixable: false,
+			suggestion: {
+				type: "refactor",
+				text: `export const ${suggestedName} = "${value.replace(/"/g, "\\\"")}";`,
+				confidence: .75,
+				reason: `The same string literal appears ${occurrences.length} times. Extracting it to a named constant improves maintainability and prevents typos.`
+			},
+			detail: {
+				value,
+				count: occurrences.length,
+				fileCount: uniqueFiles.size,
+				locations
+			}
+		}));
+	}
+	return diagnostics;
+}
+/** Convert a string value to a SCREAMING_SNAKE_CASE constant name */
+function toConstantName(value) {
+	const words = value.replace(/[^a-zA-Z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 0 && !/^\d+$/.test(w)).slice(0, 4);
+	if (words.length === 0) return "SHARED_CONSTANT";
+	return words.map((w) => w.toUpperCase()).join("_");
+}
+function detectCopyPasteFunctions(allFunctions, rootDir) {
+	const diagnostics = [];
+	const filtered = allFunctions.filter((fn) => !COPY_PASTE_NAME_WHITELIST.has(fn.name) && fn.bodyLineCount > COPY_PASTE_MIN_BODY_LINES);
+	const bodyGroups = /* @__PURE__ */ new Map();
+	for (const fn of filtered) {
+		let arr = bodyGroups.get(fn.bodyNormalized);
+		if (!arr) {
+			arr = [];
+			bodyGroups.set(fn.bodyNormalized, arr);
+		}
+		arr.push(fn);
+	}
+	for (const [, group] of bodyGroups) {
+		const uniqueNames = new Set(group.map((f) => f.name));
+		if (group.length < 2 || uniqueNames.size < 2) continue;
+		for (let i = 0; i < group.length; i++) for (let j = i + 1; j < group.length; j++) {
+			const a = group[i];
+			const b = group[j];
+			if (a.name === b.name) continue;
+			const relA = relative(rootDir, a.filePath);
+			const relB = relative(rootDir, b.filePath);
+			diagnostics.push(diag({
+				filePath: relA,
+				rule: "dup-detect/copy-paste-function",
+				severity: "warning",
+				message: `Function "${a.name}" (${relA}:${a.startLine}) has identical body to "${b.name}" (${relB}:${b.startLine})`,
+				help: "Extract the shared logic into a single utility function and call it from both locations, parameterizing any differences.",
+				line: a.startLine,
+				column: 1,
+				fixable: false,
+				suggestion: {
+					type: "refactor",
+					text: `Extract shared logic from "${a.name}" and "${b.name}" into a single utility function, parameterizing any behavioral differences.`,
+					confidence: .9,
+					reason: "Functions with identical bodies but different names are classic copy-paste duplication. This creates maintenance risk — fixes must be applied in multiple places."
+				},
+				detail: { duplicateLocations: [{
+					file: relA,
+					name: a.name,
+					startLine: a.startLine,
+					endLine: a.endLine
+				}, {
+					file: relB,
+					name: b.name,
+					startLine: b.startLine,
+					endLine: b.endLine
+				}] }
+			}));
+		}
+	}
+	return diagnostics;
+}
+const dupDetectEngine = {
+	name: "dup-detect",
+	description: "Structural duplicate detection: identical blocks, similar blocks, duplicate imports, repeated constants, copy-paste functions",
+	supportedLanguages: [
+		"typescript",
+		"javascript",
+		"python"
+	],
+	async run(context) {
+		const start = performance.now();
+		const diagnostics = [];
+		if (!context.languages.some((l) => this.supportedLanguages.includes(l))) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No supported languages detected (need typescript, javascript, or python)"
+		};
+		const enableSimilarBlocks = process.env.DEEPSLOP_SIMILAR_BLOCKS === "1";
+		const targetFiles = (await collectFiles(context.rootDirectory, context.languages, context.config.exclude, context.files)).filter((f) => SUPPORTED_EXTS.has(extname(f)));
+		if (targetFiles.length === 0) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No supported files found to scan"
+		};
+		const allBlocks = [];
+		const allImports = [];
+		const allStrings = [];
+		const allFunctions = [];
+		for (let batchStart = 0; batchStart < targetFiles.length; batchStart += FILE_BATCH_SIZE) {
+			const batch = targetFiles.slice(batchStart, batchStart + FILE_BATCH_SIZE);
+			for (const filePath of batch) {
+				let content;
+				try {
+					content = await readFileContent(filePath);
+				} catch {
+					continue;
+				}
+				const lines = toLines(content);
+				const lang = languageFromPath(filePath);
+				if (!(lines.length > LARGE_FILE_LINE_LIMIT)) {
+					const blocks = extractBlocks(lines, IDENTICAL_BLOCK_MIN_LINES, BLOCK_OVERLAP_STEP, filePath, lang, enableSimilarBlocks);
+					allBlocks.push(...blocks);
+				}
+				const imports = extractImports(content, lang ?? "typescript");
+				for (const imp of imports) {
+					const symbols = extractNamedSymbols(imp.raw, lang);
+					allImports.push({
+						filePath,
+						line: imp.line,
+						source: imp.source,
+						symbols
+					});
+				}
+				for (const line of lines) {
+					const literals = extractStringLiterals(line.text, lang);
+					for (const lit of literals) allStrings.push({
+						filePath,
+						line: line.num,
+						col: lit.col,
+						value: lit.value
+					});
+				}
+				const functions = extractFunctions(content, filePath, lang);
+				allFunctions.push(...functions);
+				content = "";
+			}
+		}
+		const identicalDiags = detectIdenticalBlocks(allBlocks, context.rootDirectory);
+		diagnostics.push(...identicalDiags);
+		if (enableSimilarBlocks) {
+			if (new Set(allBlocks.map((b) => b.filePath)).size >= 2) {
+				const similarDiags = detectSimilarBlocks(allBlocks, context.rootDirectory);
+				diagnostics.push(...similarDiags);
+			}
+		}
+		const importDiags = detectDuplicateImports(allImports, context.rootDirectory);
+		diagnostics.push(...importDiags);
+		const constantDiags = detectRepeatedConstants(allStrings, context.rootDirectory);
+		diagnostics.push(...constantDiags);
+		const funcDiags = detectCopyPasteFunctions(allFunctions, context.rootDirectory);
+		diagnostics.push(...funcDiags);
+		return {
+			engine: this.name,
+			diagnostics,
+			elapsed: performance.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { dupDetectEngine };