omp-plugin-duplicate-detector 0.1.0

package/package.json

@@ -0,0 +1,105 @@
+{
+	"name": "omp-plugin-duplicate-detector",
+	"version": "0.1.0",
+	"description": "Code clone and duplication detector plugin for oh-my-pi powered by jscpd",
+	"type": "module",
+	"files": [
+		"src",
+		"dist",
+		"types",
+		"README.md"
+	],
+	"omp": {
+		"name": "duplicate-detector",
+		"description": "Detect duplicate and clone code blocks across your codebase powered by jscpd",
+		"extensions": [
+			"./src/index.ts"
+		],
+		"settings": {
+			"minLines": {
+				"type": "number",
+				"description": "Minimum consecutive lines required to report a duplicate block",
+				"default": 5
+			},
+			"minTokens": {
+				"type": "number",
+				"description": "Minimum token count threshold for code clone detection",
+				"default": 40
+			},
+			"checkOnMutation": {
+				"type": "boolean",
+				"description": "Automatically check newly written/edited code for duplicates",
+				"default": true
+			},
+			"reminderMode": {
+				"type": "enum",
+				"enum": [
+					"steer",
+					"in-band",
+					"none"
+				],
+				"description": "Feedback style: steer (live TTSR warning card & steer message), in-band (<system-reminder> on tool_result), or none",
+				"default": "steer"
+			},
+			"ignorePatterns": {
+				"type": "string",
+				"description": "Additional comma-separated glob patterns to ignore during duplicate detection",
+				"default": ""
+			},
+			"ignoreTests": {
+				"type": "boolean",
+				"description": "Automatically ignore test files, test directories, mocks, and fixtures across all programming languages",
+				"default": true
+			},
+			"maxIndexedFiles": {
+				"type": "number",
+				"description": "Maximum number of source code files to index during baseline initialization",
+				"default": 1e4
+			}
+		}
+	},
+	"scripts": {
+		"build:worker": "bun build ./src/detector-worker.ts --target=bun --outfile=./dist/detector-worker.js",
+		"test": "bun test ./test",
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"format": "biome format --write .",
+		"lint": "biome lint .",
+		"knip": "knip",
+		"check": "biome check --write . && knip",
+		"prepare": "bun run build:worker"
+	},
+	"keywords": [
+		"oh-my-pi",
+		"omp",
+		"plugin",
+		"omp-plugin",
+		"omp-extension",
+		"duplicate-detector",
+		"jscpd",
+		"code-clone",
+		"refactoring"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@jscpd/core": "^4.2.5",
+		"@jscpd/tokenizer": "^4.2.6",
+		"eventemitter3": "^5.0.4",
+		"ignore": "^7.0.6",
+		"json5": "^2.2.3",
+		"yaml": "^2.9.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "latest",
+		"@oh-my-pi/pi-coding-agent": "latest",
+		"bun-types": "latest",
+		"husky": "^9.1.7",
+		"knip": "^6.32.2",
+		"lint-staged": "^17.3.0",
+		"typescript": "^7"
+	},
+	"lint-staged": {
+		"*.{ts,js,json,jsonc,md}": [
+			"biome check --write --no-errors-on-unmatched"
+		]
+	}
+}

package/src/config-loader.ts

