deep-slop 1.4.1

package/dist/file-utils-B_HFXhCs.js

@@ -0,0 +1,93 @@
+import { readFile } from "node:fs/promises";
+
+//#region src/utils/file-utils.ts
+/** Read file contents with encoding detection */
+async function readFileContent(filePath) {
+	let content = (await readFile(filePath)).toString("utf-8");
+	if (content.charCodeAt(0) === 65279) content = content.slice(1);
+	return content;
+}
+/** Detect BOM, CRLF, and other encoding anomalies */
+function detectEncodingAnomalies(content) {
+	const hasBom = content.charCodeAt(0) === 65279;
+	const hasCrlf = content.includes("\r\n");
+	const hasZwnbsp = content.includes("");
+	const lfOnly = (content.match(/(?<!\r)\n/g) ?? []).length;
+	const crlfCount = (content.match(/\r\n/g) ?? []).length;
+	return {
+		hasBom,
+		hasCrlf,
+		hasZwnbsp,
+		lineEnding: crlfCount > 0 && lfOnly > crlfCount ? "mixed" : crlfCount > 0 ? "crlf" : "lf"
+	};
+}
+/** Split content into lines with line numbers */
+function toLines(content) {
+	return content.split("\n").map((text, i) => ({
+		num: i + 1,
+		text
+	}));
+}
+/** Find all import statements in a file (regex-based, for quick scan) */
+function extractImports(content, language) {
+	const imports = [];
+	const lines = toLines(content);
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		if (language === "typescript" || language === "javascript") {
+			const jsMatch = trimmed.match(/^import\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/);
+			if (jsMatch) imports.push({
+				line: num,
+				source: jsMatch[1],
+				raw: trimmed,
+				isTypeOnly: trimmed.includes("import type"),
+				isDefault: !trimmed.includes("{")
+			});
+			const dynMatch = trimmed.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+			if (dynMatch) imports.push({
+				line: num,
+				source: dynMatch[1],
+				raw: trimmed,
+				isTypeOnly: false,
+				isDynamic: true
+			});
+			const reqMatch = trimmed.match(/(?:const|let|var)\s+[^=]*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+			if (reqMatch) imports.push({
+				line: num,
+				source: reqMatch[1],
+				raw: trimmed,
+				isTypeOnly: false,
+				isRequire: true
+			});
+		}
+		if (language === "python") {
+			const pyMatch = trimmed.match(/^from\s+([^\s]+)\s+import/);
+			if (pyMatch) imports.push({
+				line: num,
+				source: pyMatch[1],
+				raw: trimmed,
+				isTypeOnly: false
+			});
+			const pyImport = trimmed.match(/^import\s+([^\s]+)/);
+			if (pyImport) imports.push({
+				line: num,
+				source: pyImport[1],
+				raw: trimmed,
+				isTypeOnly: false
+			});
+		}
+		if (language === "go") {
+			const goMatch = trimmed.match(/"([^"]+)"/);
+			if (trimmed.startsWith("import") && goMatch) imports.push({
+				line: num,
+				source: goMatch[1],
+				raw: trimmed,
+				isTypeOnly: false
+			});
+		}
+	}
+	return imports;
+}
+
+//#endregion
+export { toLines as i, extractImports as n, readFileContent as r, detectEncodingAnomalies as t };

package/dist/format-lint-DeElllNm.js

