deep-slop 1.4.1

package/dist/perf-hints-BnWFMFff.js

@@ -0,0 +1,500 @@
+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/perf-hints/index.ts
+const TS_JS_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+function isRelevantFile(filePath) {
+	const ext = extname(filePath);
+	return TS_JS_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 perf-hints */
+function makeDiagnostic(overrides) {
+	return {
+		engine: "perf-hints",
+		severity: "info",
+		column: 1,
+		category: "performance",
+		fixable: false,
+		help: "",
+		...overrides
+	};
+}
+/**
+* Parse the file into block ranges by tracking brace depth.
+* This lets us answer "is line X inside a loop?" or "is line X inside an async function?"
+*/
+function parseBlocks(content) {
+	const lines = toLines(content);
+	const blocks = [];
+	const stack = [];
+	for (let i = 0; i < lines.length; i++) {
+		const text = lines[i].text;
+		for (let col = 0; col < text.length; col++) {
+			const ch = text[col];
+			if (ch === "\"" || ch === "'" || ch === "`") {
+				const quote = ch;
+				col++;
+				while (col < text.length && text[col] !== quote) {
+					if (text[col] === "\\") col++;
+					col++;
+				}
+				continue;
+			}
+			if (ch === "/" && col + 1 < text.length) {
+				if (text[col + 1] === "/") break;
+				if (text[col + 1] === "*") {
+					const end = text.indexOf("*/", col + 2);
+					if (end !== -1) col = end + 1;
+					else break;
+					continue;
+				}
+			}
+			if (ch === "{") {
+				const kind = detectConstructKind(lines, i, stack.length);
+				stack.push({
+					braceLineIdx: i,
+					headerLine: lines[i].num,
+					kind
+				});
+			} else if (ch === "}") {
+				if (stack.length > 0) {
+					const opener = stack.pop();
+					blocks.push({
+						startIdx: opener.braceLineIdx,
+						endIdx: i,
+						headerLine: opener.headerLine,
+						kind: opener.kind
+					});
+				}
+			}
+		}
+	}
+	return blocks;
+}
+/**
+* Look at the text before the opening brace on lineIdx to determine what
+* construct this block belongs to.
+*/
+function detectConstructKind(lines, braceLineIdx, _depth) {
+	const chunks = [];
+	const braceLine = lines[braceLineIdx].text;
+	const bracePos = braceLine.indexOf("{");
+	if (bracePos > 0) chunks.push(braceLine.slice(0, bracePos));
+	for (let i = braceLineIdx - 1; i >= Math.max(0, braceLineIdx - 3); i--) chunks.unshift(lines[i].text.trim());
+	const header = chunks.join(" ");
+	if (/\basync\s+(?:function\b|[\w]+\s*\([^)]*\)\s*=>)/.test(header) || /\basync\s+function\b/.test(header)) return "async-function";
+	if (/\bfunction\b/.test(header) || /=>\s*$/.test(chunks[chunks.length - 1])) return "sync-function";
+	if (/\bfor\b/.test(header)) return "for";
+	if (/\bwhile\b/.test(header)) return "while";
+	if (/\bdo\b/.test(header)) return "do";
+	if (/\.(forEach|map|filter|reduce|flatMap|some|every)\s*\(/.test(header)) {
+		if (/\.forEach\b/.test(header)) return "forEach";
+		if (/\.map\b/.test(header)) return "map";
+		return "map";
+	}
+	return "other";
+}
+/** Check if a 0-based line index is inside a block of the given kind(s) */
+function isInsideBlock(blocks, lineIdx, kinds) {
+	for (const block of blocks) if (lineIdx >= block.startIdx && lineIdx <= block.endIdx && kinds.has(block.kind)) return block;
+	return null;
+}
+function detectNPlusOne(content, filePath, blocks) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const dbCallRe = /\.(query|execute|find|findOne|findMany|insertOne|insertMany|updateOne|updateMany|deleteOne|deleteMany|raw|run|exec)\s*\(/;
+	const strictLoopKinds = new Set([
+		"for",
+		"while",
+		"do"
+	]);
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		if (dbCallRe.test(trimmed)) {
+			const enclosingLoop = isInsideBlock(blocks, i, strictLoopKinds);
+			if (enclosingLoop) {
+				const hasAwait = /\bawait\b/.test(trimmed);
+				const key = `${filePath}:${enclosingLoop.startIdx}:perf-hints/n-plus-one`;
+				if (!seenKeys.has(key)) {
+					seenKeys.add(key);
+					diagnostics.push(makeDiagnostic({
+						filePath,
+						rule: "perf-hints/n-plus-one",
+						message: `Database call inside ${describeLoopKind(enclosingLoop.kind)} — potential N+1 query pattern`,
+						line: lines[i].num,
+						severity: "info",
+						help: "Batch database queries outside the loop or use a single query with IN clause to avoid N+1 round trips",
+						fixable: false,
+						suggestion: {
+							type: "refactor",
+							text: hasAwait ? "// Collect IDs, then batch: const results = await db.query('SELECT * FROM t WHERE id IN (?)', [ids])" : "// Batch the query outside the loop instead of calling per iteration",
+							confidence: .75,
+							reason: "Performing I/O on every loop iteration causes N+1 round trips; batching reduces this to 1"
+						},
+						detail: {
+							loopKind: enclosingLoop.kind,
+							loopHeaderLine: enclosingLoop.headerLine,
+							hasAwait,
+							isDbCall: true
+						}
+					}));
+				}
+			}
+		}
+	}
+	return diagnostics;
+}
+function detectReactMissingMemo(content, filePath, blocks) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	if (!/\.(tsx|jsx)$/.test(filePath)) return diagnostics;
+	const functionKinds = new Set(["sync-function", "async-function"]);
+	const pascalFnRe = /^(?:const|let|function)\s+([A-Z][a-zA-Z0-9]*)\s*(?:=\s*(?:\([^)]*\)|[\w]*)\s*=>|[\s]*\()/;
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].text.trim().match(pascalFnRe);
+		if (!match) continue;
+		const componentName = match[1];
+		const enclosingFn = isInsideBlock(blocks, i, functionKinds);
+		if (!enclosingFn) continue;
+		const jsxAhead = contentAroundLine(lines, i, 15);
+		if (!(/<\s*[A-Za-z][A-Za-z0-9]*(?:\s[^>]*)?\/?>/.test(jsxAhead) || /React\.createElement/.test(jsxAhead))) continue;
+		diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "perf-hints/react-missing-memo",
+			message: `Component \`${componentName}\` is defined inside another component — recreated on every render`,
+			line: lines[i].num,
+			severity: "info",
+			help: `Move \`${componentName}\` outside the parent component or wrap with useMemo to avoid re-creation on every render`,
+			fixable: false,
+			suggestion: {
+				type: "refactor",
+				text: `// Move ${componentName} outside the parent component, or:\n// const ${componentName} = useMemo(() => (...) , [])`,
+				confidence: .8,
+				reason: "Inner component definitions create new function references on every parent render, causing unnecessary child re-renders"
+			},
+			detail: {
+				componentName,
+				parentHeaderLine: enclosingFn.headerLine
+			}
+		}));
+	}
+	return diagnostics;
+}
+/** Get text around a line (N lines ahead from lineIdx, inclusive) */
+function contentAroundLine(lines, lineIdx, ahead) {
+	const start = lineIdx;
+	const end = Math.min(lines.length, lineIdx + ahead);
+	const parts = [];
+	for (let i = start; i < end; i++) parts.push(lines[i].text);
+	return parts.join("\n");
+}
+function detectSyncInAsync(content, filePath, blocks) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const asyncKinds = new Set(["async-function"]);
+	const isCliFile = /(?:^|\\|\/)cli(?:\\|\/|[-_.])/i.test(filePath) || /(?:^|\\|\/)cli\./i.test(filePath);
+	const syncFsRe = /\b(readFileSync|writeFileSync|appendFileSync|existsSync|mkdirSync|rmdirSync|unlinkSync|renameSync|copyFileSync|readdirSync|statSync|lstatSync|fstatSync|accessSync|readlinkSync|symlinkSync|chmodSync|chownSync|utimesSync|realpathSync|mkdtempSync|truncateSync|openSync|closeSync|readSync|writeSync|fsyncSync|watchFile|unwatchFile)\s*\(/;
+	const cliWhitelist = new Set(["readFileSync", "writeFileSync"]);
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		const match = trimmed.match(syncFsRe);
+		if (!match) continue;
+		const methodName = match[1];
+		if (isCliFile && cliWhitelist.has(methodName)) continue;
+		const enclosingAsync = isInsideBlock(blocks, i, asyncKinds);
+		if (!enclosingAsync) continue;
+		const asyncName = methodName.replace(/Sync$/, "");
+		diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "perf-hints/sync-in-async",
+			message: `Synchronous \`${methodName}\` inside async function — blocks the event loop`,
+			line: lines[i].num,
+			severity: "warning",
+			help: `Replace \`${methodName}\` with async \`${asyncName}\` to avoid blocking the event loop`,
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: `await ${asyncName}(`,
+				confidence: .9,
+				reason: `Async functions should use the async version ${asyncName} instead of the synchronous ${methodName} to prevent blocking the event loop`,
+				range: {
+					startLine: lines[i].num,
+					startCol: trimmed.indexOf(methodName) + 1,
+					endLine: lines[i].num,
+					endCol: trimmed.indexOf(methodName) + methodName.length + 1
+				}
+			},
+			detail: {
+				syncMethod: methodName,
+				asyncMethod: asyncName,
+				asyncHeaderLine: enclosingAsync.headerLine
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectLargeLoopAllocation(content, filePath, blocks) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const loopKinds = new Set([
+		"for",
+		"while",
+		"do",
+		"forEach",
+		"map"
+	]);
+	const typedArrayTypes = new Set([
+		"Float32Array",
+		"Float64Array",
+		"Int8Array",
+		"Int16Array",
+		"Int32Array",
+		"Uint8Array",
+		"Uint16Array",
+		"Uint32Array",
+		"Uint8ClampedArray",
+		"BigInt64Array",
+		"BigUint64Array"
+	]);
+	const skipTypes = new Set([
+		"Map",
+		"Set",
+		"WeakMap",
+		"WeakSet"
+	]);
+	const allocRe = /\bnew\s+(Array|Map|Set|WeakMap|WeakSet|Float32Array|Float64Array|Int8Array|Int16Array|Int32Array|Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|BigInt64Array|BigUint64Array)\s*\(/;
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		const arrayMatch = trimmed.match(allocRe);
+		if (!arrayMatch) continue;
+		const allocType = arrayMatch[1];
+		const enclosingLoop = isInsideBlock(blocks, i, loopKinds);
+		if (!enclosingLoop) continue;
+		if (skipTypes.has(allocType)) continue;
+		const loopDesc = describeLoopKind(enclosingLoop.kind);
+		if (allocType === "Array") {
+			const sizeMatch = trimmed.match(/\bnew\s+Array\s*\(\s*(\d+)\s*\)/);
+			if (!sizeMatch) continue;
+			const size = parseInt(sizeMatch[1], 10);
+			if (size <= 100) continue;
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "perf-hints/large-loop-allocation",
+				message: `\`new Array(${size})\` allocation inside ${loopDesc} — consider pre-allocating outside the loop`,
+				line: lines[i].num,
+				severity: "suggestion",
+				help: "Move the array allocation outside the loop and re-use it, or use .push() on a pre-allocated array",
+				fixable: false,
+				suggestion: {
+					type: "refactor",
+					text: `// const arr = new Array(${size}); // outside loop\n// arr.fill(0); // reuse per iteration`,
+					confidence: .5,
+					reason: "Repeated large array allocations inside loops create GC pressure; pre-allocating outside the loop is more efficient"
+				},
+				detail: {
+					allocType,
+					loopKind: enclosingLoop.kind,
+					loopHeaderLine: enclosingLoop.headerLine,
+					hasSizeArg: true,
+					arraySize: size
+				}
+			}));
+		} else if (typedArrayTypes.has(allocType)) diagnostics.push(makeDiagnostic({
+			filePath,
+			rule: "perf-hints/large-loop-allocation",
+			message: `\`new ${allocType}()\` allocation inside ${loopDesc} — consider pre-allocating outside the loop`,
+			line: lines[i].num,
+			severity: "suggestion",
+			help: `Move the ${allocType} allocation outside the loop to reduce GC pressure`,
+			fixable: false,
+			suggestion: {
+				type: "refactor",
+				text: `// const buf = new ${allocType}(...); // allocate once outside the loop`,
+				confidence: .5,
+				reason: "Repeated typed array allocations inside loops create GC pressure; pre-allocating outside the loop is more efficient"
+			},
+			detail: {
+				allocType,
+				loopKind: enclosingLoop.kind,
+				loopHeaderLine: enclosingLoop.headerLine,
+				hasSizeArg: false
+			}
+		}));
+	}
+	return diagnostics;
+}
+function detectUnnecessaryAwait(_content, _filePath) {
+	return [];
+}
+function detectStringConcatInLoop(content, filePath, blocks) {
+	const diagnostics = [];
+	const lines = toLines(content);
+	const loopKinds = new Set([
+		"for",
+		"while",
+		"do",
+		"forEach",
+		"map"
+	]);
+	const templateConcatRe = /\b(\w+)\s*\+=\s*`/;
+	const anyConcatRe = /\b(\w+)\s*\+=\s*["'`]/;
+	const concatCounts = /* @__PURE__ */ new Map();
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].text.trim().match(anyConcatRe);
+		if (!match) continue;
+		const varName = match[1];
+		const enclosingLoop = isInsideBlock(blocks, i, loopKinds);
+		if (!enclosingLoop) continue;
+		const key = `${varName}:${enclosingLoop.startIdx}`;
+		concatCounts.set(key, (concatCounts.get(key) ?? 0) + 1);
+	}
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].text.trim();
+		const enclosingLoop = isInsideBlock(blocks, i, loopKinds);
+		if (!enclosingLoop) continue;
+		const templateMatch = trimmed.match(templateConcatRe);
+		if (templateMatch) {
+			const varName = templateMatch[1];
+			const loopDesc = describeLoopKind(enclosingLoop.kind);
+			diagnostics.push(makeDiagnostic({
+				filePath,
+				rule: "perf-hints/string-concat-in-loop",
+				message: `String concatenation (\`${varName} +=\` with template literal) inside ${loopDesc} — consider using array.join() pattern`,
+				line: lines[i].num,
+				severity: "warning",
+				help: `Use an array to collect strings and join once after the loop, which is O(n) instead of O(n²) for repeated concatenation`,
+				fixable: false,
+				suggestion: {
+					type: "refactor",
+					text: `// const parts: string[] = [];\n// parts.push(...); // inside loop\n// const ${varName} = parts.join(''); // after loop`,
+					confidence: .75,
+					reason: "Repeated string concatenation with += and template literals inside a loop is O(n²); pushing to an array and joining once is O(n)"
+				},
+				detail: {
+					variableName: varName,
+					loopKind: enclosingLoop.kind,
+					loopHeaderLine: enclosingLoop.headerLine
+				}
+			}));
+			continue;
+		}
+		const anyMatch = trimmed.match(anyConcatRe);
+		if (anyMatch) {
+			const varName = anyMatch[1];
+			const key = `${varName}:${enclosingLoop.startIdx}`;
+			const count = concatCounts.get(key) ?? 0;
+			if (count >= 3) {
+				const loopDesc = describeLoopKind(enclosingLoop.kind);
+				diagnostics.push(makeDiagnostic({
+					filePath,
+					rule: "perf-hints/string-concat-in-loop",
+					message: `String concatenation (\`${varName} +=\`) inside ${loopDesc} — ${count} concatenations found, consider using array.join() pattern`,
+					line: lines[i].num,
+					severity: "warning",
+					help: `Use an array to collect strings and join once after the loop, which is O(n) instead of O(n²) for repeated concatenation`,
+					fixable: false,
+					suggestion: {
+						type: "refactor",
+						text: `// const parts: string[] = [];\n// parts.push(...); // inside loop\n// const ${varName} = parts.join(''); // after loop`,
+						confidence: .7,
+						reason: `${count} repeated string concatenations with += inside a loop is O(n²); pushing to an array and joining once is O(n)`
+					},
+					detail: {
+						variableName: varName,
+						loopKind: enclosingLoop.kind,
+						loopHeaderLine: enclosingLoop.headerLine,
+						concatCount: count
+					}
+				}));
+			}
+		}
+	}
+	return diagnostics;
+}
+/** Human-readable loop kind description */
+function describeLoopKind(kind) {
+	switch (kind) {
+		case "for": return "for loop";
+		case "while": return "while loop";
+		case "do": return "do-while loop";
+		case "forEach": return ".forEach() callback";
+		case "map": return ".map() callback";
+		default: return "loop";
+	}
+}
+/** Global seen-keys set per run to avoid duplicates across rules */
+const seenKeys = /* @__PURE__ */ new Set();
+const perfHintsEngine = {
+	name: "perf-hints",
+	description: "Performance hints: N+1 query patterns, missing React memoization, sync I/O in async, loop allocations, unnecessary awaits, string concatenation in loops",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const start = Date.now();
+		const diagnostics = [];
+		const { rootDirectory, config, files: specifiedFiles } = context;
+		seenKeys.clear();
+		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 TypeScript/JavaScript files found to analyze"
+		};
+		for (const fp of filePaths) try {
+			const content = await readFileContent(fp);
+			const relPath = relative(rootDirectory, fp);
+			const blocks = parseBlocks(content);
+			diagnostics.push(...detectNPlusOne(content, relPath, blocks));
+			diagnostics.push(...detectReactMissingMemo(content, relPath, blocks));
+			diagnostics.push(...detectSyncInAsync(content, relPath, blocks));
+			diagnostics.push(...detectLargeLoopAllocation(content, relPath, blocks));
+			diagnostics.push(...detectUnnecessaryAwait(content, relPath));
+			diagnostics.push(...detectStringConcatInLoop(content, relPath, blocks));
+		} 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 { perfHintsEngine };