deep-slop 1.4.1

package/dist/syntax-deep-ZQYMutky.js

@@ -0,0 +1,624 @@
+import { i as toLines, r as readFileContent, t as detectEncodingAnomalies } from "./file-utils-B_HFXhCs.js";
+import { join, relative } from "node:path";
+import { writeFile } from "node:fs/promises";
+
+//#region src/engines/syntax-deep/index.ts
+/** Characters that don't need escaping inside a regex character class [...] */
+const UNNECESSARY_CLASS_ESCAPES = new Set([
+	".",
+	"/",
+	"-",
+	" ",
+	":",
+	";",
+	",",
+	"!",
+	"#",
+	"%",
+	"&",
+	"(",
+	")",
+	"<",
+	"=",
+	">",
+	"@",
+	"]",
+	"^",
+	"_",
+	"`",
+	"{",
+	"}",
+	"|",
+	"~"
+]);
+/** Unicode control / invisible characters to flag as anomalies */
+const UNICODE_ANOMALY_RANGES = [
+	{
+		lo: 0,
+		hi: 8,
+		name: "C0 control char"
+	},
+	{
+		lo: 11,
+		hi: 12,
+		name: "C0 control char"
+	},
+	{
+		lo: 14,
+		hi: 31,
+		name: "C0 control char"
+	},
+	{
+		lo: 127,
+		hi: 127,
+		name: "DEL control char"
+	},
+	{
+		lo: 8203,
+		hi: 8203,
+		name: "zero-width space"
+	},
+	{
+		lo: 8204,
+		hi: 8205,
+		name: "zero-width joiner/non-joiner"
+	},
+	{
+		lo: 8206,
+		hi: 8207,
+		name: "RTL/LTR mark"
+	},
+	{
+		lo: 8234,
+		hi: 8238,
+		name: "RTL/LTR override/embedding"
+	},
+	{
+		lo: 8294,
+		hi: 8297,
+		name: "isolate/override"
+	},
+	{
+		lo: 65279,
+		hi: 65279,
+		name: "ZWNBSP/BOM"
+	},
+	{
+		lo: 65529,
+		hi: 65531,
+		name: "interlinear annotation"
+	}
+];
+function makeDiagnostic(filePath, rule, severity, message, help, line, column, fixable, suggestion, detail) {
+	return {
+		filePath,
+		engine: "syntax-deep",
+		rule: `syntax-deep/${rule}`,
+		severity,
+		message,
+		help,
+		line,
+		column,
+		category: "syntax",
+		fixable,
+		suggestion,
+		detail
+	};
+}
+/** Collect all files to scan from context */
+async function collectFiles(context) {
+	if (context.files && context.files.length > 0) return context.files;
+	const root = context.rootDirectory;
+	const exclude = context.config.exclude ?? [];
+	const extensions = new Set([
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".py",
+		".go",
+		".rs",
+		".rb",
+		".php",
+		".java",
+		".json",
+		".yaml",
+		".yml",
+		".toml",
+		".md",
+		".css",
+		".scss",
+		".less",
+		".html",
+		".vue",
+		".svelte"
+	]);
+	const files = [];
+	async function walk(dir) {
+		let entries;
+		try {
+			const { readdir } = await import("node:fs/promises");
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(dir, entry.name);
+			const rel = relative(root, full);
+			if (exclude.some((pat) => rel.startsWith(pat) || entry.name === pat)) continue;
+			if (entry.isDirectory()) await walk(full);
+			else if (entry.isFile()) {
+				const ext = entry.name.substring(entry.name.lastIndexOf("."));
+				if (extensions.has(ext)) files.push(rel);
+			}
+		}
+	}
+	await walk(root);
+	return files;
+}
+/** Read raw buffer to detect BOM at byte level */
+async function readRawBytes(filePath) {
+	const { readFile: readBuf } = await import("node:fs/promises");
+	return readBuf(filePath);
+}
+/** 1. BOM & ZWNBSP detection */
+function checkBomAndZwnbsp(content, filePath, rawBuf) {
+	const diagnostics = [];
+	const anomalies = detectEncodingAnomalies(content);
+	if (rawBuf.length >= 3 && rawBuf[0] === 239 && rawBuf[1] === 187 && rawBuf[2] === 191) diagnostics.push(makeDiagnostic(filePath, "bom-present", "warning", "File starts with UTF-8 BOM (U+FEFF)", "BOM can cause issues with shebangs, concatenation, and some parsers. Remove it.", 1, 1, true, {
+		type: "replace",
+		text: content.startsWith("") ? content.slice(1) : content,
+		range: {
+			startLine: 1,
+			startCol: 1,
+			endLine: 1,
+			endCol: 4
+		},
+		confidence: 1,
+		reason: "Strip BOM to normalize file encoding"
+	}));
+	if (anomalies.hasZwnbsp) {
+		const lines = toLines(content);
+		for (const { num, text } of lines) {
+			const idx = text.indexOf("");
+			if (idx !== -1) diagnostics.push(makeDiagnostic(filePath, "zwnbsp-mid-file", "warning", `Zero-width no-break space (U+FEFF) found at column ${idx + 1}`, "ZWNBSP mid-file is invisible and can cause subtle bugs. Remove it.", num, idx + 1, true, {
+				type: "replace",
+				text: text.replace(/\uFEFF/g, ""),
+				range: {
+					startLine: num,
+					startCol: idx + 1,
+					endLine: num,
+					endCol: idx + 2
+				},
+				confidence: 1,
+				reason: "Remove invisible ZWNBSP character"
+			}));
+		}
+	}
+	return diagnostics;
+}
+/** 2 & 3. Line ending checks: CRLF and mixed */
+function checkLineEndings(content, filePath) {
+	const diagnostics = [];
+	const anomalies = detectEncodingAnomalies(content);
+	if (anomalies.lineEnding === "crlf") {
+		const lines = content.split("\n");
+		let firstCrlfLine = 0;
+		for (let i = 0; i < lines.length; i++) if (lines[i].endsWith("\r")) {
+			firstCrlfLine = i + 1;
+			break;
+		}
+		diagnostics.push(makeDiagnostic(filePath, "crlf-line-endings", "warning", "File uses CRLF (\\r\\n) line endings throughout", "Normalize to LF for cross-platform consistency. Git core.autocrlf can mask this.", firstCrlfLine || 1, 1, true, {
+			type: "replace",
+			text: content.replace(/\r\n/g, "\n"),
+			confidence: 1,
+			reason: "Normalize CRLF to LF"
+		}));
+	}
+	if (anomalies.lineEnding === "mixed") {
+		const crlfCount = (content.match(/\r\n/g) ?? []).length;
+		const lfOnlyCount = (content.match(/(?<!\r)\n/g) ?? []).length;
+		const lines = content.split("\n");
+		let firstMixedLine = 0;
+		for (let i = 0; i < lines.length; i++) if (lines[i].endsWith("\r")) {
+			firstMixedLine = i + 1;
+			break;
+		}
+		diagnostics.push(makeDiagnostic(filePath, "mixed-line-endings", "warning", `Mixed line endings: ${crlfCount} CRLF and ${lfOnlyCount} LF`, "Mixed line endings cause noisy git diffs and can break some tools. Normalize to LF.", firstMixedLine || 1, 1, true, {
+			type: "replace",
+			text: content.replace(/\r\n/g, "\n"),
+			confidence: 1,
+			reason: "Normalize all line endings to LF"
+		}, {
+			crlfCount,
+			lfOnlyCount
+		}));
+	}
+	return diagnostics;
+}
+/** 4. Invalid escape sequences in JS/TS string literals */
+function checkInvalidEscapes(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const escapeInStringRe = /(["'`])(?:[^\\]|\\.)*?\1/g;
+	for (const { num, text } of lines) {
+		const trimmed = text.trimStart();
+		if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+		let match;
+		escapeInStringRe.lastIndex = 0;
+		while ((match = escapeInStringRe.exec(text)) !== null) {
+			const fullMatch = match[0];
+			const quote = match[1];
+			const startPos = match.index;
+			for (let i = 1; i < fullMatch.length - 1; i++) if (fullMatch[i] === "\\") {
+				const nextChar = fullMatch[i + 1];
+				if (!nextChar) continue;
+				if ([
+					"n",
+					"r",
+					"t",
+					"b",
+					"f",
+					"v",
+					"\\",
+					"'",
+					"\"",
+					"`",
+					"0"
+				].includes(nextChar)) continue;
+				if (nextChar === "x") {
+					const hexPart = fullMatch.substring(i + 2, i + 4);
+					if (/^[0-9a-fA-F]{2}$/.test(hexPart)) {
+						i += 3;
+						continue;
+					}
+					diagnostics.push(makeDiagnostic(filePath, "invalid-escape-sequence", "warning", `Invalid escape sequence \\x without 2 hex digits`, "Use \\x followed by exactly 2 hex digits, or escape the backslash (\\\\x).", num, startPos + i + 1, true, {
+						type: "replace",
+						text: `\\x`,
+						range: {
+							startLine: num,
+							startCol: startPos + i + 1,
+							endLine: num,
+							endCol: startPos + i + 3
+						},
+						confidence: .9,
+						reason: "Fix invalid hex escape"
+					}));
+					continue;
+				}
+				if (nextChar === "u") {
+					const rest = fullMatch.substring(i + 2);
+					if (/^\{[0-9a-fA-F]+\}/.test(rest) || /^[0-9a-fA-F]{4}/.test(rest)) {
+						const unicodeMatch = rest.match(/^(\{[0-9a-fA-F]+\}|[0-9a-fA-F]{4})/);
+						if (unicodeMatch) i += 1 + unicodeMatch[0].length;
+						continue;
+					}
+					continue;
+				}
+				if (nextChar === "\n" || nextChar === "\r") continue;
+				if (/[sdwDWbBgBpP]/.test(nextChar)) diagnostics.push(makeDiagnostic(filePath, "regex-escape-in-string", "warning", `Escape sequence \\${nextChar} is a regex token but appears in a ${quote}-quoted string`, `If this is meant as a regex pattern, use a regex literal /\\${nextChar}/ instead of a string. If the backslash is literal, escape it as \\\\${nextChar}.`, num, startPos + i + 1, true, {
+					type: "replace",
+					text: `\\\\${nextChar}`,
+					range: {
+						startLine: num,
+						startCol: startPos + i + 1,
+						endLine: num,
+						endCol: startPos + i + 3
+					},
+					confidence: .7,
+					reason: "Likely regex-as-string confusion; escape the backslash or use a regex literal"
+				}, {
+					escapeChar: nextChar,
+					quoteType: quote
+				}));
+			}
+		}
+	}
+	return diagnostics;
+}
+/** 5. Unnecessary regex escapes inside character classes */
+function checkUnnecessaryRegexEscapes(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const charClassRe = /\[(?:[^\]\\]|\\.)*\]/g;
+	for (const { num, text } of lines) {
+		const regexLiteralRe = /\/(?:[^\\/]|\\.)+\/[gimsuy]*/g;
+		const regExpCtorRe = /new\s+RegExp\s*\(\s*(["'`])(?:[^\\]|\\.)*?\1/g;
+		const regexBodies = [];
+		let rmatch;
+		regexLiteralRe.lastIndex = 0;
+		while ((rmatch = regexLiteralRe.exec(text)) !== null) regexBodies.push({
+			start: rmatch.index,
+			body: rmatch[0],
+			kind: "literal"
+		});
+		regExpCtorRe.lastIndex = 0;
+		while ((rmatch = regExpCtorRe.exec(text)) !== null) regexBodies.push({
+			start: rmatch.index,
+			body: rmatch[0],
+			kind: "ctor"
+		});
+		for (const { start, body } of regexBodies) {
+			charClassRe.lastIndex = 0;
+			let cmatch;
+			while ((cmatch = charClassRe.exec(body)) !== null) {
+				const classContent = cmatch[0];
+				for (let i = 1; i < classContent.length - 1; i++) if (classContent[i] === "\\") {
+					const nextChar = classContent[i + 1];
+					if (!nextChar) continue;
+					if (UNNECESSARY_CLASS_ESCAPES.has(nextChar)) {
+						const absCol = start + cmatch.index + i + 1;
+						diagnostics.push(makeDiagnostic(filePath, "unnecessary-regex-class-escape", "info", `Unnecessary escape \\${nextChar} inside character class [${classContent}]`, `Inside [...], '${nextChar}' doesn't need escaping. Use ${nextChar} instead of \\${nextChar} for clarity.`, num, absCol + 1, true, {
+							type: "replace",
+							text: nextChar,
+							range: {
+								startLine: num,
+								startCol: absCol + 1,
+								endLine: num,
+								endCol: absCol + 3
+							},
+							confidence: .95,
+							reason: "Character doesn't need escaping inside a character class"
+						}, {
+							charClass: classContent,
+							escapedChar: nextChar
+						}));
+					}
+				}
+			}
+		}
+	}
+	return diagnostics;
+}
+/** 6. Number precision: floating point literals with >15 significant digits */
+function checkNumberPrecision(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const numberRe = /\b(?:0[xX][0-9a-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)\b/g;
+	for (const { num, text } of lines) {
+		let match;
+		numberRe.lastIndex = 0;
+		while ((match = numberRe.exec(text)) !== null) {
+			const numStr = match[0];
+			if (/^0[xXoObB]/.test(numStr)) continue;
+			numStr.replace(/^0+/, "").replace(/[.eE].*$/, "").replace(/^0+/, "");
+			const significantDigits = numStr.split(/[eE]/)[0].replace(/^0+/, "").replace(".", "").replace(/^0+/, "").length;
+			if (significantDigits > 15) {
+				const value = parseFloat(numStr);
+				const backToString = value.toString();
+				if (backToString !== numStr && !backToString.startsWith(numStr)) diagnostics.push(makeDiagnostic(filePath, "precision-loss", "warning", `Numeric literal ${numStr} has ${significantDigits} significant digits — exceeds IEEE 754 double precision (15-17 digits)`, `Runtime value becomes ${value}. Use BigInt for integers or a decimal library for precise arithmetic.`, num, match.index + 1, false, void 0, {
+					original: numStr,
+					runtimeValue: value,
+					significantDigits
+				}));
+			}
+		}
+	}
+	return diagnostics;
+}
+/** 7. Unicode anomalies: control chars, zero-width, RTL overrides */
+function checkUnicodeAnomalies(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	for (const { num, text } of lines) for (let col = 0; col < text.length; col++) {
+		const cp = text.codePointAt(col);
+		for (const range of UNICODE_ANOMALY_RANGES) if (cp >= range.lo && cp <= range.hi) {
+			if (cp === 9 || cp === 10 || cp === 13) continue;
+			const hex = cp > 65535 ? `U+${cp.toString(16).toUpperCase().padStart(6, "0")}` : `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+			diagnostics.push(makeDiagnostic(filePath, "unicode-anomaly", "warning", `Invisible/control character ${hex} (${range.name}) found at column ${col + 1}`, "This character is invisible in most editors and may indicate a homoglyph attack or copy-paste artifact. Remove it.", num, col + 1, true, {
+				type: "replace",
+				text: "",
+				range: {
+					startLine: num,
+					startCol: col + 1,
+					endLine: num,
+					endCol: col + 2
+				},
+				confidence: 1,
+				reason: "Remove invisible/control character"
+			}, {
+				codePoint: cp,
+				hex,
+				anomalyType: range.name
+			}));
+			break;
+		}
+		if (cp > 65535) col++;
+	}
+	return diagnostics;
+}
+/** 8. Trailing whitespace */
+function checkTrailingWhitespace(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	for (const { num, text } of lines) {
+		const trailingMatch = text.match(/([ \t]+)$/);
+		if (trailingMatch) {
+			const trailingLen = trailingMatch[1].length;
+			const col = text.length - trailingLen + 1;
+			diagnostics.push(makeDiagnostic(filePath, "trailing-whitespace", "info", `Line has ${trailingLen} trailing whitespace character${trailingLen > 1 ? "s" : ""}`, "Remove trailing whitespace. It creates noisy diffs and wastes space.", num, col, true, {
+				type: "replace",
+				text: text.replace(/[ \t]+$/, ""),
+				range: {
+					startLine: num,
+					startCol: col,
+					endLine: num,
+					endCol: text.length + 1
+				},
+				confidence: 1,
+				reason: "Remove trailing whitespace"
+			}));
+		}
+	}
+	return diagnostics;
+}
+/** 9. Missing final newline */
+function checkMissingFinalNewline(content, filePath) {
+	if (content.length === 0) return [];
+	if (!content.endsWith("\n")) {
+		const lineCount = content.split("\n").length;
+		return [makeDiagnostic(filePath, "missing-final-newline", "info", "File does not end with a newline (\\n)", "POSIX requires files to end with a newline. Some tools may misbehave without it.", lineCount, content.split("\n").pop().length + 1, true, {
+			type: "insert",
+			text: "\n",
+			range: {
+				startLine: lineCount,
+				startCol: content.split("\n").pop().length + 1,
+				endLine: lineCount,
+				endCol: content.split("\n").pop().length + 1
+			},
+			confidence: 1,
+			reason: "Add final newline"
+		})];
+	}
+	return [];
+}
+/** 10. Inconsistent indentation (mixed tabs and spaces) */
+function checkInconsistentIndentation(content, filePath) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	let tabIndented = 0;
+	let spaceIndented = 0;
+	const mixedLines = [];
+	for (const { num, text } of lines) {
+		if (text.length === 0) continue;
+		const indentMatch = text.match(/^([\t ]+)/);
+		if (!indentMatch) continue;
+		const indent = indentMatch[1];
+		const hasTab = indent.includes("	");
+		const hasSpace = indent.includes(" ");
+		if (hasTab && hasSpace) mixedLines.push({
+			num,
+			indent
+		});
+		else if (hasTab) tabIndented++;
+		else if (hasSpace) spaceIndented++;
+	}
+	for (const { num, indent } of mixedLines) diagnostics.push(makeDiagnostic(filePath, "mixed-indent-line", "warning", `Line mixes tabs and spaces in indentation: ${JSON.stringify(indent)}`, "Use consistent indentation (either all tabs or all spaces) within the same file.", num, 1, true, {
+		type: "replace",
+		text: indent.replace(/\t/g, "    "),
+		range: {
+			startLine: num,
+			startCol: 1,
+			endLine: num,
+			endCol: indent.length + 1
+		},
+		confidence: .8,
+		reason: "Normalize to consistent indentation"
+	}, { indent }));
+	if (mixedLines.length === 0 && tabIndented > 0 && spaceIndented > 0) {
+		const firstTabLine = lines.find((l) => l.text.match(/^\t/));
+		const firstSpaceLine = lines.find((l) => l.text.match(/^ /));
+		diagnostics.push(makeDiagnostic(filePath, "inconsistent-indent-style", "info", `File uses both tabs (${tabIndented} lines) and spaces (${spaceIndented} lines) for indentation`, "Pick one style and apply it consistently. Consider using an .editorconfig file.", firstTabLine?.num ?? firstSpaceLine?.num ?? 1, 1, true, void 0, {
+			tabLines: tabIndented,
+			spaceLines: spaceIndented
+		}));
+	}
+	return diagnostics;
+}
+const syntaxDeepEngine = {
+	name: "syntax-deep",
+	description: "Detects syntax-level anomalies that cause subtle bugs: BOM, mixed line endings, invalid escapes, precision loss, unicode anomalies, and formatting inconsistencies.",
+	supportedLanguages: [
+		"typescript",
+		"javascript",
+		"python",
+		"go",
+		"rust",
+		"ruby",
+		"php",
+		"java"
+	],
+	async run(context) {
+		const start = performance.now();
+		const diagnostics = [];
+		const files = await collectFiles(context);
+		for (const relPath of files) {
+			const absPath = join(context.rootDirectory, relPath);
+			let content;
+			let rawBuf;
+			try {
+				rawBuf = await readRawBytes(absPath);
+				content = rawBuf.toString("utf-8");
+			} catch {
+				continue;
+			}
+			diagnostics.push(...checkBomAndZwnbsp(content, relPath, rawBuf));
+			diagnostics.push(...checkLineEndings(content, relPath));
+			diagnostics.push(...checkInvalidEscapes(content, relPath));
+			diagnostics.push(...checkUnnecessaryRegexEscapes(content, relPath));
+			diagnostics.push(...checkNumberPrecision(content, relPath));
+			diagnostics.push(...checkUnicodeAnomalies(content, relPath));
+			diagnostics.push(...checkTrailingWhitespace(content, relPath));
+			diagnostics.push(...checkMissingFinalNewline(content, relPath));
+			diagnostics.push(...checkInconsistentIndentation(content, relPath));
+		}
+		return {
+			engine: "syntax-deep",
+			diagnostics,
+			elapsed: performance.now() - start,
+			skipped: false
+		};
+	},
+	async fix(diagnostics, context) {
+		const fixed = [];
+		const remaining = [];
+		const byFile = /* @__PURE__ */ new Map();
+		for (const d of diagnostics) {
+			if (!byFile.has(d.filePath)) byFile.set(d.filePath, []);
+			byFile.get(d.filePath).push(d);
+		}
+		const modifiedFiles = [];
+		const fixableRules = new Set([
+			"syntax-deep/bom-present",
+			"syntax-deep/zwnbsp-mid-file",
+			"syntax-deep/crlf-line-endings",
+			"syntax-deep/mixed-line-endings",
+			"syntax-deep/trailing-whitespace",
+			"syntax-deep/missing-final-newline"
+		]);
+		for (const [filePath, fileDiagnostics] of byFile) {
+			if (!fileDiagnostics.some((d) => fixableRules.has(d.rule))) {
+				remaining.push(...fileDiagnostics);
+				continue;
+			}
+			const absPath = join(context.rootDirectory, filePath);
+			let content;
+			try {
+				content = await readFileContent(absPath);
+			} catch {
+				remaining.push(...fileDiagnostics);
+				continue;
+			}
+			let modified = content;
+			if (fileDiagnostics.some((d) => d.rule === "syntax-deep/bom-present")) {
+				if (modified.charCodeAt(0) === 65279) modified = modified.slice(1);
+			}
+			if (fileDiagnostics.some((d) => d.rule === "syntax-deep/zwnbsp-mid-file")) modified = modified.replace(/\uFEFF/g, "");
+			if (fileDiagnostics.some((d) => d.rule === "syntax-deep/crlf-line-endings" || d.rule === "syntax-deep/mixed-line-endings")) modified = modified.replace(/\r\n/g, "\n");
+			if (fileDiagnostics.some((d) => d.rule === "syntax-deep/trailing-whitespace")) modified = modified.replace(/[ \t]+$/gm, "");
+			if (fileDiagnostics.some((d) => d.rule === "syntax-deep/missing-final-newline")) {
+				if (modified.length > 0 && !modified.endsWith("\n")) modified += "\n";
+			}
+			if (modified !== content) try {
+				await writeFile(absPath, modified, "utf-8");
+				modifiedFiles.push(filePath);
+				for (const d of fileDiagnostics) if (fixableRules.has(d.rule)) fixed.push(d);
+				else remaining.push(d);
+			} catch {
+				remaining.push(...fileDiagnostics);
+			}
+			else for (const d of fileDiagnostics) if (fixableRules.has(d.rule)) fixed.push(d);
+			else remaining.push(d);
+		}
+		return {
+			fixed: fixed.length,
+			remaining,
+			modifiedFiles
+		};
+	}
+};
+
+//#endregion
+export { syntaxDeepEngine };