@@ -0,0 +1,445 @@
+import { i as toLines, r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { extname, join, relative } from "node:path";
+import { readdir } from "node:fs/promises";
+
+//#region src/engines/format-lint/index.ts
+const ALL_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py",
+	".go",
+	".rs",
+	".rb",
+	".php",
+	".java",
+	".cs",
+	".swift",
+	".json",
+	".yaml",
+	".yml",
+	".css",
+	".html",
+	".md"
+]);
+const JS_TS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+function isRelevantFile(filePath) {
+	const ext = extname(filePath);
+	return ALL_EXTENSIONS.has(ext);
+}
+function isJsTsFile(filePath) {
+	const ext = extname(filePath);
+	return JS_TS_EXTENSIONS.has(ext);
+}
+/** Recursively collect file paths under root, respecting exclude list */
+async function collectFiles(root, exclude) {
+	const results = [];
+	async function walk(dir) {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry.name);
+			if (exclude.some((pat) => full.includes(pat))) continue;
+			if (entry.isDirectory()) await walk(full);
+			else if (entry.isFile() && isRelevantFile(full)) results.push(full);
+		}
+	}
+	await walk(root);
+	return results;
+}
+/** Make a diagnostic with sensible defaults for format-lint */
+function makeDiagnostic(overrides) {
+	return {
+		engine: "format-lint",
+		severity: "info",
+		column: 1,
+		category: "style",
+		fixable: false,
+		help: "",
+		...overrides
+	};
+}
+function detectInconsistentIndent(content, lines, filePath) {
+	const diagnostics = [];
+	const hasTab = /^[\t]/m.test(content);
+	const hasSpace = /^ [^\s]/m.test(content) || /^ {2,}/m.test(content);
+	if (!hasTab || !hasSpace) return diagnostics;
+	let tabLines = 0;
+	let spaceLines = 0;
+	const indentLines = [];
+	for (const { num, text } of lines) {
+		if (text.length === 0) continue;
+		const leading = text.match(/^[\t ]+/);
+		if (!leading) continue;
+		const indent = leading[0];
+		const usesTab = indent.includes("	");
+		const usesSpace = indent.includes(" ");
+		if (usesTab && !usesSpace) {
+			tabLines++;
+			indentLines.push({
+				num,
+				text,
+				usesTab: true
+			});
+		} else if (usesSpace && !usesTab) {
+			spaceLines++;
+			indentLines.push({
+				num,
+				text,
+				usesTab: false
+			});
+		}
+	}
+	if (tabLines === 0 || spaceLines === 0) return diagnostics;
+	const minorityIsTab = tabLines < spaceLines;
+	const minorityLines = indentLines.filter((l) => l.usesTab === minorityIsTab);
+	const majorityLabel = minorityIsTab ? "spaces" : "tabs";
+	const minorityLabel = minorityIsTab ? "tabs" : "spaces";
+	const reported = minorityLines.slice(0, 5);
+	for (const { num } of reported) diagnostics.push(makeDiagnostic({
+		filePath,
+		rule: "format-lint/inconsistent-indent",
+		message: `Mixed indentation: file uses ${majorityLabel} primarily but ${minorityLabel} on this line`,
+		line: num,
+		severity: "warning",
+		help: `Standardize on one indentation style (${majorityLabel}) throughout the file`,
+		fixable: true,
+		suggestion: {
+			type: "replace",
+			text: minorityIsTab ? "// Replace tabs with spaces" : "// Replace leading spaces with tabs",
+			confidence: .85,
+			reason: `Mixed indentation causes rendering differences across editors and breaks tooling that expects consistent indentation`
+		},
+		detail: {
+			majorityStyle: majorityLabel,
+			minorityStyle: minorityLabel,
+			minorityCount: minorityLines.length
+		}
+	}));
+	return diagnostics;
+}
+function detectInconsistentQuotes(content, lines, filePath) {
+	const diagnostics = [];
+	if (!isJsTsFile(filePath)) return diagnostics;
+	const singleQuoteRe = /(^|[^\\])'[^']*'/g;
+	const doubleQuoteRe = /(^|[^\\])"[^"]*"/g;
+	const isImportLine = (text) => /^\s*import\s+/.test(text) || /^\s*export\s+/.test(text);
+	let singleCount = 0;
+	let doubleCount = 0;
+	const quoteLines = [];
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		if (trimmed.length === 0) continue;
+		if (isImportLine(trimmed)) continue;
+		singleQuoteRe.lastIndex = 0;
+		doubleQuoteRe.lastIndex = 0;
+		const hasSingle = singleQuoteRe.test(trimmed);
+		const hasDouble = doubleQuoteRe.test(trimmed);
+		if (hasSingle) singleCount++;
+		if (hasDouble) doubleCount++;
+		if (hasSingle || hasDouble) quoteLines.push({
+			num,
+			hasSingle,
+			hasDouble
+		});
+	}
+	if (singleCount === 0 || doubleCount === 0) return diagnostics;
+	const majorityIsSingle = singleCount > doubleCount;
+	const majorityLabel = majorityIsSingle ? "single" : "double";
+	const minorityLabel = majorityIsSingle ? "double" : "single";
+	const minorityLines = quoteLines.filter((l) => majorityIsSingle ? l.hasDouble : l.hasSingle).slice(0, 5);
+	for (const { num } of minorityLines) diagnostics.push(makeDiagnostic({
+		filePath,
+		rule: "format-lint/inconsistent-quotes",
+		message: `Mixed quote styles: file primarily uses ${majorityLabel} quotes but ${minorityLabel} quotes here`,
+		line: num,
+		severity: "info",
+		help: `Standardize on ${majorityLabel} quotes throughout the file, or configure Prettier/ESLint to enforce a style`,
+		fixable: true,
+		suggestion: {
+			type: "replace",
+			text: `// Use ${majorityLabel} quotes consistently`,
+			confidence: .7,
+			reason: `Mixed quote styles are inconsistent; picking one style reduces noise in diffs and reviews`
+		},
+		detail: {
+			majorityStyle: majorityLabel,
+			minorityStyle: minorityLabel,
+			singleCount,
+			doubleCount
+		}
+	}));
+	return diagnostics;
+}
+function detectMaxLineLength(content, lines, filePath, maxLength) {
+	const diagnostics = [];
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		if (/^\s*import\s+/.test(trimmed)) continue;
+		if (/^https?:\/\//.test(trimmed)) continue;
+		if (text.length > maxLength) diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "format-lint/max-line-length",
+			message: `Line exceeds ${maxLength} characters (${text.length} chars)`,
+			line: num,
+			column: maxLength + 1,
+			severity: "info",
+			help: "Break long lines into multiple lines for readability, or configure Prettier printWidth",
+			fixable: false,
+			suggestion: {
+				type: "refactor",
+				text: "// Break into multiple lines",
+				confidence: .5,
+				reason: "Long lines require horizontal scrolling and reduce readability in code review and terminals"
+			},
+			detail: {
+				lineLength: text.length,
+				maxLength
+			}
+		}));
+	}
+	return diagnostics.slice(0, 10);
+}
+function detectInconsistentSemicolons(content, lines, filePath) {
+	const diagnostics = [];
+	if (!isJsTsFile(filePath)) return diagnostics;
+	const statementRe = /^(?:return|throw|const|let|var|export|import|function|class|interface|type|enum)\b/;
+	let withSemi = 0;
+	let withoutSemi = 0;
+	const semiLines = [];
+	for (const { num, text } of lines) {
+		const trimmed = text.trim();
+		if (trimmed.length === 0) continue;
+		if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) continue;
+		if (trimmed.startsWith("import ") || trimmed.startsWith("export type")) continue;
+		if (!(statementRe.test(trimmed) || /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*[=+\-*/]/.test(trimmed) || /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/.test(trimmed) || /^this\./.test(trimmed) || /^\./.test(trimmed))) continue;
+		const endsWithSemi = /;\s*$/.test(trimmed);
+		const endsWithoutSemi = /[^;{(\[]\s*$/.test(trimmed) && !trimmed.endsWith("{") && !trimmed.endsWith("(") && !trimmed.endsWith("[") && !trimmed.endsWith(",");
+		if (endsWithSemi) {
+			withSemi++;
+			semiLines.push({
+				num,
+				hasSemi: true
+			});
+		} else if (endsWithoutSemi && !trimmed.endsWith("}")) {
+			withoutSemi++;
+			semiLines.push({
+				num,
+				hasSemi: false
+			});
+		}
+	}
+	if (withSemi === 0 || withoutSemi === 0) return diagnostics;
+	const majorityHasSemi = withSemi > withoutSemi;
+	const minorityLabel = majorityHasSemi ? "without semicolons" : "with semicolons";
+	const majorityLabel = majorityHasSemi ? "with semicolons" : "without semicolons";
+	const minorityLines = semiLines.filter((l) => l.hasSemi !== majorityHasSemi).slice(0, 5);
+	for (const { num } of minorityLines) diagnostics.push(makeDiagnostic({
+		filePath,
+		rule: "format-lint/inconsistent-semicolons",
+		message: `Inconsistent semicolons: file mostly uses ${majorityLabel} but this line is ${minorityLabel}`,
+		line: num,
+		severity: "info",
+		help: `Standardize on one semicolon style: ${majorityLabel}. Configure ESLint semi rule or Prettier semi option`,
+		fixable: true,
+		suggestion: {
+			type: "replace",
+			text: majorityHasSemi ? "// Add semicolon" : "// Remove semicolon",
+			confidence: .75,
+			reason: "Inconsistent semicolon usage creates noise in diffs and makes the codebase harder to read"
+		},
+		detail: {
+			majorityStyle: majorityLabel,
+			withSemi,
+			withoutSemi
+		}
+	}));
+	return diagnostics;
+}
+function detectBlankLineCluster(content, lines, filePath) {
+	const diagnostics = [];
+	let blankRun = 0;
+	let runStartLine = 0;
+	for (const { num, text } of lines) if (text.trim().length === 0) {
+		if (blankRun === 0) runStartLine = num;
+		blankRun++;
+	} else {
+		if (blankRun >= 3) diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "format-lint/blank-line-cluster",
+			message: `${blankRun} consecutive blank lines — excessive whitespace`,
+			line: runStartLine,
+			severity: "suggestion",
+			help: "Reduce to 1-2 blank lines for readability. Most style guides recommend at most 2 blank lines between sections",
+			fixable: true,
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .95,
+				reason: "Excessive blank lines waste vertical space and add noise; 1-2 blank lines are sufficient for visual separation",
+				range: {
+					startLine: runStartLine + 1,
+					startCol: 1,
+					endLine: runStartLine + blankRun - 1,
+					endCol: 1
+				}
+			},
+			detail: {
+				blankCount: blankRun,
+				startLine: runStartLine
+			}
+		}));
+		blankRun = 0;
+	}
+	if (blankRun >= 3) diagnostics.push(makeDiagnostic({
+		filePath,
+		rule: "format-lint/blank-line-cluster",
+		message: `${blankRun} consecutive blank lines at end of file — excessive whitespace`,
+		line: runStartLine,
+		severity: "suggestion",
+		help: "Reduce to 1 blank line at end of file",
+		fixable: true,
+		suggestion: {
+			type: "delete",
+			text: "",
+			confidence: .95,
+			reason: "Excessive trailing blank lines add noise; one blank line is sufficient before EOF"
+		},
+		detail: {
+			blankCount: blankRun,
+			startLine: runStartLine
+		}
+	}));
+	return diagnostics;
+}
+function detectTrailingCommaInconsistency(content, lines, filePath) {
+	const diagnostics = [];
+	if (!isJsTsFile(filePath)) return diagnostics;
+	const closingLineRe = /^\s*[}\])]\s*[;,]?\s*$/;
+	const lastItemWithComma = /^\s*[^/].*,\s*$/;
+	const lastItemNoComma = /^\s*[^/].*[^,]\s*$/;
+	let trailingCount = 0;
+	let noTrailingCount = 0;
+	const commaLines = [];
+	for (let i = 0; i < lines.length - 1; i++) {
+		const current = lines[i];
+		const next = lines[i + 1];
+		const trimmed = current.text.trim();
+		if (trimmed.length === 0 || trimmed.startsWith("//")) continue;
+		if (!closingLineRe.test(next.text.trim())) continue;
+		const hasTrailing = lastItemWithComma.test(trimmed) && !trimmed.startsWith("//");
+		const noTrailing = lastItemNoComma.test(trimmed) && !trimmed.startsWith("//");
+		if (hasTrailing) {
+			trailingCount++;
+			commaLines.push({
+				num: current.num,
+				hasTrailing: true
+			});
+		} else if (noTrailing) {
+			noTrailingCount++;
+			commaLines.push({
+				num: current.num,
+				hasTrailing: false
+			});
+		}
+	}
+	if (trailingCount === 0 || noTrailingCount === 0) return diagnostics;
+	const majorityTrailing = trailingCount > noTrailingCount;
+	const minorityLabel = majorityTrailing ? "without trailing commas" : "with trailing commas";
+	const majorityLabel = majorityTrailing ? "with trailing commas" : "without trailing commas";
+	const minorityLines = commaLines.filter((l) => l.hasTrailing !== majorityTrailing).slice(0, 5);
+	for (const { num } of minorityLines) diagnostics.push(makeDiagnostic({
+		filePath,
+		rule: "format-lint/trailing-comma-inconsistency",
+		message: `Inconsistent trailing commas: file mostly ${majorityLabel} but this line is ${minorityLabel}`,
+		line: num,
+		severity: "info",
+		help: `Standardize trailing comma style. Configure ESLint comma-dangle or Prettier trailingComma`,
+		fixable: true,
+		suggestion: {
+			type: "replace",
+			text: majorityTrailing ? "// Add trailing comma" : "// Remove trailing comma",
+			confidence: .8,
+			reason: "Inconsistent trailing commas create diff noise and make refactoring error-prone"
+		},
+		detail: {
+			majorityStyle: majorityLabel,
+			trailingCount,
+			noTrailingCount
+		}
+	}));
+	return diagnostics;
+}
+const formatLintEngine = {
+	name: "format-lint",
+	description: "Format linting: mixed indentation, inconsistent quotes, max line length, inconsistent semicolons, blank line clusters, trailing comma inconsistency",
+	supportedLanguages: [
+		"typescript",
+		"javascript",
+		"tsx",
+		"jsx",
+		"python",
+		"go",
+		"rust",
+		"ruby",
+		"php",
+		"java",
+		"csharp",
+		"swift"
+	],
+	async run(context) {
+		const start = Date.now();
+		const diagnostics = [];
+		const { rootDirectory, config, files: specifiedFiles } = context;
+		const maxLineLength = config.format?.maxLineLength ?? 120;
+		const filePaths = specifiedFiles ? specifiedFiles.filter(isRelevantFile) : await collectFiles(rootDirectory, config.exclude);
+		if (filePaths.length === 0) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: Date.now() - start,
+			skipped: true,
+			skipReason: "No relevant files found to analyze"
+		};
+		for (const fp of filePaths) try {
+			const content = await readFileContent(fp);
+			const relPath = relative(rootDirectory, fp);
+			const lines = toLines(content);
+			diagnostics.push(...detectInconsistentIndent(content, lines, relPath));
+			diagnostics.push(...detectInconsistentQuotes(content, lines, relPath));
+			diagnostics.push(...detectMaxLineLength(content, lines, relPath, maxLineLength));
+			diagnostics.push(...detectInconsistentSemicolons(content, lines, relPath));
+			diagnostics.push(...detectBlankLineCluster(content, lines, relPath));
+			diagnostics.push(...detectTrailingCommaInconsistency(content, lines, relPath));
+		} catch {}
+		const seen = /* @__PURE__ */ new Set();
+		const unique = diagnostics.filter((d) => {
+			const key = `${d.filePath}:${d.line}:${d.rule}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		return {
+			engine: this.name,
+			diagnostics: unique,
+			elapsed: Date.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { formatLintEngine };