aislop 0.2.1 → 0.3.1

package/dist/cli.js

@@ -13,6 +13,23 @@ import pc from "picocolors";
 import ora from "ora";
 import { emitKeypressEvents } from "node:readline";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/config/defaults.ts
 const DEFAULT_CONFIG = {
 	version: 1,
@@ -36,18 +53,18 @@ const DEFAULT_CONFIG = {
 	},
 	scoring: {
 		weights: {
-			format: .5,
-			lint: 1,
-			"code-quality": 1.5,
-			"ai-slop": 1,
+			format: .3,
+			lint: .6,
+			"code-quality": .8,
+			"ai-slop": 2.5,
 			architecture: 1,
-			security: 2
+			security: 1.5
 		},
 		thresholds: {
 			good: 75,
 			ok: 50
 		},
-		smoothing: 10
+		smoothing: 20
 	},
 	ci: {
 		failBelow: 0,
@@ -77,15 +94,16 @@ security:
 
 scoring:
   weights:
-    format: 0.5
-    lint: 1.0
-    code-quality: 1.5
-    ai-slop: 1.0
+    format: 0.3
+    lint: 0.6
+    code-quality: 0.8
+    ai-slop: 2.5
     architecture: 1.0
-    security: 2.0
+    security: 1.5
   thresholds:
     good: 75
     ok: 50
+  smoothing: 20
 
 ci:
   failBelow: 0
@@ -113,12 +131,12 @@ const DEFAULT_RULES_YAML = `# Architecture rules (BYO)
 //#endregion
 //#region src/config/schema.ts
 const DEFAULT_WEIGHTS = {
-	format: .5,
-	lint: 1,
-	"code-quality": 1.5,
-	"ai-slop": 1,
+	format: .3,
+	lint: .6,
+	"code-quality": .8,
+	"ai-slop": 2.5,
 	architecture: 1,
-	security: 2
+	security: 1.5
 };
 const EnginesSchema = z.object({
 	format: z.boolean().default(true),
@@ -148,7 +166,7 @@ const ScoringSchema = z.object({
 		good: 75,
 		ok: 50
 	})),
-	smoothing: z.number().nonnegative().default(10)
+	smoothing: z.number().nonnegative().default(20)
 });
 const CiSchema = z.object({
 	failBelow: z.number().default(0),
@@ -181,7 +199,7 @@ const AislopConfigSchema = z.object({
 			good: 75,
 			ok: 50
 		},
-		smoothing: 10
+		smoothing: 20
 	})),
 	ci: CiSchema.default(() => ({
 		failBelow: 0,
@@ -1842,10 +1860,10 @@ const codeQualityEngine = {
 
 //#endregion
 //#region src/engines/format/biome.ts
-const esmRequire$2 = createRequire(import.meta.url);
+const esmRequire$3 = createRequire(import.meta.url);
 const resolveLocalBiomeScript = () => {
 	try {
-		const packageJsonPath = esmRequire$2.resolve("@biomejs/biome/package.json");
+		const packageJsonPath = esmRequire$3.resolve("@biomejs/biome/package.json");
 		return path.join(path.dirname(packageJsonPath), "bin", "biome");
 	} catch {
 		return null;
@@ -1919,12 +1937,14 @@ const parseBiomeJsonOutput = (output, rootDir) => {
 			const rawPath = entry.location?.path;
 			if (!rawPath) continue;
 			const severity = entry.severity === "error" ? "error" : "warning";
+			const rawMessage = entry.message ?? "";
+			const message = !rawMessage || rawMessage.toLowerCase().includes("would have printed") ? "File is not formatted correctly" : rawMessage;
 			diagnostics.push({
 				filePath: path.isAbsolute(rawPath) ? path.relative(rootDir, rawPath) : rawPath,
 				engine: "format",
 				rule: "formatting",
 				severity,
-				message: entry.message ?? "File is not formatted correctly",
+				message,
 				help: "Run `aislop fix` to auto-format",
 				line: entry.location?.start?.line ?? 0,
 				column: entry.location?.start?.column ?? 0,
@@ -2092,7 +2112,7 @@ const fixGofmt = async (rootDirectory) => {
 //#endregion
 //#region src/utils/tooling.ts
 const THIS_FILE = fileURLToPath(import.meta.url);
-const esmRequire$1 = createRequire(import.meta.url);
+const esmRequire$2 = createRequire(import.meta.url);
 const resolvePackageRoot = (startFile) => {
 	let current = path.dirname(startFile);
 	while (true) {
@@ -2123,7 +2143,7 @@ const isToolAvailable = async (toolName) => {
 };
 const isNodePackageAvailable = (packageName) => {
 	try {
-		esmRequire$1.resolve(`${packageName}/package.json`);
+		esmRequire$2.resolve(`${packageName}/package.json`);
 		return true;
 	} catch {
 		return false;
@@ -2406,10 +2426,10 @@ const createOxlintConfig = (options) => {
 
 //#endregion
 //#region src/engines/lint/oxlint.ts
-const esmRequire = createRequire(import.meta.url);
+const esmRequire$1 = createRequire(import.meta.url);
 const resolveOxlintBinary = () => {
 	try {
-		const oxlintMainPath = esmRequire.resolve("oxlint");
+		const oxlintMainPath = esmRequire$1.resolve("oxlint");
 		const oxlintDir = path.resolve(path.dirname(oxlintMainPath), "..");
 		return path.join(oxlintDir, "bin", "oxlint");
 	} catch {
@@ -2417,6 +2437,10 @@ const resolveOxlintBinary = () => {
 	}
 };
 const parseRuleCode = (code) => {
+	if (!code) return {
+		plugin: "unknown",
+		rule: "unknown"
+	};
 	const match = code.match(/^(.+)\((.+)\)$/);
 	if (!match) return {
 		plugin: "unknown",
@@ -2444,6 +2468,143 @@ const detectTestFramework = (rootDir) => {
 	} catch {}
 	return null;
 };
+const extractUnusedVarName = (message) => {
+	const variableMatch = message.match(/Variable '([^']+)' is declared but never used/);
+	if (variableMatch?.[1]) return {
+		name: variableMatch[1],
+		type: "variable"
+	};
+	const paramMatch = message.match(/Parameter '([^']+)' is declared but never used/);
+	if (paramMatch?.[1]) return {
+		name: paramMatch[1],
+		type: "parameter"
+	};
+	const catchMatch = message.match(/Catch parameter '([^']+)' is caught but never used/);
+	if (catchMatch?.[1]) return {
+		name: catchMatch[1],
+		type: "parameter"
+	};
+	return null;
+};
+const collectUnusedVarCandidates = (diagnostics) => diagnostics.filter((d) => d.rule === "eslint/no-unused-vars").map((d) => {
+	const extracted = extractUnusedVarName(d.message);
+	if (!extracted || extracted.name.startsWith("_")) return null;
+	return {
+		filePath: d.filePath,
+		line: d.line,
+		column: d.column,
+		name: extracted.name,
+		type: extracted.type
+	};
+}).filter((candidate) => candidate !== null);
+const prefixIdentifierOnLine = (line, name, column, type) => {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	if (type === "parameter") {
+		const destructureMatch = line.match(/\{[^}]*\}/);
+		if (destructureMatch) {
+			const { 0: content, index: start } = destructureMatch;
+			const propPattern = new RegExp(`(?<!:\\s*)\\b${escaped}\\b(?!\\s*:)`);
+			if (propPattern.test(content)) {
+				const updated = content.replace(propPattern, `${name}: _${name}`);
+				if (updated !== content) return line.slice(0, start) + updated + line.slice(start + content.length);
+			}
+		}
+		const paramPattern = new RegExp(`\\b${escaped}\\b`);
+		return paramPattern.test(line) ? line.replace(paramPattern, `_${name}`) : line;
+	}
+	const assignPattern = new RegExp(`(\\s*)(const|let|var)\\s+${escaped}\\s*=\\s*(.+)$`);
+	const assignMatch = line.match(assignPattern);
+	if (assignMatch) {
+		const [, indent, , expression] = assignMatch;
+		if (/await\s/.test(expression) || /\w+\s*\(/.test(expression)) return `${indent}${expression}`;
+		return "";
+	}
+	const destructureMatch = line.match(/\{[^}]*\}/);
+	if (destructureMatch) {
+		const { 0: content, index: start } = destructureMatch;
+		if (new RegExp(`\\b${escaped}\\b`).test(content)) {
+			let updated = content.replace(new RegExp(`\\b${escaped}\\b\\s*,?`), "");
+			updated = updated.replace(/,\s*\},/, "}").replace(/\{,\s*/, "{").replace(/\s*,\s*\}/, "}");
+			if (updated !== content) return line.slice(0, start) + updated + line.slice(start + content.length);
+		}
+	}
+	let bestStart = -1;
+	let bestEnd = -1;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	const target = Math.max(0, column - 1);
+	for (const match of line.matchAll(new RegExp(`\\b${escaped}\\b`, "g"))) {
+		if (match.index === void 0) continue;
+		const start = match.index;
+		const end = start + name.length;
+		if (start > 0 && line[start - 1] === "_") continue;
+		const distance = target >= start && target <= end ? 0 : Math.abs(start - target);
+		if (distance < bestDistance) {
+			bestDistance = distance;
+			bestStart = start;
+			bestEnd = end;
+		}
+	}
+	if (bestStart < 0 || bestEnd < 0) return line;
+	return `${line.slice(0, bestStart)}_${name}${line.slice(bestEnd)}`;
+};
+const applyUnusedVarPrefixFixes = (rootDirectory, candidates) => {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const absolute = path.isAbsolute(candidate.filePath) ? candidate.filePath : path.join(rootDirectory, candidate.filePath);
+		const entries = byFile.get(absolute) ?? [];
+		entries.push(candidate);
+		byFile.set(absolute, entries);
+	}
+	for (const [filePath, fileCandidates] of byFile.entries()) {
+		if (!fs.existsSync(filePath)) continue;
+		const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+		const ordered = [...fileCandidates].sort((a, b) => {
+			if (a.line !== b.line) return a.line - b.line;
+			return a.column - b.column;
+		});
+		let changed = false;
+		for (const candidate of ordered) {
+			const lineIndex = candidate.line - 1;
+			if (lineIndex < 0 || lineIndex >= lines.length) continue;
+			const current = lines[lineIndex];
+			const updated = prefixIdentifierOnLine(current, candidate.name, candidate.column, candidate.type);
+			if (updated !== current) {
+				lines[lineIndex] = updated;
+				changed = true;
+			}
+		}
+		if (changed) fs.writeFileSync(filePath, lines.join("\n"));
+	}
+};
+const removeDuplicateKeyLines = (rootDirectory, diagnostics) => {
+	const byFile = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		const keyMatch = d.message.match(/Duplicate key '([^']+)'/);
+		if (!keyMatch) continue;
+		const absolute = path.isAbsolute(d.filePath) ? d.filePath : path.join(rootDirectory, d.filePath);
+		const entries = byFile.get(absolute) ?? [];
+		entries.push({
+			key: keyMatch[1],
+			line: d.line
+		});
+		byFile.set(absolute, entries);
+	}
+	for (const [filePath, dupes] of byFile) {
+		if (!fs.existsSync(filePath)) continue;
+		const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+		const toRemove = /* @__PURE__ */ new Set();
+		for (const { key } of dupes) {
+			const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			const keyPattern = new RegExp(`^\\s*['"]?${escaped}['"]?\\s*:|^\\s*${escaped}\\s*:`);
+			const matches = [];
+			for (let i = 0; i < lines.length; i++) if (keyPattern.test(lines[i])) matches.push(i);
+			for (let j = 1; j < matches.length; j++) toRemove.add(matches[j]);
+		}
+		if (toRemove.size === 0) continue;
+		const filtered = lines.filter((_, i) => !toRemove.has(i));
+		fs.writeFileSync(filePath, filtered.join("\n"));
+	}
+};
 const runOxlint = async (context) => {
 	const configPath = path.join(os.tmpdir(), `aislop-oxlintrc-${process.pid}.json`);
 	const config = createOxlintConfig({
@@ -2506,6 +2667,7 @@ const fixOxlint = async (context) => {
 			configPath,
 			"--fix",
 			"--fix-suggestions",
+			"--fix-dangerously",
 			"."
 		];
 		const result = await runSubprocess(process.execPath, args, {
@@ -2513,10 +2675,18 @@ const fixOxlint = async (context) => {
 			timeout: 12e4
 		});
 		if (result.exitCode !== 0) throw new Error(result.stderr || result.stdout || `Oxlint exited with code ${result.exitCode}`);
+		const remaining = await runOxlint(context);
+		const candidates = collectUnusedVarCandidates(remaining);
+		if (candidates.length > 0) applyUnusedVarPrefixFixes(context.rootDirectory, candidates);
+		const duplicateKeys = remaining.filter((d) => d.message.startsWith("Duplicate key"));
+		if (duplicateKeys.length > 0) removeDuplicateKeyLines(context.rootDirectory, duplicateKeys);
 	} finally {
 		if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
 	}
 };
+const fixOxlintForce = async (context) => {
+	return fixOxlint(context);
+};
 
 //#endregion
 //#region src/engines/lint/ruff.ts
@@ -2559,6 +2729,18 @@ const fixRuffLint = async (rootDirectory) => {
 	});
 	if (result.exitCode !== 0) throw new Error(result.stderr || result.stdout || `ruff check --fix exited with code ${result.exitCode}`);
 };
