deep-slop 1.4.1

package/dist/arch-rules-DI1SYPqu.js

@@ -0,0 +1,358 @@
+import { t as collectFiles } from "./discover-B_S_Fy2S.js";
+import { r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { join, relative } from "node:path";
+import { readFile } from "node:fs/promises";
+import { minimatch } from "minimatch";
+import yaml from "js-yaml";
+
+//#region src/engines/arch-rules/loader.ts
+const RULES_PATH = ".deep-slop/rules.yml";
+/** Validate and normalize a single rule object */
+function validateRule(raw, index) {
+	const name = typeof raw.name === "string" ? raw.name : `rule-${index + 1}`;
+	const type = raw.type;
+	if (!type || ![
+		"forbid_import",
+		"forbid_import_from_path",
+		"require_pattern"
+	].includes(type)) throw new Error(`Rule "${name}" has invalid type: "${type}". Expected: forbid_import, forbid_import_from_path, require_pattern`);
+	if (!raw.match || typeof raw.match !== "string") throw new Error(`Rule "${name}" is missing required "match" glob pattern`);
+	if (type === "forbid_import" && (!raw.forbid || typeof raw.forbid !== "string")) throw new Error(`Rule "${name}" (forbid_import) is missing required "forbid" field`);
+	if (type === "forbid_import_from_path" && (!raw.forbid || typeof raw.forbid !== "string")) throw new Error(`Rule "${name}" (forbid_import_from_path) is missing required "forbid" field`);
+	if (type === "forbid_import_from_path" && (!raw.from || typeof raw.from !== "string")) throw new Error(`Rule "${name}" (forbid_import_from_path) is missing required "from" field`);
+	if (type === "require_pattern" && (!raw.pattern || typeof raw.pattern !== "string")) throw new Error(`Rule "${name}" (require_pattern) is missing required "pattern" field`);
+	const severity = raw.severity;
+	if (severity && ![
+		"error",
+		"warning",
+		"info"
+	].includes(severity)) throw new Error(`Rule "${name}" has invalid severity: "${severity}". Expected: error, warning, info`);
+	return {
+		name,
+		type,
+		match: raw.match,
+		forbid: raw.forbid,
+		from: raw.from,
+		pattern: raw.pattern,
+		severity: severity ?? "warning",
+		where: raw.where
+	};
+}
+/**
+* Load architecture rules from .deep-slop/rules.yml.
+* Returns an empty array if the file does not exist.
+*/
+async function loadRules(rootDir) {
+	const filePath = join(rootDir, RULES_PATH);
+	let content;
+	try {
+		content = await readFile(filePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const parsed = yaml.load(content);
+	if (!parsed || !Array.isArray(parsed.rules)) throw new Error(`Invalid rules file: ${RULES_PATH} — expected a "rules" array at top level`);
+	return parsed.rules.map((raw, i) => validateRule(raw, i));
+}
+
+//#endregion
+//#region src/engines/arch-rules/matchers.ts
+/** Extract imports from JS/TS content */
+function extractJsImports(content) {
+	const imports = [];
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		const lineNum = i + 1;
+		const staticMatch = trimmed.match(/^import\s+(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/);
+		if (staticMatch) {
+			imports.push({
+				line: lineNum,
+				source: staticMatch[1],
+				raw: trimmed
+			});
+			continue;
+		}
+		const sideEffectMatch = trimmed.match(/^import\s+['"]([^'"]+)['"]/);
+		if (sideEffectMatch) {
+			imports.push({
+				line: lineNum,
+				source: sideEffectMatch[1],
+				raw: trimmed
+			});
+			continue;
+		}
+		const dynMatch = trimmed.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+		if (dynMatch) {
+			imports.push({
+				line: lineNum,
+				source: dynMatch[1],
+				raw: trimmed
+			});
+			continue;
+		}
+		const reqMatch = trimmed.match(/(?:const|let|var)\s+[^=]*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+		if (reqMatch) imports.push({
+			line: lineNum,
+			source: reqMatch[1],
+			raw: trimmed
+		});
+	}
+	return imports;
+}
+/** Extract imports from Python content */
+function extractPythonImports(content) {
+	const imports = [];
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		const lineNum = i + 1;
+		const fromMatch = trimmed.match(/^from\s+([^\s]+)\s+import/);
+		if (fromMatch) {
+			imports.push({
+				line: lineNum,
+				source: fromMatch[1],
+				raw: trimmed
+			});
+			continue;
+		}
+		const importMatch = trimmed.match(/^import\s+([^\s,]+)/);
+		if (importMatch) imports.push({
+			line: lineNum,
+			source: importMatch[1],
+			raw: trimmed
+		});
+	}
+	return imports;
+}
+/** Extract imports from Go content */
+function extractGoImports(content) {
+	const imports = [];
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		const lineNum = i + 1;
+		const singleMatch = trimmed.match(/^import\s+"([^"]+)"/);
+		if (singleMatch) {
+			imports.push({
+				line: lineNum,
+				source: singleMatch[1],
+				raw: trimmed
+			});
+			continue;
+		}
+		const multiMatch = trimmed.match(/^"([^"]+)"$/);
+		if (multiMatch) {
+			const nearby = content.substring(Math.max(0, content.indexOf(lines[i]) - 200), content.indexOf(lines[i]) + lines[i].length);
+			if (nearby.includes("import") && nearby.includes("(")) imports.push({
+				line: lineNum,
+				source: multiMatch[1],
+				raw: trimmed
+			});
+		}
+	}
+	return imports;
+}
+/** Detect language from file extension and extract imports */
+function extractImportsFromContent(content, filePath) {
+	const ext = filePath.split(".").pop() ?? "";
+	if ([
+		"ts",
+		"tsx",
+		"js",
+		"jsx",
+		"mjs",
+		"cjs"
+	].includes(ext)) return extractJsImports(content);
+	if (["py", "pyw"].includes(ext)) return extractPythonImports(content);
+	if (ext === "go") return extractGoImports(content);
+	return extractJsImports(content);
+}
+/** Check if a path matches a glob pattern */
+function globMatch(pattern, path) {
+	return minimatch(path, pattern, { dot: true });
+}
+/** Build a diagnostic for an arch-rules violation */
+function buildDiag(opts) {
+	return {
+		filePath: opts.filePath,
+		engine: "arch-rules",
+		rule: `arch-rules/${opts.rule.name}`,
+		severity: opts.rule.severity,
+		message: opts.message,
+		help: opts.help,
+		line: opts.line,
+		column: opts.column,
+		category: "architecture",
+		fixable: false,
+		detail: {
+			ruleName: opts.rule.name,
+			ruleType: opts.rule.type
+		}
+	};
+}
+/**
+* forbid_import: Checks if a file contains a forbidden import.
+* The `forbid` field is a glob that matches against import sources.
+* The `match` field is a glob that selects which files to check.
+*/
+function applyForbidImport(rule, content, filePath) {
+	if (!rule.forbid) return [];
+	if (!globMatch(rule.match, filePath)) return [];
+	if (rule.where && !globMatch(rule.where, filePath)) return [];
+	const imports = extractImportsFromContent(content, filePath);
+	const results = [];
+	for (const imp of imports) if (globMatch(rule.forbid, imp.source)) {
+		const col = imp.raw.indexOf(imp.source) + 1;
+		results.push(buildDiag({
+			filePath,
+			rule,
+			line: imp.line,
+			column: Math.max(col, 1),
+			message: `Forbidden import '${imp.source}' found (rule: ${rule.name})`,
+			help: `The rule "${rule.name}" forbids importing modules matching "${rule.forbid}". Remove this import or update the rule.`
+		}));
+	}
+	return results;
+}
+/**
+* forbid_import_from_path: Checks cross-layer imports.
+* Files matching `match` must not import from paths matching `from`.
+* The `forbid` field specifies what is being imported (glob on import source).
+* The `from` field specifies the source path pattern that triggers the violation.
+*/
+function applyForbidImportFromPath(rule, content, filePath) {
+	if (!rule.forbid || !rule.from) return [];
+	if (!globMatch(rule.match, filePath)) return [];
+	if (rule.where && !globMatch(rule.where, filePath)) return [];
+	const imports = extractImportsFromContent(content, filePath);
+	const results = [];
+	for (const imp of imports) {
+		if (!globMatch(rule.forbid, imp.source)) continue;
+		if (!globMatch(rule.from, imp.source)) continue;
+		const col = imp.raw.indexOf(imp.source) + 1;
+		results.push(buildDiag({
+			filePath,
+			rule,
+			line: imp.line,
+			column: Math.max(col, 1),
+			message: `Cross-layer import: '${imp.source}' is forbidden from '${filePath}' (rule: ${rule.name})`,
+			help: `The rule "${rule.name}" forbids importing "${rule.forbid}" from "${rule.from}" in files matching "${rule.match}". Refactor to use a service layer or adapter instead.`
+		}));
+	}
+	return results;
+}
+/**
+* require_pattern: Checks that a required regex pattern exists in the file.
+* The `match` field is a glob that selects which files to check.
+* The `pattern` field is a regex that must be present in the file content.
+*/
+function applyRequirePattern(rule, content, filePath) {
+	if (!rule.pattern) return [];
+	if (!globMatch(rule.match, filePath)) return [];
+	if (rule.where && !globMatch(rule.where, filePath)) return [];
+	const results = [];
+	try {
+		if (!new RegExp(rule.pattern, "m").test(content)) results.push(buildDiag({
+			filePath,
+			rule,
+			line: 1,
+			column: 1,
+			message: `Required pattern /${rule.pattern}/ not found (rule: ${rule.name})`,
+			help: `The rule "${rule.name}" requires files matching "${rule.match}" to contain the pattern /${rule.pattern}/. Add the required pattern to this file.`
+		}));
+	} catch (err) {
+		results.push(buildDiag({
+			filePath,
+			rule,
+			line: 1,
+			column: 1,
+			message: `Rule "${rule.name}" has invalid regex pattern: ${rule.pattern}`,
+			help: `Fix the regex pattern in .deep-slop/rules.yml for rule "${rule.name}".`
+		}));
+	}
+	return results;
+}
+/**
+* Apply a single rule to a file, dispatching to the correct matcher.
+*/
+function applyRule(rule, content, filePath) {
+	switch (rule.type) {
+		case "forbid_import": return applyForbidImport(rule, content, filePath);
+		case "forbid_import_from_path": return applyForbidImportFromPath(rule, content, filePath);
+		case "require_pattern": return applyRequirePattern(rule, content, filePath);
+		default: return [];
+	}
+}
+
+//#endregion
+//#region src/engines/arch-rules/index.ts
+const archRulesEngine = {
+	name: "arch-rules",
+	description: "User-defined architecture rules from .deep-slop/rules.yml: forbid imports, enforce cross-layer boundaries, and require patterns.",
+	supportedLanguages: [
+		"typescript",
+		"javascript",
+		"python",
+		"go"
+	],
+	async run(context) {
+		const start = performance.now();
+		const { rootDirectory, config } = context;
+		let rules;
+		try {
+			rules = await loadRules(rootDirectory);
+		} catch (err) {
+			return {
+				engine: this.name,
+				diagnostics: [],
+				elapsed: performance.now() - start,
+				skipped: true,
+				skipReason: `Failed to load rules: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+		if (rules.length === 0) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No rules defined in .deep-slop/rules.yml"
+		};
+		const files = await collectFiles(rootDirectory, [
+			"typescript",
+			"javascript",
+			"python",
+			"go"
+		], config.exclude, context.files);
+		if (files.length === 0) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No files found for supported languages (ts, js, py, go)"
+		};
+		const diagnostics = [];
+		for (const absPath of files) {
+			const relPath = relative(rootDirectory, absPath);
+			let content;
+			try {
+				content = await readFileContent(absPath);
+			} catch {
+				continue;
+			}
+			for (const rule of rules) {
+				const ruleDiagnostics = applyRule(rule, content, relPath);
+				diagnostics.push(...ruleDiagnostics);
+			}
+		}
+		return {
+			engine: this.name,
+			diagnostics,
+			elapsed: performance.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { archRulesEngine };