@@ -0,0 +1,336 @@
+import * as path from "node:path";
+import JSON5 from "json5";
+import YAML from "yaml";
+
+export interface JscpdProjectConfig {
+	sourcePath?: string;
+	sourceType?: "file" | "package.json";
+	minLines?: number;
+	maxLines?: number;
+	minTokens?: number;
+	threshold?: number;
+	ignore?: string[];
+	ignoreTests?: boolean;
+	customTestPatterns?: string[];
+	excludeTestPatterns?: string[];
+	formatsExts?: Record<string, string[]>;
+	format?: string[];
+	mode?: string;
+	crossFormats?: boolean;
+	gitignore?: boolean;
+	maxIndexedFiles?: number;
+	raw?: Record<string, unknown>;
+}
+
+/** Standard configuration file candidates in priority order */
+const JSCPD_CONFIG_CANDIDATES = [
+	".jscpd.json",
+	".jscpd.rc.json",
+	".jscpd.rc",
+	".jscpd.rc.yaml",
+	".jscpd.rc.yml",
+	".jscpd.yaml",
+	".jscpd.yml",
+	path.join(".config", ".jscpd.json"),
+	path.join(".config", "jscpd.json"),
+	"package.json",
+];
+
+/**
+ * Parses JSON5 (supporting comments, trailing commas, unquoted keys).
+ */
+export function parseJsonConfig(content: string): unknown {
+	const trimmed = content.trim();
+	if (!trimmed) return null;
+	return JSON5.parse(trimmed);
+}
+
+/**
+ * Parses YAML using the standard yaml library.
+ */
+export function parseYamlConfig(content: string): unknown {
+	const trimmed = content.trim();
+	if (!trimmed) return null;
+	return YAML.parse(trimmed);
+}
+
+/**
+ * Normalizes raw configuration dictionary (camelCase, kebab-case, or alternative jscpd keys)
+ * into a typed JscpdProjectConfig object.
+ */
+export function normalizeJscpdConfig(
+	raw: Record<string, unknown>,
+	sourcePath?: string,
+	sourceType: "file" | "package.json" = "file",
+): JscpdProjectConfig {
+	const config: JscpdProjectConfig = {
+		sourcePath,
+		sourceType,
+		raw,
+	};
+
+	// minLines / min-lines / min_lines
+	const rawMinLines = raw.minLines ?? raw["min-lines"] ?? raw.min_lines;
+	if (typeof rawMinLines === "number" && !Number.isNaN(rawMinLines)) {
+		config.minLines = Math.max(1, Math.floor(rawMinLines));
+	} else if (typeof rawMinLines === "string") {
+		const parsed = Number.parseInt(rawMinLines, 10);
+		if (!Number.isNaN(parsed)) config.minLines = Math.max(1, parsed);
+	}
+
+	// maxLines / max-lines / max_lines
+	const rawMaxLines = raw.maxLines ?? raw["max-lines"] ?? raw.max_lines;
+	if (typeof rawMaxLines === "number" && !Number.isNaN(rawMaxLines)) {
+		config.maxLines = Math.max(1, Math.floor(rawMaxLines));
+	} else if (typeof rawMaxLines === "string") {
+		const parsed = Number.parseInt(rawMaxLines, 10);
+		if (!Number.isNaN(parsed)) config.maxLines = Math.max(1, parsed);
+	}
+
+	// minTokens / min-tokens / min_tokens / tokens
+	const rawMinTokens =
+		raw.minTokens ?? raw["min-tokens"] ?? raw.min_tokens ?? raw.tokens;
+	if (typeof rawMinTokens === "number" && !Number.isNaN(rawMinTokens)) {
+		config.minTokens = Math.max(1, Math.floor(rawMinTokens));
+	} else if (typeof rawMinTokens === "string") {
+		const parsed = Number.parseInt(rawMinTokens, 10);
+		if (!Number.isNaN(parsed)) config.minTokens = Math.max(1, parsed);
+	}
+
+	// maxIndexedFiles / max-indexed-files / max_indexed_files
+	const rawMaxIndexedFiles =
+		raw.maxIndexedFiles ?? raw["max-indexed-files"] ?? raw.max_indexed_files;
+	if (
+		typeof rawMaxIndexedFiles === "number" &&
+		!Number.isNaN(rawMaxIndexedFiles)
+	) {
+		config.maxIndexedFiles = Math.max(1, Math.floor(rawMaxIndexedFiles));
+	} else if (typeof rawMaxIndexedFiles === "string") {
+		const parsed = Number.parseInt(rawMaxIndexedFiles, 10);
+		if (!Number.isNaN(parsed)) config.maxIndexedFiles = Math.max(1, parsed);
+	}
+
+	// threshold
+	const rawThreshold = raw.threshold;
+	if (typeof rawThreshold === "number" && !Number.isNaN(rawThreshold)) {
+		config.threshold = rawThreshold;
+	} else if (typeof rawThreshold === "string") {
+		const parsed = Number.parseFloat(rawThreshold);
+		if (!Number.isNaN(parsed)) config.threshold = parsed;
+	}
+
+	// ignore / ignorePatterns / ignore-patterns / ignore-pattern
+	const rawIgnore =
+		raw.ignore ??
+		raw.ignorePatterns ??
+		raw["ignore-patterns"] ??
+		raw["ignore-pattern"];
+	if (Array.isArray(rawIgnore)) {
+		config.ignore = rawIgnore
+			.filter(
+				(item): item is string | number => item !== null && item !== undefined,
+			)
+			.map(String)
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0 && s !== "null" && s !== "undefined");
+	} else if (typeof rawIgnore === "string") {
+		config.ignore = rawIgnore
+			.split(",")
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
+	}
+
+	// formatsExts / formats-exts / formats_exts
+	const rawFormatsExts =
+		raw.formatsExts ?? raw["formats-exts"] ?? raw.formats_exts;
+	if (
+		rawFormatsExts &&
+		typeof rawFormatsExts === "object" &&
+		!Array.isArray(rawFormatsExts)
+	) {
+		const formatted: Record<string, string[]> = {};
+		for (const [fmt, exts] of Object.entries(rawFormatsExts)) {
+			if (Array.isArray(exts)) {
+				formatted[fmt] = exts
+					.filter((e): e is string | number => e !== null && e !== undefined)
+					.map(String)
+					.map((e) => e.replace(/^\./, ""));
+			} else if (typeof exts === "string") {
+				formatted[fmt] = exts
+					.split(",")
+					.map((e) => e.trim().replace(/^\./, ""))
+					.filter(Boolean);
+			}
+		}
+		if (Object.keys(formatted).length > 0) {
+			config.formatsExts = formatted;
+		}
+	}
+
+	// format / formats
+	const rawFormat = raw.format ?? raw.formats;
+	if (Array.isArray(rawFormat)) {
+		config.format = rawFormat.filter(Boolean).map(String).filter(Boolean);
+	} else if (typeof rawFormat === "string") {
+		config.format = rawFormat
+			.split(",")
+			.map((s) => s.trim())
+			.filter(Boolean);
+	}
+
+	// mode
+	if (typeof raw.mode === "string") {
+		config.mode = raw.mode;
+	}
+
+	// crossFormats / cross-formats / cross_formats
+	const rawCross =
+		raw.crossFormats ?? raw["cross-formats"] ?? raw.cross_formats;
+	if (typeof rawCross === "boolean") {
+		config.crossFormats = rawCross;
+	}
+	// ignoreTests / ignore-tests / ignore_tests
+	const rawIgnoreTests =
+		raw.ignoreTests ?? raw["ignore-tests"] ?? raw.ignore_tests;
+	if (typeof rawIgnoreTests === "boolean") {
+		config.ignoreTests = rawIgnoreTests;
+	} else if (typeof rawIgnoreTests === "string") {
+		if (rawIgnoreTests.toLowerCase() === "false") config.ignoreTests = false;
+		else if (rawIgnoreTests.toLowerCase() === "true") config.ignoreTests = true;
+	}
+
+	// customTestPatterns / custom-test-patterns / testPatterns / test-patterns
+	const rawCustomTest =
+		raw.customTestPatterns ??
+		raw["custom-test-patterns"] ??
+		raw.custom_test_patterns ??
+		raw.testPatterns ??
+		raw["test-patterns"] ??
+		raw.test_patterns;
+	if (Array.isArray(rawCustomTest)) {
+		config.customTestPatterns = rawCustomTest
+			.filter(
+				(item): item is string | number => item !== null && item !== undefined,
+			)
+			.map(String)
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0 && s !== "null" && s !== "undefined");
+	} else if (typeof rawCustomTest === "string") {
+		config.customTestPatterns = rawCustomTest
+			.split(",")
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
+	}
+
+	// excludeTestPatterns / exclude-test-patterns / exclude_test_patterns
+	const rawExcludeTest =
+		raw.excludeTestPatterns ??
+		raw["exclude-test-patterns"] ??
+		raw.exclude_test_patterns;
+	if (Array.isArray(rawExcludeTest)) {
+		config.excludeTestPatterns = rawExcludeTest
+			.filter(
+				(item): item is string | number => item !== null && item !== undefined,
+			)
+			.map(String)
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0 && s !== "null" && s !== "undefined");
+	} else if (typeof rawExcludeTest === "string") {
+		config.excludeTestPatterns = rawExcludeTest
+			.split(",")
+			.map((s) => s.trim())
+			.filter((s) => s.length > 0);
+	}
+
+	// gitignore
+	const rawGitignore = raw.gitignore;
+	if (typeof rawGitignore === "boolean") {
+		config.gitignore = rawGitignore;
+	}
+
+	return config;
+}
+
+/**
+ * Asynchronously locates and loads the jscpd configuration from a target project root.
+ * Searches candidate config files in standard precedence order.
+ * Returns normalized JscpdProjectConfig or null if no config found.
+ */
+export async function findProjectJscpdConfig(
+	rootDir: string,
+): Promise<JscpdProjectConfig | null> {
+	for (const candidate of JSCPD_CONFIG_CANDIDATES) {
+		const fullPath = path.isAbsolute(candidate)
+			? candidate
+			: path.join(rootDir, candidate);
+
+		try {
+			const file = Bun.file(fullPath);
+			if (!(await file.exists())) continue;
+
+			const content = await file.text();
+			const basename = path.basename(fullPath);
+
+			if (basename === "package.json") {
+				const pkg = JSON5.parse(content) as Record<string, unknown>;
+				if (
+					pkg &&
+					typeof pkg === "object" &&
+					!Array.isArray(pkg) &&
+					"jscpd" in pkg &&
+					pkg.jscpd &&
+					typeof pkg.jscpd === "object" &&
+					!Array.isArray(pkg.jscpd)
+				) {
+					return normalizeJscpdConfig(
+						pkg.jscpd as Record<string, unknown>,
+						fullPath,
+						"package.json",
+					);
+				}
+				continue;
+			}
+
+			if (basename.endsWith(".yaml") || basename.endsWith(".yml")) {
+				const parsed = YAML.parse(content);
+				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+					return normalizeJscpdConfig(
+						parsed as Record<string, unknown>,
+						fullPath,
+						"file",
+					);
+				}
+				continue;
+			}
+
+			// JSON or .jscpd.rc (try JSON5 first, fallback to YAML)
+			try {
+				const parsed = JSON5.parse(content);
+				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+					return normalizeJscpdConfig(
+						parsed as Record<string, unknown>,
+						fullPath,
+						"file",
+					);
+				}
+			} catch {
+				const yamlParsed = YAML.parse(content);
+				if (
+					yamlParsed &&
+					typeof yamlParsed === "object" &&
+					!Array.isArray(yamlParsed)
+				) {
+					return normalizeJscpdConfig(
+						yamlParsed as Record<string, unknown>,
+						fullPath,
+						"file",
+					);
+				}
+			}
+		} catch {
+			// Ignore corrupt or unreadable candidate, continue probing
+		}
+	}
+
+	return null;
+}