+const fixRuffLintForce = async (rootDirectory) => {
+	const result = await runSubprocess(resolveToolBinary("ruff"), [
+		"check",
+		"--fix",
+		"--unsafe-fixes",
+		rootDirectory
+	], {
+		cwd: rootDirectory,
+		timeout: 6e4
+	});
+	if (result.exitCode !== 0) throw new Error(result.stderr || result.stdout || `ruff check --fix exited with code ${result.exitCode}`);
+};
 
 //#endregion
 //#region src/engines/lint/index.ts
@@ -2569,7 +2751,7 @@ const lintEngine = {
 		const { languages, installedTools } = context;
 		const promises = [];
 		if (languages.includes("typescript") || languages.includes("javascript")) promises.push(runOxlint(context));
-		if (context.frameworks.includes("expo")) promises.push(import("./expo-doctor-vDz4kh9-.js").then((mod) => mod.runExpoDoctor(context)));
+		if (context.frameworks.includes("expo")) promises.push(Promise.resolve().then(() => expo_doctor_exports).then((mod) => mod.runExpoDoctor(context)));
 		if (languages.includes("python") && installedTools["ruff"]) promises.push(runRuffLint(context));
 		if (languages.includes("go") && installedTools["golangci-lint"]) promises.push(runGolangciLint(context));
 		if (languages.includes("rust") && installedTools["cargo"]) promises.push(runGenericLinter(context, "rust"));
@@ -3194,11 +3376,11 @@ const logger = {
 * Application version — injected at build time by tsdown from package.json.
 * The fallback should always match the "version" field in package.json.
 */
-const APP_VERSION = "0.2.1";
+const APP_VERSION = "0.3.1";
 
 //#endregion
 //#region src/output/layout.ts
-const formatElapsed$1 = (elapsedMs) => elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`;
+const formatElapsed$2 = (elapsedMs) => elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`;
 const printCommandHeader = (commandName) => {
 	logger.log(`${highlighter.bold(`aislop ${commandName.toLowerCase()}`)} ${highlighter.dim(`v${APP_VERSION}`)}`);
 	logger.break();
@@ -3213,7 +3395,7 @@ const printProjectMetadata = (project) => {
 
 //#endregion
 //#region src/output/scan-progress.ts
-const SPINNER_FRAMES = [
+const SPINNER_FRAMES$1 = [
 	"⠋",
 	"⠙",
 	"⠹",
@@ -3226,20 +3408,20 @@ const SPINNER_FRAMES = [
 	"⠏"
 ];
 const shouldRenderLiveScanProgress = () => Boolean(process.stderr.isTTY) && process.env.CI !== "true" && process.env.CI !== "1";
-const formatElapsed = (elapsedMs) => elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`;
+const formatElapsed$1 = (elapsedMs) => elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`;
 const truncateText = (text, maxLength = 52) => text.length <= maxLength ? text : `${text.slice(0, maxLength - 1)}…`;
 const getIssueSummary = (result) => {
 	const errors = result.diagnostics.filter((d) => d.severity === "error").length;
 	const warnings = result.diagnostics.filter((d) => d.severity === "warning").length;
-	if (errors === 0 && warnings === 0) return `Done (0 issues, ${formatElapsed(result.elapsed)})`;
+	if (errors === 0 && warnings === 0) return `Done (0 issues, ${formatElapsed$1(result.elapsed)})`;
 	const parts = [];
 	if (errors > 0) parts.push(`${errors} error${errors === 1 ? "" : "s"}`);
 	if (warnings > 0) parts.push(`${warnings} warning${warnings === 1 ? "" : "s"}`);
-	return `Done (${parts.join(", ")}, ${formatElapsed(result.elapsed)})`;
+	return `Done (${parts.join(", ")}, ${formatElapsed$1(result.elapsed)})`;
 };
-const getStatusParts = (state, frameIndex) => {
+const getStatusParts$1 = (state, frameIndex) => {
 	if (state.status === "running") return {
-		icon: highlighter.info(SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]),
+		icon: highlighter.info(SPINNER_FRAMES$1[frameIndex % SPINNER_FRAMES$1.length]),
 		detail: highlighter.info("Running")
 	};
 	if (state.status === "done") {
@@ -3278,11 +3460,11 @@ const renderScanProgressBlock = (states, frameIndex) => {
 	const headingStatus = completedCount === states.length ? highlighter.dim("complete") : runningCount > 0 ? highlighter.dim(`${runningCount} running`) : highlighter.dim("starting");
 	return `${[`  ${highlighter.bold(`Engines ${completedCount}/${states.length}`)} ${headingStatus}`, ...states.map((state) => {
 		const label = getEngineLabel(state.engine).padEnd(labelWidth, " ");
-		const { icon, detail } = getStatusParts(state, frameIndex);
+		const { icon, detail } = getStatusParts$1(state, frameIndex);
 		return `    ${icon} ${label}  ${detail}`;
 	})].join("\n")}\n`;
 };
-const clearRenderedLines$1 = (lineCount) => {
+const clearRenderedLines$2 = (lineCount) => {
 	if (lineCount === 0) return;
 	process.stderr.write(`\u001B[${lineCount}F`);
 	for (let index = 0; index < lineCount; index += 1) {
@@ -3334,7 +3516,7 @@ var ScanProgressRenderer = class {
 	}
 	render() {
 		if (!shouldRenderLiveScanProgress()) return;
-		if (this.previousLineCount > 0) clearRenderedLines$1(this.previousLineCount);
+		if (this.previousLineCount > 0) clearRenderedLines$2(this.previousLineCount);
 		const output = renderScanProgressBlock(this.states, this.frameIndex);
 		process.stderr.write(output);
 		this.previousLineCount = output.split("\n").length - 1;
@@ -3976,6 +4158,42 @@ const doctorCommand = async (directory) => {
 	printDoctorConclusion(isAllGood());
 };
 
+//#endregion
+//#region src/engines/ai-slop/dead-patterns-fix.ts
+/**
+* Removes lines flagged as fixable by the trivial-comment and dead-pattern detectors.
+* Specifically handles:
+*   - ai-slop/trivial-comment  (trivial comments that restate the code)
+*   - ai-slop/console-leftover (console.log/debug/info left in production)
+*/
+const fixDeadPatterns = async (context) => {
+	const fixable = [...await detectTrivialComments(context), ...await detectDeadPatterns(context)].filter((d) => d.fixable);
+	if (fixable.length === 0) return;
+	const byFile = /* @__PURE__ */ new Map();
+	for (const d of fixable) {
+		const absolute = path.isAbsolute(d.filePath) ? d.filePath : path.join(context.rootDirectory, d.filePath);
+		const lines = byFile.get(absolute) ?? /* @__PURE__ */ new Set();
+		lines.add(d.line);
+		byFile.set(absolute, lines);
+	}
+	for (const [filePath, lineNumbers] of byFile) {
+		if (!fs.existsSync(filePath)) continue;
+		const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+		const filtered = [];
+		for (let i = 0; i < lines.length; i++) {
+			const lineNo = i + 1;
+			if (lineNumbers.has(lineNo)) continue;
+			filtered.push(lines[i]);
+		}
+		const collapsed = [];
+		for (const line of filtered) {
+			if (line.trim() === "" && collapsed.length > 0 && collapsed[collapsed.length - 1].trim() === "") continue;
+			collapsed.push(line);
+		}
+		fs.writeFileSync(filePath, collapsed.join("\n"));
+	}
+};
+
 //#endregion
 //#region src/engines/ai-slop/unused-imports-fix.ts
 const fixUnusedImports = async (context) => {
@@ -3997,7 +4215,7 @@ const fixUnusedImports = async (context) => {
 		for (const [lineNo, syms] of symbolsByLine) {
 			const lineIdx = lineNo - 1;
 			const allUnused = syms.every((s) => unusedNames.has(s.name));
-			const importSpan = getImportSpan(lineIdx, analysis.importLines);
+			const importSpan = JS_EXTENSIONS.has(analysis.ext) ? getJsImportSpan(lines, lineIdx) : [lineIdx];
 			if (allUnused) for (const idx of importSpan) linesToRemove.add(idx);
 			else if (JS_EXTENSIONS.has(analysis.ext)) rewriteJsImportSpan(lines, importSpan, syms, unusedNames);
 			else if (PY_EXTENSIONS.has(analysis.ext)) rewritePyImportLine(lines, lineIdx, syms, unusedNames);
@@ -4010,11 +4228,14 @@ const fixUnusedImports = async (context) => {
 		fs.writeFileSync(filePath, filtered.join("\n"));
 	}
 };
-const getImportSpan = (startIdx, importLines) => {
+const getJsImportSpan = (lines, startIdx) => {
 	const span = [startIdx];
+	let fullImport = lines[startIdx]?.trim() ?? "";
+	if (!fullImport.startsWith("import ")) return span;
 	let idx = startIdx + 1;
-	while (importLines.has(idx)) {
+	while (!fullImport.includes("from") && idx < lines.length) {
 		span.push(idx);
+		fullImport += ` ${lines[idx].trim()}`;
 		idx++;
 	}
 	return span;
@@ -4024,23 +4245,31 @@ const rewriteJsImportSpan = (lines, span, syms, unusedNames) => {
 	const namedMatch = fullImport.match(/\{([^}]+)\}/s);
 	if (!namedMatch) return;
 	const unusedNamed = syms.filter((s) => !s.isDefault && !s.isNamespace && unusedNames.has(s.name));
-	if (unusedNamed.length === 0) return;
+	const defaultUnused = syms.some((s) => s.isDefault && unusedNames.has(s.name));
+	if (unusedNamed.length === 0 && !defaultUnused) return;
 	const unusedNamedSet = new Set(unusedNamed.map((s) => s.name));
 	const keptSpecifiers = namedMatch[1].split(",").map((s) => s.trim()).filter(Boolean).filter((spec) => {
 		const parts = spec.split(/\s+as\s+/);
 		const localName = parts.length > 1 ? parts[1].trim().replace(/^type\s+/, "") : parts[0].trim().replace(/^type\s+/, "");
 		return !unusedNamedSet.has(localName);
 	});
+	const fromMatch = fullImport.match(/from\s+["']([^"']+)["'];?/);
+	const fromClause = fromMatch ? `from "${fromMatch[1]}"` : "";
 	if (keptSpecifiers.length === 0) {
-		if (syms.find((s) => s.isDefault && !unusedNames.has(s.name))) {
-			const rewritten = fullImport.replace(/,\s*\{[^}]*\}/s, "").replace(/\{[^}]*\}\s*,?\s*/s, "");
-			lines[span[0]] = rewritten.replace(/\n/g, " ").replace(/\s+/g, " ");
+		const usedDefault = syms.find((s) => s.isDefault && !unusedNames.has(s.name));
+		if (usedDefault) {
+			const defaultMatch = fullImport.match(/^import\s+(\w+)/);
+			const defaultName = defaultMatch ? defaultMatch[1] : usedDefault.name;
+			lines[span[0]] = `import ${defaultName} ${fromClause};`;
 			for (let i = 1; i < span.length; i++) lines[span[i]] = REMOVE_MARKER;
-		}
+		} else for (const idx of span) lines[idx] = REMOVE_MARKER;
+		return;
+	}
+	if (defaultUnused) {
+		lines[span[0]] = `import { ${keptSpecifiers.join(", ")} } ${fromClause};`;
+		for (let i = 1; i < span.length; i++) lines[span[i]] = REMOVE_MARKER;
 		return;
 	}
-	const fromMatch = fullImport.match(/\}\s*(from\s+.+)$/s);
-	const fromClause = fromMatch ? fromMatch[1].trim() : "";
 	const importPrefix = fullImport.match(/^(import\s+(?:\w+\s*,\s*)?)/);
 	const prefix = importPrefix ? importPrefix[1] : "import ";
 	const wasMultiLine = span.length > 1;
@@ -4048,8 +4277,8 @@ const rewriteJsImportSpan = (lines, span, syms, unusedNames) => {
 	if (wasMultiLine && keptSpecifiers.length > 2) {
 		const indentMatch = lines[span[1]]?.match(/^(\s+)/);
 		const indent = indentMatch ? indentMatch[1] : "	";
-		newImport = `${prefix}{\n${keptSpecifiers.map((s) => `${indent}${s},`).join("\n")}\n} ${fromClause}`;
-	} else newImport = `${prefix}{ ${keptSpecifiers.join(", ")} } ${fromClause}`;
+		newImport = `${prefix}{\n${keptSpecifiers.map((s) => `${indent}${s},`).join("\n")}\n} ${fromClause};`;
+	} else newImport = `${prefix}{ ${keptSpecifiers.join(", ")} } ${fromClause};`;
 	lines[span[0]] = newImport;
 	for (let i = 1; i < span.length; i++) lines[span[i]] = REMOVE_MARKER;
 };
@@ -4070,7 +4299,289 @@ const rewritePyImportLine = (lines, lineIdx, syms, unusedNames) => {
 };
 
 //#endregion
-//#region src/commands/fix.ts
+//#region src/engines/lint/expo-doctor.ts
+var expo_doctor_exports = /* @__PURE__ */ __exportAll({ runExpoDoctor: () => runExpoDoctor });
+const esmRequire = createRequire(import.meta.url);
+const ISSUE_PREFIX = "✖ ";
+const resolveExpoDoctorScript = () => {
+	try {
+		const packageJsonPath = esmRequire.resolve("expo-doctor/package.json");
+		const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		const binRelativePath = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["expo-doctor"];
+		if (!binRelativePath) return null;
+		return path.join(path.dirname(packageJsonPath), binRelativePath);
+	} catch {
+		return null;
+	}
+};
+const toRuleSuffix = (title) => {
+	const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+	return slug.length > 0 ? slug : "issue";
+};
+const parseIssues = (output) => {
+	const lines = output.split("\n").map((line) => line.trimEnd());
+	const startIndex = lines.findIndex((line) => line.includes("Possible issues detected:"));
+	if (startIndex < 0) return [];
+	const issues = [];
+	let current = null;
+	let inAdvice = false;
+	for (let i = startIndex + 1; i < lines.length; i += 1) {
+		const line = lines[i].trim();
+		if (/^\d+\s+checks failed/.test(line)) break;
+		if (line.length === 0) continue;
+		if (line.startsWith(ISSUE_PREFIX)) {
+			if (current) issues.push(current);
+			current = {
+				title: line.slice(2).trim(),
+				details: [],
+				advice: []
+			};
+			inAdvice = false;
+			continue;
+		}
+		if (!current) continue;
+		if (line === "Advice:") {
+			inAdvice = true;
+			continue;
+		}
+		if (inAdvice) current.advice.push(line);
+		else current.details.push(line);
+	}
+	if (current) issues.push(current);
+	return issues;
+};
+const parseConfigError = (output) => {
+	const line = output.split("\n").find((candidate) => candidate.trim().startsWith("ConfigError:"));
+	return line ? line.trim() : null;
+};
+const toDiagnostics = (issues) => issues.map((issue) => {
+	const helpParts = [issue.details.join(" ").trim(), issue.advice.join(" ").trim()].filter((part) => part.length > 0);
+	return {
+		filePath: "package.json",
+		engine: "lint",
+		rule: `expo-doctor/${toRuleSuffix(issue.title)}`,
+		severity: "warning",
+		message: `Expo Doctor: ${issue.title}`,
+		help: helpParts.join(" "),
+		line: 0,
+		column: 0,
+		category: "Expo",
+		fixable: false
+	};
+});
+const runExpoDoctor = async (context) => {
+	const scriptPath = resolveExpoDoctorScript();
+	let stdout = "";
+	let stderr = "";
+	try {
+		if (scriptPath) {
+			const result = await runSubprocess(process.execPath, [
+				scriptPath,
+				context.rootDirectory,
+				"--verbose"
+			], {
+				cwd: context.rootDirectory,
+				timeout: 12e4
+			});
+			stdout = result.stdout;
+			stderr = result.stderr;
+		} else {
+			const result = await runSubprocess("npx", [
+				"--yes",
+				"expo-doctor",
+				context.rootDirectory,
+				"--verbose"
+			], {
+				cwd: context.rootDirectory,
+				timeout: 12e4
+			});
+			stdout = result.stdout;
+			stderr = result.stderr;
+		}
+	} catch {
+		return [];
+	}
+	const output = [stdout, stderr].filter(Boolean).join("\n");
+	if (!output) return [];
+	const configError = parseConfigError(output);
+	if (configError) return [{
+		filePath: "package.json",
+		engine: "lint",
+		rule: "expo-doctor/config-error",
+		severity: "warning",
+		message: configError,
+		help: "Install project dependencies, then re-run `aislop scan`.",
+		line: 0,
+		column: 0,
+		category: "Expo",
+		fixable: false
+	}];
+	return toDiagnostics(parseIssues(output));
+};
+
+//#endregion
+//#region src/output/fix-progress.ts
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const shouldRenderLive = () => Boolean(process.stderr.isTTY) && process.env.CI !== "true" && process.env.CI !== "1";
+const formatElapsed = (elapsedMs) => elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`;
+const getStepSummary = (result) => {
+	if (result.failed) return `Failed (${result.afterIssues} remain)`;
+	if (result.beforeIssues === 0) return `0 issues, ${formatElapsed(result.elapsedMs)}`;
+	if (result.afterIssues === 0) return `${result.resolvedIssues} resolved, ${formatElapsed(result.elapsedMs)}`;
+	if (result.resolvedIssues > 0) return `${result.resolvedIssues} resolved, ${result.afterIssues} remaining, ${formatElapsed(result.elapsedMs)}`;
+	return `no changes, ${result.afterIssues} issue${result.afterIssues === 1 ? "" : "s"}, ${formatElapsed(result.elapsedMs)}`;
+};
+const getStatusParts = (state, frameIndex) => {
+	if (state.status === "running") return {
+		icon: highlighter.info(SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]),
+		detail: highlighter.info("Running")
+	};
+	if (state.status === "done" && state.result) return {
+		icon: state.result.afterIssues > 0 ? highlighter.warn("!") : highlighter.success("✓"),
+		detail: highlighter.dim(`Done (${getStepSummary(state.result)})`)
+	};
+	if (state.status === "failed" && state.result) return {
+		icon: highlighter.error("✗"),
+		detail: highlighter.dim(`Failed (${getStepSummary(state.result)})`)
+	};
+	return {
+		icon: highlighter.dim("○"),
+		detail: highlighter.dim("Waiting")
+	};
+};
+const clearRenderedLines$1 = (lineCount) => {
+	if (lineCount === 0) return;
+	process.stderr.write(`\u001B[${lineCount}F`);
+	for (let index = 0; index < lineCount; index += 1) {
+		process.stderr.write("\x1B[2K");
+		if (index < lineCount - 1) process.stderr.write("\x1B[1E");
+	}
+	if (lineCount > 1) process.stderr.write(`\u001B[${lineCount - 1}F`);
+};
+const renderFixProgressBlock = (states, frameIndex) => {
+	if (states.length === 0) return `  ${highlighter.bold("Fixes 0/0")} ${highlighter.dim("nothing to run")}\n`;
+	const completedCount = states.filter((s) => s.status === "done" || s.status === "failed").length;
+	const runningCount = states.filter((s) => s.status === "running").length;
+	const labelWidth = Math.max(...states.map((s) => s.name.length));
+	const headingStatus = completedCount === states.length ? highlighter.dim("complete") : runningCount > 0 ? highlighter.dim(`${runningCount} running`) : highlighter.dim("starting");
+	return `${[`  ${highlighter.bold(`Fixes ${completedCount}/${states.length}`)} ${headingStatus}`, ...states.map((state) => {
+		const label = state.name.padEnd(labelWidth, " ");
+		const { icon, detail } = getStatusParts(state, frameIndex);
+		return `    ${icon} ${label}  ${detail}`;
+	})].join("\n")}\n`;
+};
+var FixProgressRenderer = class {
+	states;
+	previousLineCount = 0;
+	frameIndex = 0;
+	timer;
+	live;
+	constructor(stepNames) {
+		this.states = stepNames.map((name) => ({
+			name,
+			status: "pending"
+		}));
+		this.live = shouldRenderLive();
+	}
+	isLive() {
+		return this.live;
+	}
+	start() {
+		if (!this.live) return;
+		this.render();
+		this.timer = setInterval(() => {
+			this.frameIndex += 1;
+			this.render();
+		}, 100);
+		this.timer.unref();
+	}
+	markStarted(name) {
+		const state = this.states.find((s) => s.name === name);
+		if (!state) return;
+		state.status = "running";
+		this.render();
+	}
+	markComplete(name, result) {
+		const state = this.states.find((s) => s.name === name);
+		if (!state) return;
+		state.status = result.failed ? "failed" : "done";
+		state.result = result;
+		this.render();
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+		if (!this.live) return;
+		this.render();
+	}
+	render() {
+		if (!this.live) return;
+		if (this.previousLineCount > 0) clearRenderedLines$1(this.previousLineCount);
+		const output = renderFixProgressBlock(this.states, this.frameIndex);
+		process.stderr.write(output);
+		this.previousLineCount = output.split("\n").length - 1;
+	}
+};
+
+//#endregion
+//#region src/commands/fix-force.ts
+const getJsAuditFixCommand = (rootDirectory) => {
+	if (fs.existsSync(path.join(rootDirectory, "pnpm-lock.yaml"))) return {
+		command: "pnpm",
+		args: ["audit", "--fix"]
+	};
+	if (fs.existsSync(path.join(rootDirectory, "package-lock.json")) || fs.existsSync(path.join(rootDirectory, "package.json"))) return {
+		command: "npm",
+		args: ["audit", "fix"]
+	};
+	return null;
+};
+const fixDependencyAudit = async (context) => {
+	const auditFix = getJsAuditFixCommand(context.rootDirectory);
+	if (!auditFix) return;
+	const result = await runSubprocess(auditFix.command, auditFix.args, {
+		cwd: context.rootDirectory,
+		timeout: 18e4
+	});
+	if (result.exitCode !== 0) throw new Error(result.stderr || result.stdout || `${auditFix.command} audit fix failed`);
+};
+const fixExpoDependencies = async (context) => {
+	if ((await runSubprocess("npx", [
+		"--yes",
+		"expo",
+		"install",
+		"--fix"
+	], {
+		cwd: context.rootDirectory,
+		timeout: 18e4
+	})).exitCode === 0) return;
+	const checkResult = await runSubprocess("npx", [
+		"--yes",
+		"expo",
+		"install",
+		"--check"
+	], {
+		cwd: context.rootDirectory,
+		timeout: 18e4
+	});
+	if (checkResult.exitCode !== 0) throw new Error(checkResult.stderr || checkResult.stdout || "expo dependency check failed");
+};
+
+//#endregion
+//#region src/commands/fix-step.ts
 const uniqueFiles = (diagnostics) => [...new Set(diagnostics.map((d) => d.filePath))];
 const uniqueFileCount = (diagnostics) => uniqueFiles(diagnostics).length;
 const getFilePreviewLines = (title, files, verbose) => {
@@ -4094,7 +4605,8 @@ const getStepStatusLine = (result, name, elapsedLabel) => {
 	if (result.resolvedIssues > 0) return highlighter.warn(`  ! ${name}: done (${result.resolvedIssues} resolved, ${result.afterIssues} remaining, ${elapsedLabel})`);
 	return highlighter.warn(`  ! ${name}: done (no auto-fix changes, ${result.afterIssues} issue${result.afterIssues === 1 ? "" : "s"}, ${elapsedLabel})`);
 };
-const runFixStep = async (name, detect, applyFix, options) => {
+const runFixStep = async (name, detect, applyFix, options, progress) => {
+	progress.markStarted(name);
 	const stepStart = performance.now();
 	const before = await detect();
 	let applyError = null;
@@ -4114,28 +4626,21 @@ const runFixStep = async (name, detect, applyFix, options) => {
 		failed: applyError !== null && before.length === after.length,
 		elapsedMs
 	};
-	const lines = [getStepStatusLine(result, name, formatElapsed$1(result.elapsedMs))];
-	if (applyError) {
-		const reasonLines = getReasonLines(applyError instanceof Error ? applyError.message : String(applyError));
-		const reasonToPrint = options.verbose ? reasonLines.printable : reasonLines.firstLine;
-		for (const line of reasonToPrint.split("\n")) lines.push(highlighter.dim(`      ${line}`));
-		if (!options.verbose && reasonLines.printable !== reasonToPrint) lines.push(highlighter.dim("      Re-run with -d for full tool output."));
-	}
-	lines.push(...getFilePreviewLines("Affected", uniqueFiles(before), options.verbose));
-	if (after.length > 0) lines.push(...getFilePreviewLines("Remaining", uniqueFiles(after), options.verbose));
-	process.stdout.write(`${lines.join("\n")}\n\n`);
+	progress.markComplete(name, result);
+	if (!progress.isLive()) {
+		const lines = [getStepStatusLine(result, name, formatElapsed$2(result.elapsedMs))];
+		if (applyError) {
+			const reasonLines = getReasonLines(applyError instanceof Error ? applyError.message : String(applyError));
+			const reasonToPrint = options.verbose ? reasonLines.printable : reasonLines.firstLine;
+			for (const line of reasonToPrint.split("\n")) lines.push(highlighter.dim(`      ${line}`));
+			if (!options.verbose && reasonLines.printable !== reasonToPrint) lines.push(highlighter.dim("      Re-run with -d for full tool output."));
+		}
+		lines.push(...getFilePreviewLines("Affected", uniqueFiles(before), options.verbose));
+		if (after.length > 0) lines.push(...getFilePreviewLines("Remaining", uniqueFiles(after), options.verbose));
+		process.stdout.write(`${lines.join("\n")}\n\n`);
+	}
 	return result;
 };
-const createEngineContext = (rootDirectory, projectInfo, config) => ({
-	rootDirectory,
-	languages: projectInfo.languages,
-	frameworks: projectInfo.frameworks,
-	installedTools: projectInfo.installedTools,
-	config: {
-		quality: config.quality,
-		security: config.security
-	}
-});
 const summarizeFixRun = (steps) => {
 	const totals = steps.reduce((acc, step) => {
 		acc.beforeIssues += step.beforeIssues;
@@ -4155,6 +4660,19 @@ const summarizeFixRun = (steps) => {
 	} else logger.log(`  Fix summary: checked ${steps.length} step(s), resolved ${totals.resolvedIssues} issue(s), remaining ${totals.afterIssues}.`);
 	if (totals.failedSteps === 0 && totals.beforeIssues > 0 && totals.resolvedIssues === 0) logger.dim("  No auto-fixable changes were applied. Current findings are likely manual-fix categories.");
 };
+
+//#endregion
+//#region src/commands/fix.ts
+const createEngineContext = (rootDirectory, projectInfo, config) => ({
+	rootDirectory,
+	languages: projectInfo.languages,
+	frameworks: projectInfo.frameworks,
+	installedTools: projectInfo.installedTools,
+	config: {
+		quality: config.quality,
+		security: config.security
+	}
+});
 const fixCommand = async (directory, config, options = {
 	verbose: false,
 	showHeader: true
@@ -4166,38 +4684,98 @@ const fixCommand = async (directory, config, options = {
 	printProjectMetadata(projectInfo);
 	const context = createEngineContext(resolvedDir, projectInfo, config);
 	const steps = [];
-	if (config.engines["ai-slop"]) steps.push(await runFixStep("Unused imports", () => detectUnusedImports(context), () => fixUnusedImports(context), options));
+	const stepNames = [];
+	if (config.engines["ai-slop"]) {
+		stepNames.push("Unused imports");
+		stepNames.push("Dead code & comments");
+	}
+	if (config.engines.lint) {
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) stepNames.push("JS/TS lint fixes");
+		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) stepNames.push("Python lint fixes");
+	}
+	if (config.engines["code-quality"]) {
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) stepNames.push("Unused dependencies");
+	}
+	if (config.engines.format) {
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) stepNames.push("JS/TS formatting");
+		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) stepNames.push("Python formatting");
+		if (projectInfo.languages.includes("go") && projectInfo.installedTools.gofmt) stepNames.push("Go formatting");
+	}
+	if (options.force) {
+		if (config.engines.security) stepNames.push("Dependency audit fixes");
+		if (projectInfo.frameworks.includes("expo")) stepNames.push("Expo dependency alignment");
+	}
+	const progress = new FixProgressRenderer(stepNames);
+	progress.start();
+	if (config.engines["ai-slop"]) {
+		steps.push(await runFixStep("Unused imports", () => detectUnusedImports(context), () => fixUnusedImports(context), options, progress));
+		const detectFixableSlop = async () => {
+			const [comments, dead] = await Promise.all([detectTrivialComments(context), detectDeadPatterns(context)]);
+			return [...comments, ...dead].filter((d) => d.fixable);
+		};
+		steps.push(await runFixStep("Dead code & comments", detectFixableSlop, () => fixDeadPatterns(context), options, progress));
+	}
 	if (config.engines.lint) {
-		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("JS/TS lint fixes", () => runOxlint(context), () => fixOxlint(context), options));
-		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) steps.push(await runFixStep("Python lint fixes", () => runRuffLint(context), () => fixRuffLint(resolvedDir), options));
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("JS/TS lint fixes", () => runOxlint(context), () => options.force ? fixOxlintForce(context) : fixOxlint(context), options, progress));
+		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) steps.push(await runFixStep("Python lint fixes", () => runRuffLint(context), () => options.force ? fixRuffLintForce(resolvedDir) : fixRuffLint(resolvedDir), options, progress));
 		else if (projectInfo.languages.includes("python")) logger.warn("  Python detected but ruff is not installed; skipping Python lint fixes.");
 	}
 	if (config.engines["code-quality"]) {
-		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("Unused dependencies", () => runKnipDependencyCheck(resolvedDir), () => fixUnusedDependencies(resolvedDir), options));
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("Unused dependencies", () => runKnipDependencyCheck(resolvedDir), () => fixUnusedDependencies(resolvedDir), options, progress));
 	}
 	if (config.engines.format) {
-		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("JS/TS formatting", () => runBiomeFormat(context), () => fixBiomeFormat(context), options));
-		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) steps.push(await runFixStep("Python formatting", () => runRuffFormat(context), () => fixRuffFormat(resolvedDir), options));
+		if (projectInfo.languages.includes("typescript") || projectInfo.languages.includes("javascript")) steps.push(await runFixStep("JS/TS formatting", () => runBiomeFormat(context), () => fixBiomeFormat(context), options, progress));
+		if (projectInfo.languages.includes("python") && projectInfo.installedTools.ruff) steps.push(await runFixStep("Python formatting", () => runRuffFormat(context), () => fixRuffFormat(resolvedDir), options, progress));
 		else if (projectInfo.languages.includes("python")) logger.warn("  Python detected but ruff is not installed; skipping Python formatting fixes.");
-		if (projectInfo.languages.includes("go") && projectInfo.installedTools.gofmt) steps.push(await runFixStep("Go formatting", () => runGofmt(context), () => fixGofmt(resolvedDir), options));
+		if (projectInfo.languages.includes("go") && projectInfo.installedTools.gofmt) steps.push(await runFixStep("Go formatting", () => runGofmt(context), () => fixGofmt(resolvedDir), options, progress));
 		else if (projectInfo.languages.includes("go")) logger.warn("  Go detected but gofmt is not installed; skipping Go formatting fixes.");
 	}
+	if (options.force) {
+		if (config.engines.security) steps.push(await runFixStep("Dependency audit fixes", () => runDependencyAudit(context), () => fixDependencyAudit(context), options, progress));
+		if (projectInfo.frameworks.includes("expo")) steps.push(await runFixStep("Expo dependency alignment", () => runExpoDoctor(context), () => fixExpoDependencies(context), options, progress));
+	}
+	progress.stop();
+	const totalResolved = steps.reduce((sum, s) => sum + s.resolvedIssues, 0);
 	if (steps.length === 0) logger.dim("  No applicable auto-fixers found for this project.");
 	else {
 		logger.break();
 		summarizeFixRun(steps);
 	}
-	if (!isTelemetryDisabled(config.telemetry?.enabled)) {
-		const totalResolved = steps.reduce((sum, s) => sum + s.resolvedIssues, 0);
-		trackEvent({
-			command: "fix",
-			languages: projectInfo.languages,
-			fixSteps: steps.length,
-			fixResolved: totalResolved
-		});
-	}
+	if (!isTelemetryDisabled(config.telemetry?.enabled)) trackEvent({
+		command: "fix",
+		languages: projectInfo.languages,
+		fixSteps: steps.length,
+		fixResolved: totalResolved
+	});
 	logger.break();
-	logger.success("  ✓ Done. Run `aislop scan` to verify.");
+	const configDir = findConfigDir(resolvedDir);
+	const rulesPath = configDir ? path.join(configDir, RULES_FILE) : void 0;
+	const engineConfig = {
+		quality: config.quality,
+		security: config.security,
+		architectureRulesPath: config.engines.architecture ? rulesPath : void 0
+	};
+	const allDiagnostics = (await runEngines({
+		rootDirectory: resolvedDir,
+		languages: projectInfo.languages,
+		frameworks: projectInfo.frameworks,
+		installedTools: projectInfo.installedTools,
+		config: engineConfig
+	}, config.engines, () => {}, () => {})).flatMap((r) => r.diagnostics);
+	const scoreResult = calculateScore(allDiagnostics, config.scoring.weights, config.scoring.thresholds, projectInfo.sourceFileCount, config.scoring.smoothing);
+	const errors = allDiagnostics.filter((d) => d.severity === "error").length;
+	const warnings = allDiagnostics.filter((d) => d.severity === "warning").length;
+	const fixable = allDiagnostics.filter((d) => d.fixable).length;
+	const manual = errors + warnings - fixable;
+	const scoreColor = scoreResult.score >= config.scoring.thresholds.good ? highlighter.success : scoreResult.score >= config.scoring.thresholds.ok ? highlighter.warn : highlighter.error;
+	logger.log(highlighter.dim("------------------------------------------------------------"));
+	logger.log(highlighter.bold("Result"));
+	logger.log(`  Score: ${scoreColor(`${scoreResult.score}/100`)} ${scoreColor(`(${scoreResult.label})`)}`);
+	logger.log(`  Resolved: ${highlighter.success(String(totalResolved))} issue${totalResolved === 1 ? "" : "s"}`);
+	logger.log(`  Remaining: ${errors + warnings > 0 ? highlighter.warn(String(errors + warnings)) : highlighter.success("0")} (${errors} error${errors === 1 ? "" : "s"}, ${warnings} warning${warnings === 1 ? "" : "s"})`);
+	if (fixable > 0) logger.log(`  Auto-fixable: ${highlighter.info(String(fixable))}`);
+	if (manual > 0) logger.log(`  Manual effort: ${highlighter.dim(String(manual))}`);
+	logger.log(highlighter.dim("------------------------------------------------------------"));
 	logger.break();
 };
 
@@ -4558,7 +5136,7 @@ const program = new Command().name("aislop").description("The unified code quali
 }).addHelpText("after", `
 ${highlighter.dim("Commands:")}
   aislop scan [dir]      Full code quality scan
-  aislop fix [dir]       Auto-fix formatting and lint issues
+  aislop fix [dir]       Auto-fix ai slop in codebase
   aislop init [dir]      Initialize aislop config
   aislop doctor [dir]    Check installed tools
   aislop ci [dir]        CI-friendly JSON output
@@ -4570,7 +5148,8 @@ ${highlighter.dim("Examples:")}
   aislop scan -d         Scan with file/line details
   aislop scan --changes  Scan only changed files
   aislop scan --staged   Scan only staged files (for hooks)
-  aislop fix             Auto-fix issues
+  aislop fix             Auto-fix ai slop in codebase
+  aislop fix --force     Run aggressive fixes (includes audit and dependency alignment)
   aislop ci              JSON output for CI pipelines
 `);
 program.command("scan [directory]").description("Run full code quality scan").option("--changes", "only scan changed files").option("--staged", "only scan staged files").option("-d, --verbose", "show file details per rule").option("--json", "output JSON").action(async (directory = ".", _flags, command) => {
@@ -4586,9 +5165,12 @@ program.command("scan [directory]").description("Run full code quality scan").op
 		process.exit(exitCode);
 	}
 });
-program.command("fix [directory]").description("Auto-fix formatting and lint issues").option("-d, --verbose", "show detailed fix progress").action(async (directory = ".", _flags, command) => {
+program.command("fix [directory]").description("Auto-fix ai slop in codebase").option("-d, --verbose", "show detailed fix progress").option("-f, --force", "run aggressive fixes (audit and framework dependency alignment)").action(async (directory = ".", _flags, command) => {
 	const flags = command.optsWithGlobals();
-	await fixCommand(directory, loadConfig(directory), { verbose: Boolean(flags.verbose) });
+	await fixCommand(directory, loadConfig(directory), {
+		verbose: Boolean(flags.verbose),
+		force: Boolean(flags.force)
+	});
 });
 program.command("init [directory]").description("Initialize aislop config in project").action(async (directory = ".") => {
 	await initCommand(directory);
@@ -4613,4 +5195,4 @@ const main = async () => {
 main();
 
 //#endregion
-export { ENGINE_INFO as n, runSubprocess as r, APP_VERSION as t };
+export { ENGINE_INFO as n, APP_VERSION as t };