deep-slop 1.4.1

package/dist/index.js

@@ -0,0 +1,1030 @@
+import { n as detectFrameworks, r as detectLanguages, t as collectFiles } from "./discover-B_S_Fy2S.js";
+import { performance } from "node:perf_hooks";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+
+//#region src/config/defaults.ts
+/** Default configuration matching the canonical values */
+const DEFAULT_CONFIG = {
+	engines: {
+		"ast-slop": true,
+		"import-intelligence": true,
+		"dead-flow": true,
+		"type-safety": true,
+		"syntax-deep": true,
+		"security-deep": true,
+		"arch-constraints": true,
+		"dup-detect": true,
+		"perf-hints": true,
+		"i18n-lint": true,
+		"config-lint": true,
+		"meta-quality": true,
+		"arch-rules": true,
+		"lint-external": true,
+		"knip": true,
+		"format-lint": true,
+		"framework-lint": true,
+		"markup-lint": true
+	},
+	quality: {
+		maxFunctionLoc: 50,
+		maxFileLoc: 300,
+		maxNesting: 4,
+		maxParams: 5,
+		maxCyclomatic: 10,
+		maxCoupling: 10
+	},
+	security: {
+		audit: false,
+		auditTimeout: 25e3,
+		owasp: true
+	},
+	imports: {
+		suggestAlternatives: true,
+		optimizeBarrels: true,
+		validateAliases: true,
+		buildGraph: true,
+		maxCircularDepth: 5
+	},
+	types: {
+		flagAsAny: true,
+		suggestTypes: true,
+		flagDoubleAssertion: true
+	},
+	deadCode: {
+		unreachableBranches: true,
+		unusedExports: true,
+		unusedVariables: true
+	},
+	i18n: {
+		hardcodedStrings: true,
+		validateKeys: false
+	},
+	scoring: {
+		mode: "logarithmic",
+		smoothing: 20,
+		maxPerRule: 40
+	},
+	telemetry: { enabled: false },
+	exclude: [
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		"coverage",
+		"tmp-*"
+	],
+	ignore: [],
+	ci: {
+		failBelow: 70,
+		format: "json",
+		failOnErrors: true
+	},
+	rules: {}
+};
+
+//#endregion
+//#region src/types/index.ts
+/** Runtime list of all 18 built-in engine names */
+const ALL_ENGINE_NAMES = [
+	"ast-slop",
+	"import-intelligence",
+	"dead-flow",
+	"type-safety",
+	"syntax-deep",
+	"security-deep",
+	"arch-constraints",
+	"dup-detect",
+	"perf-hints",
+	"i18n-lint",
+	"config-lint",
+	"meta-quality",
+	"arch-rules",
+	"lint-external",
+	"knip",
+	"format-lint",
+	"framework-lint",
+	"markup-lint"
+];
+
+//#endregion
+//#region src/scoring/rule-impact.ts
+/** Tier defaults: multiplier and per-rule cap */
+const TIER_DEFAULTS = {
+	strict: {
+		multiplier: 1,
+		cap: 40
+	},
+	standard: {
+		multiplier: 1,
+		cap: 30
+	},
+	maintainability: {
+		multiplier: .75,
+		cap: 24
+	},
+	mechanical: {
+		multiplier: .5,
+		cap: 16
+	},
+	style: {
+		multiplier: .5,
+		cap: 8
+	},
+	advisory: {
+		multiplier: .25,
+		cap: 8
+	}
+};
+/** Helper to build a RuleImpact from tier name + rationale */
+function tier(t, rationale) {
+	const def = TIER_DEFAULTS[t];
+	return {
+		tier: t,
+		multiplier: def.multiplier,
+		cap: def.cap,
+		rationale
+	};
+}
+/**
+* Map of all 60+ rule IDs to their impact tier/multiplier/cap/rationale.
+* Rule IDs use the format "engine/rule-name" matching Diagnostic.rule.
+*/
+const RULE_IMPACT = {
+	"ast-slop/narrative-comment": tier("strict", "Narrative comments are a hallmark of AI slop — authoritative, misleading, and dangerous"),
+	"ast-slop/trivial-comment": tier("mechanical", "Trivial comments add noise without value, easily bulk-removed"),
+	"ast-slop/decorative-comment": tier("style", "Decorative comments are cosmetic — section dividers, banners"),
+	"ast-slop/console-leftover": tier("style", "Console leftovers are debug debris, low impact but sloppy"),
+	"ast-slop/generic-naming": tier("advisory", "Generic naming reduces readability but is subjective"),
+	"ast-slop/hallucinated-import": tier("standard", "Hallucinated imports will cause runtime errors"),
+	"ast-slop/as-any-cast": tier("standard", "as-any casts disable type safety — tracked here for ast-slop context"),
+	"ast-slop/empty-catch": tier("strict", "Empty catch blocks silently swallow errors, hiding bugs"),
+	"ast-slop/todo-leftover": tier("mechanical", "TODO leftovers are technical debt markers, not critical"),
+	"import-intelligence/alternative-path": tier("mechanical", "Non-optimal import paths increase bundle size"),
+	"import-intelligence/barrel-optimization": tier("mechanical", "Barrel files cause unnecessary re-export overhead"),
+	"import-intelligence/circular-dependency": tier("strict", "Circular dependencies create unstable module graphs and runtime errors"),
+	"import-intelligence/unused-import": tier("mechanical", "Unused imports are dead code that increases bundle size"),
+	"import-intelligence/duplicate-import": tier("mechanical", "Duplicate imports are redundant and indicate copy-paste"),
+	"import-intelligence/broken-alias": tier("standard", "Broken path aliases cause module resolution failures"),
+	"dead-flow/unreachable-after-terminator": tier("strict", "Unreachable code after return/throw is definitively dead"),
+	"dead-flow/unused-export": tier("standard", "Unused exports bloat the public API surface"),
+	"dead-flow/unused-variable": tier("standard", "Unused variables are dead code increasing cognitive load"),
+	"dead-flow/empty-block": tier("mechanical", "Empty blocks suggest missing implementation"),
+	"dead-flow/dead-conditional": tier("standard", "Dead conditionals indicate logic errors or AI artifacts"),
+	"dead-flow/dead-switch-case": tier("standard", "Dead switch cases are unreachable branches"),
+	"type-safety/as-any-cast": tier("standard", "as-any casts circumvent the type system"),
+	"type-safety/double-assertion": tier("strict", "Double assertions (as unknown as X) are type-system abuse"),
+	"type-safety/ts-suppress": tier("standard", "@ts-ignore/@ts-expect-error suppress real type errors"),
+	"type-safety/non-null-assertion": tier("standard", "Non-null assertions (!) bypass null checks"),
+	"type-safety/generic-any": tier("mechanical", "Generic <any> parameters lose type information"),
+	"type-safety/missing-return-type": tier("mechanical", "Missing return types reduce type inference reliability"),
+	"syntax-deep/bom-present": tier("mechanical", "BOM characters cause encoding issues across tools"),
+	"syntax-deep/crlf-line-endings": tier("mechanical", "CRLF line endings cause cross-platform diff noise"),
+	"syntax-deep/mixed-line-endings": tier("mechanical", "Mixed line endings break tooling expectations"),
+	"syntax-deep/escape-sequence": tier("mechanical", "Unusual escape sequences may indicate encoding bugs"),
+	"syntax-deep/regex-issue": tier("mechanical", "Regex issues can cause silent match failures"),
+	"syntax-deep/precision-loss": tier("style", "Floating-point precision loss is cosmetic in most contexts"),
+	"syntax-deep/unicode-anomaly": tier("standard", "Unicode anomalies may hide invisible characters or homoglyphs"),
+	"security-deep/eval-usage": tier("strict", "eval() enables arbitrary code execution"),
+	"security-deep/innerhtml-usage": tier("strict", "innerHTML enables XSS injection"),
+	"security-deep/sql-injection": tier("strict", "SQL injection enables database compromise"),
+	"security-deep/shell-injection": tier("strict", "Shell injection enables OS command execution"),
+	"security-deep/prototype-pollution": tier("strict", "Prototype pollution corrupts all object instances"),
+	"security-deep/ssrf-risk": tier("strict", "SSRF enables internal network access from external input"),
+	"security-deep/hardcoded-secret": tier("strict", "Hardcoded secrets leak credentials into source control"),
+	"security-deep/dependency-vulnerability": tier("strict", "Dependency vulnerabilities expose known exploit vectors"),
+	"security-deep/xss-risk": tier("strict", "XSS risks enable cross-site scripting attacks"),
+	"security-deep/unsafe-html": tier("strict", "Unsafe HTML operations enable injection attacks"),
+	"arch-constraints/high-coupling": tier("maintainability", "High coupling makes modules hard to change independently"),
+	"arch-constraints/layer-violation": tier("maintainability", "Layer violations break architectural boundaries"),
+	"arch-constraints/god-file": tier("maintainability", "God files concentrate too many responsibilities"),
+	"arch-constraints/circular-dependency": tier("strict", "Arch-level circular deps create build and runtime instability"),
+	"arch-constraints/deep-nesting": tier("maintainability", "Deep nesting reduces readability and increases bug surface"),
+	"arch-constraints/unstable-dependency": tier("style", "Unstable dependencies increase fragility"),
+	"dup-detect/identical-blocks": tier("maintainability", "Identical code blocks violate DRY and increase maintenance cost"),
+	"dup-detect/similar-blocks": tier("style", "Similar blocks may indicate copy-paste with minor edits"),
+	"dup-detect/duplicate-imports": tier("mechanical", "Duplicate imports are redundant overhead"),
+	"dup-detect/repeated-constants": tier("mechanical", "Repeated constants should be extracted to shared definitions"),
+	"dup-detect/copy-paste": tier("style", "Copy-paste patterns increase divergence risk"),
+	"perf-hints/n-plus-one": tier("maintainability", "N+1 queries cause severe performance degradation at scale"),
+	"perf-hints/react-missing-memo": tier("advisory", "Missing React memoization causes unnecessary re-renders"),
+	"perf-hints/sync-in-async": tier("standard", "Synchronous calls in async context block the event loop"),
+	"perf-hints/large-loop-allocation": tier("style", "Large allocations in loops increase GC pressure"),
+	"perf-hints/unnecessary-await": tier("advisory", "Unnecessary awaits add microtask overhead"),
+	"perf-hints/string-concat": tier("style", "String concatenation in loops is slower than array join"),
+	"i18n-lint/hardcoded-string": tier("advisory", "Hardcoded strings prevent localization"),
+	"i18n-lint/missing-key": tier("mechanical", "Missing translation keys cause fallback or errors"),
+	"i18n-lint/locale-mismatch": tier("mechanical", "Locale mismatches cause inconsistent user experience"),
+	"i18n-lint/untranslated": tier("advisory", "Untranslated strings break multi-language support"),
+	"config-lint/tsconfig-issue": tier("mechanical", "Misconfigured tsconfig causes type-check gaps"),
+	"config-lint/eslint-issue": tier("mechanical", "ESLint misconfig leaves lint rules ineffective"),
+	"config-lint/package-scripts": tier("mechanical", "Package script issues break CI/CD workflows"),
+	"config-lint/prettier-issue": tier("mechanical", "Prettier misconfig causes formatting inconsistencies"),
+	"config-lint/vite-config": tier("mechanical", "Vite misconfig affects build performance and output"),
+	"config-lint/editorconfig": tier("mechanical", "EditorConfig issues cause cross-editor inconsistencies"),
+	"meta-quality/score-report": tier("advisory", "Score report quality is meta — it affects trust in the tool itself"),
+	"meta-quality/trend-analysis": tier("advisory", "Trend analysis is meta — helps track regressions over time"),
+	"meta-quality/quality-gate": tier("standard", "Quality gate failures block CI, directly impacting delivery"),
+	"meta-quality/config-check": tier("mechanical", "Config check issues are operational, not code quality"),
+	"lint-external/ruff": tier("mechanical", "Ruff findings are external Python lint issues"),
+	"lint-external/golangci": tier("mechanical", "golangci-lint findings are external Go lint issues"),
+	"lint-external/clippy": tier("mechanical", "Clippy findings are external Rust lint issues"),
+	"format-lint/inconsistent-indent": tier("mechanical", "Mixed indentation breaks rendering and tooling across editors"),
+	"format-lint/inconsistent-quotes": tier("style", "Mixed quote styles create diff noise and inconsistency"),
+	"format-lint/max-line-length": tier("style", "Long lines require scrolling and reduce readability"),
+	"format-lint/inconsistent-semicolons": tier("style", "Inconsistent semicolons create diff noise and style ambiguity"),
+	"format-lint/blank-line-cluster": tier("style", "Excessive blank lines waste vertical space"),
+	"format-lint/trailing-comma-inconsistency": tier("mechanical", "Inconsistent trailing commas create diff noise and refactoring errors"),
+	"nextjs/misplaced-use-client": tier("mechanical", "Unnecessary 'use client' increases client bundle size"),
+	"nextjs/missing-use-client": tier("strict", "Missing 'use client' causes runtime errors with React hooks"),
+	"nextjs/pages-router-in-app": tier("maintainability", "Pages Router APIs are deprecated in App Router projects"),
+	"nextjs/next-router-vs-navigation": tier("maintainability", "next/router is deprecated in App Router — use next/navigation"),
+	"nextjs/image-missing-dimensions": tier("mechanical", "Missing Image dimensions cause layout shift"),
+	"nextjs/metadata-in-client": tier("strict", "Metadata exports in client components are ignored by Next.js"),
+	"nextjs/hardcoded-env": tier("mechanical", "Hardcoded URLs should use environment variables for portability"),
+	"nextjs/link-without-aria": tier("advisory", "Links without accessible text fail a11y standards"),
+	"tailwind/apply-anti-pattern": tier("maintainability", "@apply negates Tailwind utility-first approach"),
+	"tailwind/inline-style-conflict": tier("maintainability", "Mixing inline styles with Tailwind creates conflicting styling sources"),
+	"tailwind/important-modifier": tier("style", "!important modifier in Tailwind indicates specificity issues"),
+	"tailwind/duplicate-utilities": tier("maintainability", "Conflicting utilities in same className indicate copy-paste errors"),
+	"tailwind/magic-values": tier("advisory", "Arbitrary values should use theme scale for consistency"),
+	"tailwind/incomplete-flex": tier("style", "Bare flex without alignment likely incomplete"),
+	"tailwind/overloaded-classname": tier("advisory", "Overloaded className strings should be extracted into components"),
+	"json/trailing-comma": tier("strict", "Trailing commas make JSON invalid per RFC 8259"),
+	"json/duplicate-keys": tier("strict", "Duplicate keys in JSON objects cause silent data loss"),
+	"json/inconsistent-spacing": tier("style", "Mixed compact/expanded formatting is cosmetic"),
+	"json/deep-nesting": tier("maintainability", "Deep nesting makes JSON hard to read and maintain"),
+	"yaml/tab-indent": tier("strict", "Tab indentation is invalid in YAML — parsers reject it"),
+	"yaml/duplicate-keys": tier("strict", "Duplicate keys in YAML mappings cause silent data loss"),
+	"yaml/complex-anchor": tier("advisory", "Complex anchor/alias chains are hard to trace"),
+	"yaml/multi-doc-unseparated": tier("mechanical", "Missing --- separator between documents causes ambiguity"),
+	"css/unused-selector": tier("mechanical", "Unused CSS selectors bloat stylesheets"),
+	"css/important-overuse": tier("maintainability", "!important overuse indicates specificity conflicts"),
+	"css/duplicate-property": tier("mechanical", "Duplicate properties in same rule are accidental"),
+	"css/universal-selector": tier("advisory", "Universal selector * has performance impact"),
+	"html/missing-alt": tier("strict", "Missing alt on <img> fails WCAG 1.1.1 accessibility"),
+	"html/missing-lang": tier("maintainability", "Missing lang on <html> fails WCAG 3.1.1"),
+	"html/deprecated-tag": tier("mechanical", "Deprecated HTML tags are removed from HTML5 spec"),
+	"html/inline-event-handler": tier("maintainability", "Inline handlers violate CSP and mix behavior with structure"),
+	"md/broken-link": tier("mechanical", "Empty or # links are broken references"),
+	"md/inconsistent-heading": tier("style", "Mixed heading styles reduce document consistency"),
+	"md/todo-in-doc": tier("advisory", "TODO/FIXME markers in docs should be tracked externally"),
+	"md/missing-fenced-lang": tier("advisory", "Missing language on fenced blocks disables syntax highlighting")
+};
+/** Fallback impact for unknown rules */
+const DEFAULT_IMPACT = {
+	tier: "mechanical",
+	multiplier: .5,
+	cap: 16,
+	rationale: "Unknown rule — defaulting to mechanical tier"
+};
+/** Get the RuleImpact for a given rule ID, falling back to default */
+function getRuleImpact(ruleId) {
+	return RULE_IMPACT[ruleId] ?? DEFAULT_IMPACT;
+}
+
+//#endregion
+//#region src/scoring/rule-severity.ts
+/**
+* Per-severity weight mapping.
+* Errors hurt most, suggestions are mild.
+* These weights are multiplied by the rule's impact multiplier
+* to get the per-diagnostic deduction.
+*/
+const SEVERITY_WEIGHTS = {
+	error: 10,
+	warning: 1,
+	info: 0,
+	suggestion: 0
+};
+
+//#endregion
+//#region src/scoring/index.ts
+/** Default scoring configuration */
+const DEFAULT_SCORING_CONFIG = {
+	mode: "logarithmic",
+	severityWeights: { ...SEVERITY_WEIGHTS },
+	defaultEngineWeight: 1,
+	smoothing: 2e4,
+	maxPerRule: 5,
+	tierDefaults: { ...TIER_DEFAULTS }
+};
+/**
+* Classify a score into a human-readable label.
+*   Healthy:   >= 75
+*   Needs Work: >= 50
+*   Critical:   < 50
+*/
+function scoreLabel(score) {
+	if (score >= 75) return "Healthy";
+	if (score >= 50) return "Needs Work";
+	return "Critical";
+}
+/**
+* Density-aware logarithmic scoring (aislop formula).
+*
+* density = min(1, diagnostics.length / (fileCount + smoothing))
+* totalDeduction = sum(severityWeight * ruleMultiplier * engineWeight) [skip if rule count > cap]
+* scaledDeduction = totalDeduction * density
+* score = round(100 - (100 * log1p(scaledDeduction)) / log1p(100 + scaledDeduction))
+*/
+function calculateLogarithmic(diagnostics, fileCount, config) {
+	const smoothing = config.smoothing;
+	const maxPerRule = config.maxPerRule;
+	const actionableCount = diagnostics.filter((d) => d.severity === "error" || d.severity === "warning").length;
+	const density = Math.min(1, actionableCount / (fileCount + smoothing));
+	const ruleCounts = /* @__PURE__ */ new Map();
+	const ruleDeductions = /* @__PURE__ */ new Map();
+	let totalDeduction = 0;
+	let cappedCount = 0;
+	for (const d of diagnostics) {
+		const impact = getRuleImpact(d.rule);
+		const prev = ruleCounts.get(d.rule) ?? 0;
+		ruleCounts.set(d.rule, prev + 1);
+		if (prev >= impact.cap) {
+			cappedCount++;
+			continue;
+		}
+		const severityWeight = config.severityWeights[d.severity];
+		const ruleMultiplier = impact.multiplier;
+		const engineWeight = config.defaultEngineWeight;
+		const deduction = severityWeight * ruleMultiplier * engineWeight;
+		const prevDeduction = ruleDeductions.get(d.rule) ?? 0;
+		if (prevDeduction + deduction > maxPerRule) {
+			const allowed = maxPerRule - prevDeduction;
+			if (allowed > 0) {
+				totalDeduction += allowed;
+				ruleDeductions.set(d.rule, maxPerRule);
+			}
+			cappedCount++;
+		} else {
+			totalDeduction += deduction;
+			ruleDeductions.set(d.rule, prevDeduction + deduction);
+		}
+	}
+	const scaledDeduction = totalDeduction * density;
+	const rawScore = 100 - 100 * Math.log1p(scaledDeduction) / Math.log1p(100 + scaledDeduction);
+	const score = Math.round(Math.max(0, Math.min(100, rawScore)));
+	return {
+		score,
+		label: scoreLabel(score),
+		density,
+		totalDeduction,
+		scaledDeduction,
+		cappedCount,
+		mode: "logarithmic"
+	};
+}
+/**
+* Legacy linear scoring (old formula).
+* score = max(0, 100 - sum(penalties))
+* Each diagnostic contributes severityWeight * ruleMultiplier.
+*/
+function calculateLinear(diagnostics, config) {
+	const ruleCounts = /* @__PURE__ */ new Map();
+	let totalPenalty = 0;
+	let cappedCount = 0;
+	for (const d of diagnostics) {
+		const impact = getRuleImpact(d.rule);
+		const prev = ruleCounts.get(d.rule) ?? 0;
+		ruleCounts.set(d.rule, prev + 1);
+		if (prev >= impact.cap) {
+			cappedCount++;
+			continue;
+		}
+		const severityWeight = config.severityWeights[d.severity];
+		const ruleMultiplier = impact.multiplier;
+		totalPenalty += severityWeight * ruleMultiplier;
+	}
+	const score = Math.max(0, Math.round(100 - totalPenalty));
+	return {
+		score,
+		label: scoreLabel(score),
+		density: 0,
+		totalDeduction: totalPenalty,
+		scaledDeduction: totalPenalty,
+		cappedCount,
+		mode: "linear"
+	};
+}
+/**
+* Calculate score using the configured mode.
+*
+* @param diagnostics - All diagnostics from the scan
+* @param fileCount - Number of files scanned (for density calculation)
+* @param config - Scoring configuration (uses defaults if omitted)
+* @returns Detailed scoring result
+*/
+function calculateScore(diagnostics, fileCount, config = DEFAULT_SCORING_CONFIG) {
+	if (config.mode === "linear") return calculateLinear(diagnostics, config);
+	return calculateLogarithmic(diagnostics, fileCount, config);
+}
+
+//#endregion
+//#region src/scoring/rule-overrides.ts
+/**
+* Apply per-rule severity overrides to a list of diagnostics.
+*
+* - If a rule's override is "off": the diagnostic is removed (filtered out).
+* - If a rule's override is "error"/"warning"/"info": the diagnostic's severity is rewritten.
+* - Override keys ending with "/*" act as wildcard prefixes, matching all rules
+*   that start with that prefix (e.g. "ast-slop/*" matches "ast-slop/narrative-comment").
+*
+* Exact-match overrides take precedence over wildcard overrides.
+* CLI overrides (passed separately) should be merged into the overrides map
+* before calling this function, with CLI values taking priority.
+*
+* @param diagnostics - Raw diagnostics from all engines
+* @param overrides - Map of rule-id (or prefix with /*) to severity override
+* @returns Filtered and re-severitized diagnostics
+*/
+function applyRuleSeverities(diagnostics, overrides) {
+	if (!overrides || Object.keys(overrides).length === 0) return diagnostics;
+	const wildcardPrefixes = [];
+	const exactOverrides = {};
+	for (const [key, severity] of Object.entries(overrides)) if (key.endsWith("/*")) wildcardPrefixes.push({
+		prefix: key.slice(0, -2),
+		severity
+	});
+	else exactOverrides[key] = severity;
+	const severityMap = {
+		error: "error",
+		warning: "warning",
+		info: "info"
+	};
+	const result = [];
+	for (const d of diagnostics) {
+		let override = exactOverrides[d.rule];
+		if (!override) {
+			for (const wc of wildcardPrefixes) if (d.rule.startsWith(wc.prefix)) {
+				override = wc.severity;
+				break;
+			}
+		}
+		if (!override) {
+			result.push(d);
+			continue;
+		}
+		if (override === "off") continue;
+		const newSeverity = severityMap[override];
+		if (newSeverity && newSeverity !== d.severity) result.push({
+			...d,
+			severity: newSeverity
+		});
+		else result.push(d);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/history/store.ts
+const HISTORY_DIR = ".deep-slop";
+const HISTORY_FILE = "history.jsonl";
+function historyPath(rootDir) {
+	return join(rootDir, HISTORY_DIR, HISTORY_FILE);
+}
+function appendRecord(rootDir, record) {
+	const dir = join(rootDir, HISTORY_DIR);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const line = JSON.stringify(record) + "\n";
+	appendFileSync(historyPath(rootDir), line, "utf8");
+}
+
+//#endregion
+//#region src/utils/file-cache.ts
+/** In-memory file content cache — avoids re-reading the same file across engines */
+const cache = /* @__PURE__ */ new Map();
+/** Read file with caching. Checks mtime to invalidate stale entries. */
+async function readFileCached(filePath) {
+	await readFile(filePath).then((b) => b);
+	const cached = cache.get(filePath);
+	if (cached) return cached.content;
+	let content = (await readFile(filePath)).toString("utf-8");
+	if (content.charCodeAt(0) === 65279) content = content.slice(1);
+	cache.set(filePath, {
+		content,
+		mtimeMs: Date.now()
+	});
+	return content;
+}
+/** Preload multiple files into cache in parallel */
+async function preloadFiles(filePaths) {
+	await Promise.all(filePaths.map(async (fp) => {
+		try {
+			await readFileCached(fp);
+		} catch {}
+	}));
+}
+/** Clear the file cache (call between scans) */
+function clearFileCache() {
+	cache.clear();
+}
+
+//#endregion
+//#region src/plugins/loader.ts
+/**
+* Load a plugin from a file path.
+* The module must default-export an Engine-compatible object.
+* Returns null on any failure (missing file, bad export, etc).
+*/
+async function loadPlugin(pluginPath) {
+	try {
+		const engine = (await import(pluginPath)).default;
+		if (!engine || typeof engine !== "object") return null;
+		if (typeof engine.name === "string" && typeof engine.description === "string" && Array.isArray(engine.supportedLanguages) && typeof engine.run === "function") return engine;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Load multiple plugins from an array of paths.
+* Returns successfully loaded engines, skipping failures.
+*/
+async function loadPlugins(paths) {
+	const results = await Promise.allSettled(paths.map((p) => loadPlugin(p)));
+	const engines = [];
+	for (const r of results) if (r.status === "fulfilled" && r.value !== null) engines.push(r.value);
+	return engines;
+}
+
+//#endregion
+//#region src/plugins/registry.ts
+/** Plugin registry singleton */
+var PluginRegistry = class {
+	entries = /* @__PURE__ */ new Map();
+	loaded = false;
+	/** Get all registered plugins */
+	getAll() {
+		return [...this.entries.values()];
+	}
+	/** Get all successfully loaded engines */
+	getEngines() {
+		return [...this.entries.values()].filter((e) => e.loaded).map((e) => e.engine);
+	}
+	/** Get a specific plugin by id */
+	get(id) {
+		return this.entries.get(id);
+	}
+	/** Get a loaded engine by name */
+	getEngine(name) {
+		const entry = this.entries.get(name);
+		return entry?.loaded ? entry.engine : void 0;
+	}
+	/** Register a plugin entry */
+	register(entry) {
+		this.entries.set(entry.id, entry);
+	}
+	/** Remove a plugin by id */
+	remove(id) {
+		return this.entries.delete(id);
+	}
+	/** Check if a plugin is registered */
+	has(id) {
+		return this.entries.has(id);
+	}
+	/** Number of registered plugins */
+	get size() {
+		return this.entries.size;
+	}
+	/** Whether the registry has been loaded from disk */
+	get isLoaded() {
+		return this.loaded;
+	}
+	/** Mark the registry as loaded */
+	setLoaded(loaded) {
+		this.loaded = loaded;
+	}
+	/** Clear all entries */
+	clear() {
+		this.entries.clear();
+		this.loaded = false;
+	}
+};
+/** Global plugin registry instance */
+const pluginRegistry = new PluginRegistry();
+/** Default plugin directory name */
+const PLUGIN_DIR = ".deep-slop/plugins";
+/**
+* Resolve the plugins directory for a given project root.
+*/
+function getPluginDir(rootDir) {
+	return join(rootDir, PLUGIN_DIR);
+}
+/**
+* Discover and load all plugins from the project's plugin directory.
+* Returns the loaded engines. Safe to call multiple times.
+*/
+async function discoverAndLoadPlugins(rootDir) {
+	if (pluginRegistry.isLoaded) return pluginRegistry.getEngines();
+	const pluginDir = getPluginDir(rootDir);
+	if (!existsSync(pluginDir)) {
+		pluginRegistry.setLoaded(true);
+		return [];
+	}
+	try {
+		const pluginPaths = (await readdir(pluginDir)).filter((f) => f.endsWith(".js") || f.endsWith(".mjs")).map((f) => join(pluginDir, f));
+		const engines = await loadPlugins(pluginPaths);
+		for (let i = 0; i < engines.length; i++) {
+			const engine = engines[i];
+			pluginRegistry.register({
+				id: engine.name,
+				path: pluginPaths[i],
+				engine,
+				loaded: true
+			});
+		}
+		for (let i = 0; i < pluginPaths.length; i++) {
+			const path = pluginPaths[i];
+			if (!engines.find((e) => {
+				return pluginRegistry.getAll().find((ent) => ent.path === path)?.engine;
+			}) && !pluginRegistry.has(path)) pluginRegistry.register({
+				id: `plugin-${i}`,
+				path,
+				engine: null,
+				loaded: false,
+				error: "Failed to load plugin module"
+			});
+		}
+		pluginRegistry.setLoaded(true);
+		return engines;
+	} catch {
+		pluginRegistry.setLoaded(true);
+		return [];
+	}
+}
+
+//#endregion
+//#region src/utils/suppress.ts
+/** Parse suppress directives from source content */
+function parseSuppressDirectives(content) {
+	const entries = [];
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		const lineNum = i + 1;
+		const ignoreNextMatch = line.match(/\/\/\s*deep-slop-ignore-next(?:\s+(.+))?$/);
+		if (ignoreNextMatch) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum + 1,
+				rules: parseRuleList(ignoreNextMatch[1]),
+				type: "next-line"
+			});
+			continue;
+		}
+		const ignoreLineMatch = line.match(/\/\/\s*deep-slop-ignore-line(?:\s+(.+))?$/);
+		if (ignoreLineMatch) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum,
+				rules: parseRuleList(ignoreLineMatch[1]),
+				type: "line"
+			});
+			continue;
+		}
+		const ignoreRuleMatch = line.match(/\/\/\s*deep-slop-ignore(?:\s+(.+))?$/);
+		if (ignoreRuleMatch) {
+			const rulePart = ignoreRuleMatch[1];
+			if (rulePart !== "start" && rulePart !== "end") {
+				entries.push({
+					directiveLine: lineNum,
+					targetLine: lineNum + 1,
+					rules: parseRuleList(rulePart),
+					type: "next-line"
+				});
+				continue;
+			}
+		}
+		const ignoreStartMatch = line.match(/\/\/\s*deep-slop-ignore-start(?:\s+(.+))?$/);
+		if (ignoreStartMatch) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum,
+				rules: parseRuleList(ignoreStartMatch[1]),
+				type: "block-start"
+			});
+			continue;
+		}
+		if (line.match(/\/\/\s*deep-slop-ignore-end/)) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum,
+				rules: /* @__PURE__ */ new Set(),
+				type: "block-end"
+			});
+			continue;
+		}
+		const nextLineMatch = line.match(/\/\/\s*deep-slop-disable-next-line(?:\s+(.+))?$/);
+		if (nextLineMatch) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum + 1,
+				rules: parseRuleList(nextLineMatch[1]),
+				type: "next-line"
+			});
+			continue;
+		}
+		const lineMatch = line.match(/\/\/\s*deep-slop-disable-line(?:\s+(.+))?$/);
+		if (lineMatch) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum,
+				rules: parseRuleList(lineMatch[1]),
+				type: "line"
+			});
+			continue;
+		}
+		const blockStart = line.match(/\/\*\s*deep-slop-disable(?:\s+(.+))?\s*\//);
+		if (blockStart) {
+			entries.push({
+				directiveLine: lineNum,
+				targetLine: lineNum,
+				rules: parseRuleList(blockStart[1]),
+				type: "block-start"
+			});
+			continue;
+		}
+		if (line.match(/\/\*\s*deep-slop-enable\s*\//)) entries.push({
+			directiveLine: lineNum,
+			targetLine: lineNum,
+			rules: /* @__PURE__ */ new Set(),
+			type: "block-end"
+		});
+	}
+	return entries;
+}
+/** Parse comma/space-separated rule list from directive */
+function parseRuleList(rulesStr) {
+	if (!rulesStr) return /* @__PURE__ */ new Set();
+	const rules = rulesStr.split(/[,\\s]+/).map((r) => r.trim()).filter(Boolean);
+	return new Set(rules);
+}
+/** Build a suppress check function from parsed directives */
+function buildSuppressChecker(entries) {
+	const blockRanges = [];
+	let currentStart = null;
+	for (const entry of entries) if (entry.type === "block-start") currentStart = {
+		line: entry.directiveLine,
+		rules: entry.rules
+	};
+	else if (entry.type === "block-end" && currentStart) {
+		blockRanges.push({
+			startLine: currentStart.line,
+			endLine: entry.directiveLine,
+			rules: currentStart.rules
+		});
+		currentStart = null;
+	}
+	if (currentStart) blockRanges.push({
+		startLine: currentStart.line,
+		endLine: 999999,
+		rules: currentStart.rules
+	});
+	return (line, rule) => {
+		for (const entry of entries) if (entry.type === "next-line" || entry.type === "line") {
+			if (entry.targetLine === line) {
+				if (entry.rules.size === 0 || entry.rules.has(rule)) return true;
+			}
+		}
+		for (const range of blockRanges) if (line >= range.startLine && line <= range.endLine) {
+			if (range.rules.size === 0 || range.rules.has(rule)) return true;
+		}
+		return false;
+	};
+}
+/**
+* Build a full suppress map for a file's content.
+* Returns both the entries and a checker function.
+*/
+function buildSuppressMap(content) {
+	const entries = parseSuppressDirectives(content);
+	return {
+		entries,
+		isSuppressed: buildSuppressChecker(entries)
+	};
+}
+/**
+* Load global suppression rules from `.deep-slop/.deep-slop-ignore`.
+* Returns a list of rule IDs to suppress across the whole project.
+* Missing or unreadable files are treated as "no global rules".
+*/
+function loadIgnoreFile(rootDir) {
+	const ignorePath = join(rootDir, ".deep-slop", ".deep-slop-ignore");
+	try {
+		return readFileSync(ignorePath, "utf-8").split("\n").map((line) => line.split("#")[0].trim()).filter((line) => line && !line.startsWith("file:"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Filter diagnostics using suppress directives.
+* Returns the filtered list and the count of suppressed diagnostics.
+*/
+function applySuppressDirectives(diagnostics, fileContents, globallySuppressed = /* @__PURE__ */ new Set()) {
+	const suppressMaps = /* @__PURE__ */ new Map();
+	for (const [filePath, content] of fileContents) suppressMaps.set(filePath, buildSuppressMap(content));
+	const filtered = [];
+	let suppressedCount = 0;
+	for (const diag of diagnostics) {
+		if (globallySuppressed.has(diag.rule)) {
+			suppressedCount++;
+			continue;
+		}
+		const map = suppressMaps.get(diag.filePath);
+		if (map && map.isSuppressed(diag.line, diag.rule)) suppressedCount++;
+		else filtered.push(diag);
+	}
+	return {
+		filtered,
+		suppressedCount
+	};
+}
+
+//#endregion
+//#region src/engines/orchestrator.ts
+/** File extension to Language mapping (for scoreability check) */
+const EXT_TO_LANG = {
+	".ts": "typescript",
+	".tsx": "tsx",
+	".js": "javascript",
+	".jsx": "jsx",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".py": "python",
+	".go": "go",
+	".rs": "rust",
+	".rb": "ruby",
+	".php": "php",
+	".java": "java",
+	".cs": "csharp",
+	".swift": "swift"
+};
+/** Registry of all 18 engines (loaded lazily) */
+const ENGINE_REGISTRY = {
+	"ast-slop": () => import("./ast-slop-BGdr58wZ.js").then((m) => m.astSlopEngine),
+	"import-intelligence": () => import("./import-intelligence-SK4F7XpL.js").then((m) => m.importIntelligenceEngine),
+	"dead-flow": () => import("./dead-flow-DHRkyxZT.js").then((m) => m.deadFlowEngine),
+	"type-safety": () => import("./type-safety-Dboj2C1t.js").then((m) => m.typeSafetyEngine),
+	"syntax-deep": () => import("./syntax-deep-ZQYMutky.js").then((m) => m.syntaxDeepEngine),
+	"security-deep": () => import("./security-deep-DJRINs10.js").then((m) => m.securityDeepEngine),
+	"arch-constraints": () => import("./arch-constraints-C7s1E_bc.js").then((m) => m.archConstraintsEngine),
+	"dup-detect": () => import("./dup-detect-DKRXM04q.js").then((m) => m.dupDetectEngine),
+	"perf-hints": () => import("./perf-hints-BnWFMFff.js").then((m) => m.perfHintsEngine),
+	"i18n-lint": () => import("./i18n-lint-CPzx7V8Q.js").then((m) => m.i18nLintEngine),
+	"config-lint": () => import("./config-lint-ph3vMUbg.js").then((m) => m.configLintEngine),
+	"meta-quality": () => import("./meta-quality-Dai1W5iC.js").then((m) => m.metaQualityEngine),
+	"lint-external": () => import("./lint-external-ZbW3jGvB.js").then((m) => m.lintExternalEngine),
+	"arch-rules": () => import("./arch-rules-DI1SYPqu.js").then((m) => m.archRulesEngine),
+	"knip": () => import("./knip-CgxnnTBZ.js").then((m) => m.knipEngine),
+	"format-lint": () => import("./format-lint-DeElllNm.js").then((m) => m.formatLintEngine),
+	"framework-lint": () => import("./framework-lint-CqdlF9hX.js").then((m) => m.frameworkLintEngine),
+	"markup-lint": () => import("./markup-lint-DKVEDz9M.js").then((m) => m.markupLintEngine)
+};
+/** Run selected engines and produce aggregated scan result */
+async function runScan(context, callbacks) {
+	const startTotal = performance.now();
+	clearFileCache();
+	if (context.files?.length) await preloadFiles(context.files);
+	const pluginEngines = await discoverAndLoadPlugins(context.rootDirectory);
+	const enabledEngines = Object.entries(ENGINE_REGISTRY).filter(([name]) => context.config.engines[name] !== false);
+	for (const pluginEngine of pluginEngines) if (context.config.engines[pluginEngine.name] !== false) enabledEngines.push([pluginEngine.name, () => Promise.resolve(pluginEngine)]);
+	const results = [];
+	let completed = 0;
+	const settled = await Promise.allSettled(enabledEngines.map(async ([name, loader]) => {
+		callbacks?.onEngineStart?.(name);
+		try {
+			const engine = await loader();
+			const start = performance.now();
+			if (!engine.supportedLanguages.some((l) => context.languages.includes(l))) {
+				const result = {
+					engine: name,
+					diagnostics: [],
+					elapsed: 0,
+					skipped: true,
+					skipReason: `No supported language found (engine supports: ${engine.supportedLanguages.join(", ")})`
+				};
+				callbacks?.onEngineComplete?.(result);
+				completed++;
+				callbacks?.onProgress?.(completed, enabledEngines.length);
+				return result;
+			}
+			const result = await engine.run(context);
+			result.elapsed = performance.now() - start;
+			callbacks?.onEngineComplete?.(result);
+			completed++;
+			callbacks?.onProgress?.(completed, enabledEngines.length);
+			return result;
+		} catch (error) {
+			const result = {
+				engine: name,
+				diagnostics: [],
+				elapsed: 0,
+				skipped: true,
+				skipReason: error instanceof Error ? error.message : String(error)
+			};
+			callbacks?.onEngineComplete?.(result);
+			completed++;
+			callbacks?.onProgress?.(completed, enabledEngines.length);
+			return result;
+		}
+	}));
+	for (const r of settled) results.push(r.status === "fulfilled" ? r.value : {
+		engine: "ast-slop",
+		diagnostics: [],
+		elapsed: 0,
+		skipped: true,
+		skipReason: r.reason instanceof Error ? r.reason.message : String(r.reason)
+	});
+	let allDiagnostics = applyRuleSeverities(results.flatMap((r) => r.diagnostics), context.config.rules || {});
+	const fileContents = /* @__PURE__ */ new Map();
+	if (context.files?.length) {
+		const { readFile: fsReadFile } = await import("node:fs/promises");
+		const { join } = await import("node:path");
+		const uniquePaths = new Set(allDiagnostics.map((d) => d.filePath));
+		for (const relPath of uniquePaths) try {
+			const content = await fsReadFile(join(context.rootDirectory, relPath), "utf-8");
+			fileContents.set(relPath, content);
+		} catch {}
+	}
+	const globallySuppressed = new Set(loadIgnoreFile(context.rootDirectory));
+	const { filtered, suppressedCount } = applySuppressDirectives(allDiagnostics, fileContents, globallySuppressed);
+	allDiagnostics = filtered;
+	for (const r of results) r.diagnostics = allDiagnostics.filter((d) => d.engine === r.engine);
+	const bySeverity = {
+		error: 0,
+		warning: 0,
+		info: 0,
+		suggestion: 0
+	};
+	const byEngine = {};
+	const categoryScores = {};
+	for (const d of allDiagnostics) {
+		bySeverity[d.severity]++;
+		byEngine[d.engine] = (byEngine[d.engine] ?? 0) + 1;
+	}
+	const fileCount = context.files?.length ?? 0;
+	let score = calculateScore(allDiagnostics, fileCount).score;
+	const supportedLangs = /* @__PURE__ */ new Set();
+	for (const r of results) if (!r.skipped) {
+		const engineLoader = ENGINE_REGISTRY[r.engine];
+		if (engineLoader) try {
+			const engine = await engineLoader();
+			for (const l of engine.supportedLanguages) supportedLangs.add(l);
+		} catch {}
+	}
+	const unsupportedFileCount = context.files ? context.files.filter((f) => {
+		const lang = EXT_TO_LANG[`.${f.split(".").pop()?.toLowerCase() ?? ""}`];
+		return lang && !supportedLangs.has(lang);
+	}).length : 0;
+	const totalFileCount = context.files?.length ?? 0;
+	const scoreable = (totalFileCount > 0 ? unsupportedFileCount / totalFileCount : 0) < .8;
+	if (!scoreable) score = null;
+	const scanResult = {
+		engines: results,
+		score,
+		scoreable,
+		categoryScores,
+		totalDiagnostics: allDiagnostics.length,
+		bySeverity,
+		byEngine,
+		suppressedCount,
+		meta: {
+			rootDirectory: context.rootDirectory,
+			languages: context.languages,
+			frameworks: context.frameworks,
+			filesScanned: context.files?.length ?? 0,
+			elapsed: performance.now() - startTotal,
+			diffScope: context.diffScope
+		}
+	};
+	if (!context.diffScope) {
+		const record = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			score: scanResult.score,
+			errors: bySeverity.error,
+			warnings: bySeverity.warning,
+			info: bySeverity.info,
+			suggestions: bySeverity.suggestion,
+			filesScanned: scanResult.meta.filesScanned,
+			engines: results.filter((r) => !r.skipped).map((r) => r.engine),
+			durationMs: scanResult.meta.elapsed
+		};
+		try {
+			appendRecord(context.rootDirectory, record);
+		} catch {}
+	}
+	return scanResult;
+}
+/** Run auto-fix for a specific engine */
+async function runFix(engineName, diagnostics, context) {
+	const loader = ENGINE_REGISTRY[engineName];
+	if (!loader) return null;
+	const engine = await loader();
+	if (!engine.fix) return null;
+	return engine.fix(diagnostics, context);
+}
+
+//#endregion
+export { ALL_ENGINE_NAMES, DEFAULT_CONFIG, collectFiles, detectFrameworks, detectLanguages, runFix, runScan };