deep-slop 1.4.1

package/dist/tree-sitter-CM-cP0nl.js

@@ -0,0 +1,661 @@
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils/tree-sitter.ts
+let parserInstance = null;
+let tsLang = null;
+let tsxLang = null;
+let initPromise = null;
+let initDone = false;
+let initOk = false;
+let pyLang = null;
+let pyInitDone = false;
+let pyInitOk = false;
+let goLang = null;
+let goInitDone = false;
+let goInitOk = false;
+let rustLang = null;
+let rustInitDone = false;
+let rustInitOk = false;
+let phpLang = null;
+let phpInitDone = false;
+let phpInitOk = false;
+let csharpLang = null;
+let csharpInitDone = false;
+let csharpInitOk = false;
+let swiftLang = null;
+let swiftInitDone = false;
+let swiftInitOk = false;
+/**
+* Attempt to initialise web-tree-sitter with the TypeScript grammar.
+* Returns true on success; false on any failure (missing WASM, etc.).
+* Safe to call multiple times – only the first call does real work.
+*/
+async function initParser() {
+	if (initDone) return initOk;
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		try {
+			const wt = await import("web-tree-sitter");
+			const { dirname } = await import("node:path");
+			const wasmDir = dirname(__require.resolve("web-tree-sitter/tree-sitter.wasm"));
+			await wt.Parser.init({ locateFile: (name) => `${wasmDir}/${name}` });
+			parserInstance = new wt.Parser();
+			const tsWasm = __require.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
+			tsLang = await wt.Language.load(tsWasm);
+			const tsxWasm = __require.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+			tsxLang = await wt.Language.load(tsxWasm);
+			initDone = true;
+			initOk = true;
+			return true;
+		} catch (err) {
+			initDone = true;
+			initOk = false;
+			return false;
+		}
+	})();
+	return initPromise;
+}
+/**
+* Attempt to load the Python grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-python is not installed.
+*/
+async function initPythonParser() {
+	if (pyInitDone) return pyInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			pyInitDone = true;
+			pyInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const pyWasm = __require.resolve("tree-sitter-python/python.wasm");
+		pyLang = await (await import("web-tree-sitter")).Language.load(pyWasm);
+		pyInitDone = true;
+		pyInitOk = true;
+		return true;
+	} catch {
+		pyInitDone = true;
+		pyInitOk = false;
+		return false;
+	}
+}
+/**
+* Attempt to load the Go grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-go is not installed.
+*/
+async function initGoParser() {
+	if (goInitDone) return goInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			goInitDone = true;
+			goInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const goWasm = __require.resolve("tree-sitter-go/go.wasm");
+		goLang = await (await import("web-tree-sitter")).Language.load(goWasm);
+		goInitDone = true;
+		goInitOk = true;
+		return true;
+	} catch {
+		goInitDone = true;
+		goInitOk = false;
+		return false;
+	}
+}
+/**
+* Attempt to load the Rust grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-rust is not installed.
+*/
+async function initRustParser() {
+	if (rustInitDone) return rustInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			rustInitDone = true;
+			rustInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const rustWasm = __require.resolve("tree-sitter-rust/rust.wasm");
+		rustLang = await (await import("web-tree-sitter")).Language.load(rustWasm);
+		rustInitDone = true;
+		rustInitOk = true;
+		return true;
+	} catch {
+		rustInitDone = true;
+		rustInitOk = false;
+		return false;
+	}
+}
+/**
+* Attempt to load the PHP grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-php is not installed.
+*/
+async function initPhpParser() {
+	if (phpInitDone) return phpInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			phpInitDone = true;
+			phpInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const phpWasm = __require.resolve("tree-sitter-php/php.wasm");
+		phpLang = await (await import("web-tree-sitter")).Language.load(phpWasm);
+		phpInitDone = true;
+		phpInitOk = true;
+		return true;
+	} catch {
+		phpInitDone = true;
+		phpInitOk = false;
+		return false;
+	}
+}
+/**
+* Attempt to load the C# grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-c-sharp is not installed.
+*/
+async function initCsharpParser() {
+	if (csharpInitDone) return csharpInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			csharpInitDone = true;
+			csharpInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const csharpWasm = __require.resolve("tree-sitter-c-sharp/c_sharp.wasm");
+		csharpLang = await (await import("web-tree-sitter")).Language.load(csharpWasm);
+		csharpInitDone = true;
+		csharpInitOk = true;
+		return true;
+	} catch {
+		csharpInitDone = true;
+		csharpInitOk = false;
+		return false;
+	}
+}
+/**
+* Attempt to load the Swift grammar for tree-sitter.
+* Returns true on success. Graceful fallback: returns false if
+* tree-sitter-swift is not installed.
+*/
+async function initSwiftParser() {
+	if (swiftInitDone) return swiftInitOk;
+	if (!initOk) {
+		if (!await initParser()) {
+			swiftInitDone = true;
+			swiftInitOk = false;
+			return false;
+		}
+	}
+	try {
+		const swiftWasm = __require.resolve("tree-sitter-swift/swift.wasm");
+		swiftLang = await (await import("web-tree-sitter")).Language.load(swiftWasm);
+		swiftInitDone = true;
+		swiftInitOk = true;
+		return true;
+	} catch {
+		swiftInitDone = true;
+		swiftInitOk = false;
+		return false;
+	}
+}
+/** Check if tree-sitter is available and initialized */
+function isAvailable() {
+	return initOk && parserInstance !== null;
+}
+/** Check if Python tree-sitter grammar is available */
+function isPythonAvailable() {
+	return pyInitOk && pyLang !== null;
+}
+/**
+* Parse a source file into an AST tree.
+* Returns null if tree-sitter is not available or parsing fails.
+*
+* When `filePath` is provided, routes to the correct language parser
+* based on file extension (.go, .rs, .php, .cs, .swift, .py, .tsx, .jsx).
+* When omitted, parses as TypeScript (or TSX when `isTsx` is true).
+*/
+async function parseFile(content, isTsx = false, filePath) {
+	if (filePath) {
+		const ext = filePath.toLowerCase();
+		if (ext.endsWith(".go")) return parseGoFile(content);
+		if (ext.endsWith(".rs")) return parseRustFile(content);
+		if (ext.endsWith(".php")) return parsePhpFile(content);
+		if (ext.endsWith(".cs")) return parseCsharpFile(content);
+		if (ext.endsWith(".swift")) return parseSwiftFile(content);
+		if (ext.endsWith(".py")) return parsePython(content);
+	}
+	if (!parserInstance || !tsLang && !tsxLang) {
+		if (!await initParser()) return null;
+	}
+	try {
+		const lang = isTsx ? tsxLang : tsLang;
+		parserInstance.setLanguage(lang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse Python source content into an AST tree.
+* Returns null if tree-sitter-python is not available or parsing fails.
+*/
+async function parsePython(content) {
+	if (!pyLang) {
+		if (!await initPythonParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(pyLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse Go source content into an AST tree.
+* Returns null if tree-sitter-go is not available or parsing fails.
+*/
+async function parseGoFile(content) {
+	if (!goLang) {
+		if (!await initGoParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(goLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse Rust source content into an AST tree.
+* Returns null if tree-sitter-rust is not available or parsing fails.
+*/
+async function parseRustFile(content) {
+	if (!rustLang) {
+		if (!await initRustParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(rustLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse PHP source content into an AST tree.
+* Returns null if tree-sitter-php is not available or parsing fails.
+*/
+async function parsePhpFile(content) {
+	if (!phpLang) {
+		if (!await initPhpParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(phpLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse C# source content into an AST tree.
+* Returns null if tree-sitter-c-sharp is not available or parsing fails.
+*/
+async function parseCsharpFile(content) {
+	if (!csharpLang) {
+		if (!await initCsharpParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(csharpLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse Swift source content into an AST tree.
+* Returns null if tree-sitter-swift is not available or parsing fails.
+*/
+async function parseSwiftFile(content) {
+	if (!swiftLang) {
+		if (!await initSwiftParser()) return null;
+	}
+	if (!parserInstance) {
+		if (!await initParser()) return null;
+	}
+	try {
+		parserInstance.setLanguage(swiftLang);
+		const tree = parserInstance.parse(content);
+		if (!tree) return null;
+		return convertNode(tree.rootNode, null);
+	} catch {
+		return null;
+	}
+}
+/**
+* Find all descendant nodes of a given type.
+*/
+function findNodesOfType(root, type) {
+	const results = [];
+	function walk(node) {
+		if (node.type === type) results.push(node);
+		for (const child of node.children) walk(child);
+	}
+	walk(root);
+	return results;
+}
+/**
+* Find all descendant nodes matching any of the given types.
+*/
+function findNodesOfTypes(root, types) {
+	const typeSet = new Set(types);
+	const results = [];
+	function walk(node) {
+		if (typeSet.has(node.type)) results.push(node);
+		for (const child of node.children) walk(child);
+	}
+	walk(root);
+	return results;
+}
+/**
+* Walk the AST depth-first, calling visitor on each node.
+* Return false from visitor to skip children.
+*/
+function walkAST(root, visitor) {
+	function walk(node) {
+		if (visitor(node) !== false) for (const child of node.children) walk(child);
+	}
+	walk(root);
+}
+/**
+* Find the nearest ancestor of a node matching a type predicate.
+*/
+function findAncestor(node, predicate) {
+	let current = node.parent;
+	while (current) {
+		if (predicate(current)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Check if a node is inside a try/catch block.
+*/
+function isInsideCatch(node) {
+	return findAncestor(node, (n) => n.type === "catch_clause") !== null;
+}
+/** Find ancestor of specific type */
+function findAncestorOfType(node, type) {
+	return findAncestor(node, (n) => n.type === type);
+}
+/** Check if a catch clause body is empty (only contains comments or whitespace) */
+function isCatchBodyEmpty(catchNode) {
+	if (catchNode.type !== "catch_clause") return false;
+	const body = catchNode.children.find((c) => c.type === "statement_block" || c.type === "block");
+	if (!body) return true;
+	return body.children.filter((c) => c.type !== "comment" && c.type !== "//" && c.type !== "/*" && c.type !== "{" && c.type !== "}" && c.text.trim() !== "").length === 0;
+}
+/** Get the type annotation from an `as` expression (e.g., `x as any` → "any") */
+function getAsExpressionType(node) {
+	if (node.type !== "as_expression") return null;
+	return node.children.find((c) => c.fieldName === "type")?.text ?? null;
+}
+/** Get context of an `as` expression — returns 'catch', 'orm', 'json', 'variable', or 'unknown' */
+function getAsExpressionContext(node) {
+	if (isInsideCatch(node)) return "catch";
+	const funcAncestor = findAncestor(node, (n) => [
+		"function_declaration",
+		"arrow_function",
+		"method_definition"
+	].includes(n.type));
+	if (funcAncestor) {
+		const text = funcAncestor.text.toLowerCase();
+		if (/prisma|drizzle|sequelize|mongoose|typeorm|knex|supabase/.test(text)) return "orm";
+		if (/json\.parse|parse\(/.test(text)) return "json";
+	}
+	return "unknown";
+}
+/** Extract import info from an import_statement or import_declaration node */
+function extractImportFromNode(node) {
+	if (node.type !== "import_statement" && node.type !== "import_declaration") return null;
+	const sourceNode = node.children.find((c) => c.type === "string" || c.fieldName === "source");
+	if (!sourceNode) return null;
+	const source = sourceNode.text.replace(/^['"]|['"]$/g, "");
+	const isTypeOnly = node.text.includes("import type ");
+	const symbols = [];
+	const namedImport = node.children.find((c) => c.type === "named_imports" || c.type === "import_clause");
+	if (namedImport) {
+		for (const child of namedImport.children) if (child.type === "identifier" || child.type === "type_identifier" || child.type === "import_specifier") symbols.push(child.text);
+	}
+	return {
+		source,
+		symbols,
+		line: node.startRow + 1,
+		isTypeOnly
+	};
+}
+/**
+* Find all Python function definitions in an AST.
+*/
+function findPythonFunctions(root) {
+	const funcNodes = findNodesOfTypes(root, ["function_definition", "decorated_definition"]);
+	const results = [];
+	for (const node of funcNodes) if (node.type === "decorated_definition") {
+		const inner = node.children.find((c) => c.type === "function_definition");
+		if (inner) results.push(extractPythonFunctionInfo(inner, node));
+	} else results.push(extractPythonFunctionInfo(node));
+	return results;
+}
+/**
+* Find all Python class definitions in an AST.
+*/
+function findPythonClasses(root) {
+	const classNodes = findNodesOfTypes(root, ["class_definition", "decorated_definition"]);
+	const results = [];
+	for (const node of classNodes) if (node.type === "decorated_definition") {
+		const inner = node.children.find((c) => c.type === "class_definition");
+		if (inner) results.push(extractPythonClassInfo(inner, node));
+	} else results.push(extractPythonClassInfo(node));
+	return results;
+}
+/**
+* Find all Python import statements in an AST.
+*/
+function findPythonImports(root) {
+	return findNodesOfTypes(root, ["import_statement", "import_from_statement"]).map(extractPythonImportInfo);
+}
+/**
+* Check if a Python function body is essentially empty
+* (only contains pass, ..., or docstrings).
+*/
+function isPythonFunctionStub(funcInfo) {
+	const bodyLines = funcInfo.text.split("\n").slice(1).join("\n").trim();
+	if (/^(\s*(pass|\.\.\.)\s*)$/.test(bodyLines)) return true;
+	const docstringOnly = bodyLines.replace(/"""[\s\S]*?"""/g, "").replace(/'''[\s\S]*?'''/g, "").trim();
+	if (docstringOnly === "" || docstringOnly === "pass" || docstringOnly === "...") return true;
+	return false;
+}
+/**
+* Detect Python AI patterns in an AST.
+* Returns diagnostic-like findings for the ast-slop engine.
+*/
+function detectPythonAIPatterns(root) {
+	const findings = [];
+	const functions = findPythonFunctions(root);
+	for (const fn of functions) if (isPythonFunctionStub(fn)) findings.push({
+		type: "python-stub-function",
+		message: `Function '${fn.name}' is a stub (only pass/ellipsis)`,
+		line: fn.line
+	});
+	const tryNodes = findNodesOfType(root, "try_statement");
+	for (const tryNode of tryNodes) {
+		const exceptNodes = tryNode.children.filter((c) => c.type === "except_clause");
+		for (const exceptNode of exceptNodes) if (!exceptNode.children.some((c) => c.type === "identifier" || c.type === "tuple")) {
+			exceptNode.children.find((c) => c.text && c.text.includes("except"));
+			findings.push({
+				type: "python-bare-except",
+				message: "Bare except clause catches all exceptions",
+				line: exceptNode.startRow + 1
+			});
+		}
+	}
+	const commentNodes = findNodesOfType(root, "comment");
+	for (const comment of commentNodes) {
+		const text = comment.text.toLowerCase();
+		if (/todo|fixme|hack|xxx/.test(text)) findings.push({
+			type: "python-todo-stub",
+			message: `TODO/FIXME comment: ${comment.text.trim()}`,
+			line: comment.startRow + 1
+		});
+	}
+	const callNodes = findNodesOfType(root, "call");
+	for (const call of callNodes) {
+		const func = call.children[0];
+		if (func && func.text === "print") findings.push({
+			type: "python-print-leftover",
+			message: "print() statement — likely debug leftover",
+			line: call.startRow + 1
+		});
+	}
+	return findings;
+}
+function extractPythonFunctionInfo(funcNode, decoratedParent) {
+	const name = (funcNode.children.find((c) => c.fieldName === "name") ?? funcNode.children.find((c) => c.type === "identifier"))?.text ?? "(anonymous)";
+	const params = funcNode.children.find((c) => c.type === "parameters");
+	const parameters = params ? params.children.filter((c) => c.type === "identifier" || c.type === "typed_parameter" || c.type === "default_parameter").map((c) => c.children[0]?.text ?? c.text) : [];
+	const isAsync = funcNode.children.some((c) => c.type === "async");
+	const decorators = [];
+	if (decoratedParent) {
+		for (const child of decoratedParent.children) if (child.type === "decorator") decorators.push(child.text.replace("@", ""));
+	}
+	return {
+		name,
+		decorators,
+		parameters,
+		isAsync,
+		line: funcNode.startRow + 1,
+		endLine: funcNode.endRow + 1,
+		text: funcNode.text
+	};
+}
+function extractPythonClassInfo(classNode, decoratedParent) {
+	const name = (classNode.children.find((c) => c.fieldName === "name") ?? classNode.children.find((c) => c.type === "identifier"))?.text ?? "(anonymous)";
+	const argList = classNode.children.find((c) => c.type === "argument_list");
+	const bases = argList ? argList.children.filter((c) => c.type === "identifier" || c.type === "attribute").map((c) => c.text) : [];
+	const decorators = [];
+	if (decoratedParent) {
+		for (const child of decoratedParent.children) if (child.type === "decorator") decorators.push(child.text.replace("@", ""));
+	}
+	const body = classNode.children.find((c) => c.type === "block");
+	const methods = [];
+	if (body) {
+		for (const child of body.children) if (child.type === "function_definition") methods.push(extractPythonFunctionInfo(child));
+		else if (child.type === "decorated_definition") {
+			const inner = child.children.find((c) => c.type === "function_definition");
+			if (inner) methods.push(extractPythonFunctionInfo(inner, child));
+		}
+	}
+	return {
+		name,
+		bases,
+		decorators,
+		methods,
+		line: classNode.startRow + 1,
+		endLine: classNode.endRow + 1,
+		text: classNode.text
+	};
+}
+function extractPythonImportInfo(importNode) {
+	const isFromImport = importNode.type === "import_from_statement";
+	let module = "";
+	const symbols = [];
+	if (isFromImport) {
+		const moduleNode = importNode.children.find((c) => c.fieldName === "module_name" || c.type === "dotted_name" && c.fieldName !== "name" || c.type === "identifier" && c.fieldName !== "name");
+		module = moduleNode?.text ?? "";
+		const nameList = importNode.children.find((c) => c.type === "dotted_name" && c !== moduleNode);
+		const identifierChildren = importNode.children.filter((c) => c.type === "identifier" && c !== moduleNode);
+		if (nameList) symbols.push(nameList.text);
+		for (const id of identifierChildren) if (id.text !== "from" && id.text !== "import" && id.text !== module) symbols.push(id.text);
+	} else {
+		const dottedNames = importNode.children.filter((c) => c.type === "dotted_name");
+		const identifiers = importNode.children.filter((c) => c.type === "identifier");
+		for (const dn of dottedNames) symbols.push(dn.text);
+		for (const id of identifiers) if (id.text !== "import") symbols.push(id.text);
+		module = symbols[0] ?? "";
+	}
+	return {
+		module,
+		symbols,
+		isFromImport,
+		line: importNode.startRow + 1,
+		text: importNode.text
+	};
+}
+function convertNode(node, parent) {
+	const children = [];
+	const astNode = {
+		type: node.type,
+		text: node.text,
+		startRow: node.startPosition.row,
+		startCol: node.startPosition.column,
+		endRow: node.endPosition.row,
+		endCol: node.endPosition.column,
+		children,
+		parent,
+		fieldName: null
+	};
+	for (let i = 0; i < node.childCount; i++) {
+		const child = node.child(i);
+		if (child) {
+			const converted = convertNode(child, astNode);
+			converted.fieldName = node.fieldNameForChild(i) ?? null;
+			children.push(converted);
+		}
+	}
+	return astNode;
+}
+
+//#endregion
+export { parseFile as _, findNodesOfType as a, findPythonImports as c, initParser as d, initPythonParser as f, isPythonAvailable as g, isInsideCatch as h, findAncestorOfType as i, getAsExpressionContext as l, isCatchBodyEmpty as m, extractImportFromNode as n, findNodesOfTypes as o, isAvailable as p, findAncestor as r, findPythonClasses as s, detectPythonAIPatterns as t, getAsExpressionType as u, parsePython as v, walkAST as y };