deep-slop 1.4.1

package/dist/knip-CgxnnTBZ.js

@@ -0,0 +1,93 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+//#region src/engines/knip/index.ts
+const execFileAsync = promisify(execFile);
+const KNIPTIMEOUT_MS = 3e4;
+/** Check if knip is installed by running `npx knip --version` */
+async function isKnipInstalled() {
+	try {
+		await execFileAsync("npx", ["knip", "--version"], { timeout: 15e3 });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Run knip with JSON reporter and return parsed output */
+async function runKnip(rootDir) {
+	try {
+		const { stdout } = await execFileAsync("npx", [
+			"knip",
+			"--reporter",
+			"json",
+			"--no-progress"
+		], {
+			timeout: KNIPTIMEOUT_MS,
+			cwd: rootDir
+		});
+		if (!String(stdout).trim()) return null;
+		return JSON.parse(String(stdout));
+	} catch {
+		return null;
+	}
+}
+/** Map a knip section to diagnostics */
+function mapKnipSection(section, rulePrefix, messageLabel) {
+	if (!section) return [];
+	const diagnostics = [];
+	for (const [filePath, symbols] of Object.entries(section)) for (const symbol of symbols) diagnostics.push({
+		filePath,
+		engine: "knip",
+		rule: `knip/${rulePrefix}`,
+		severity: "warning",
+		message: `${messageLabel}: ${symbol}`,
+		help: `Remove the unused ${messageLabel.toLowerCase()} \`${symbol}\` or re-export it if it is part of the public API`,
+		line: 1,
+		column: 1,
+		category: "dead-code",
+		fixable: true,
+		detail: {
+			symbol,
+			type: rulePrefix
+		}
+	});
+	return diagnostics;
+}
+const knipEngine = {
+	name: "knip",
+	description: "Runs knip to detect unused files, dependencies, exports, and types in TypeScript/JavaScript projects",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const start = Date.now();
+		if (!await isKnipInstalled()) return {
+			engine: "knip",
+			diagnostics: [],
+			elapsed: Date.now() - start,
+			skipped: true,
+			skipReason: "knip is not installed. Install with: npm i -D knip"
+		};
+		const output = await runKnip(context.rootDirectory);
+		if (!output) return {
+			engine: "knip",
+			diagnostics: [],
+			elapsed: Date.now() - start,
+			skipped: false
+		};
+		return {
+			engine: "knip",
+			diagnostics: [
+				...mapKnipSection(output.files, "unused-file", "Unused file"),
+				...mapKnipSection(output.dependencies, "unused-dependency", "Unused dependency"),
+				...mapKnipSection(output.exports, "unused-export", "Unused export"),
+				...mapKnipSection(output.types, "unused-type", "Unused type"),
+				...mapKnipSection(output.classMembers, "unused-class-member", "Unused class member"),
+				...mapKnipSection(output.enumMembers, "unused-enum-member", "Unused enum member")
+			],
+			elapsed: Date.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { knipEngine };

package/dist/lint-external-ZbW3jGvB.js

@@ -0,0 +1,326 @@
+import { existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { execSync } from "node:child_process";
+
+//#region src/engines/lint-external/python.ts
+/** Default timeout for ruff execution (ms) */
+const RUFF_TIMEOUT_MS = 3e4;
+/** Check if ruff is available on PATH */
+function isRuffAvailable() {
+	try {
+		execSync("ruff --version", {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Map ruff severity-like codes to our severity levels */
+function mapSeverity$2(code) {
+	if ([
+		"S",
+		"T20",
+		"ERA"
+	].some((p) => code.startsWith(p))) return "error";
+	return "warning";
+}
+/** Run ruff and return diagnostics */
+function runRuff(context) {
+	if (!isRuffAvailable()) return [];
+	const root = context.rootDirectory;
+	let rawOutput;
+	try {
+		rawOutput = execSync("ruff check --output-format=json .", {
+			cwd: root,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: RUFF_TIMEOUT_MS,
+			encoding: "utf-8"
+		});
+	} catch (err) {
+		const e = err;
+		if (e.stdout && typeof e.stdout === "string") rawOutput = e.stdout;
+		else return [];
+	}
+	let findings;
+	try {
+		findings = JSON.parse(rawOutput);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(findings)) return [];
+	const diagnostics = [];
+	for (const f of findings) {
+		const filePath = relative(root, f.filename).replace(/\\/g, "/");
+		const ruleId = f.code ?? "unknown";
+		const severity = mapSeverity$2(ruleId);
+		diagnostics.push({
+			engine: "lint-external",
+			filePath,
+			rule: `lint-external/ruff-${ruleId}`,
+			severity,
+			message: f.message,
+			help: f.fix?.message ?? `Run 'ruff rule ${ruleId}' for details`,
+			line: f.location?.row ?? 1,
+			column: f.location?.column ?? 1,
+			category: "style",
+			fixable: f.fix != null
+		});
+	}
+	return diagnostics;
+}
+/** Check if ruff is installed (for skip detection) */
+function ruffAvailable() {
+	return isRuffAvailable();
+}
+
+//#endregion
+//#region src/engines/lint-external/go.ts
+/** Default timeout for golangci-lint execution (ms) */
+const GOLANGCI_TIMEOUT_MS = 6e4;
+/** Check if golangci-lint is available on PATH */
+function isGolangciAvailable() {
+	try {
+		execSync("golangci-lint version", {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Check if go.mod exists in the project */
+function hasGoMod(root) {
+	return existsSync(join(root, "go.mod"));
+}
+/** Map golangci-lint severity to our severity levels */
+function mapSeverity$1(linter, textSeverity) {
+	if (textSeverity === "error") return "error";
+	if ([
+		"govet",
+		"errcheck",
+		"sqlclosecheck",
+		"rowserrcheck"
+	].includes(linter)) return "error";
+	return "warning";
+}
+/** Run golangci-lint and return diagnostics */
+function runGolangciLint(context) {
+	if (!isGolangciAvailable()) return [];
+	if (!hasGoMod(context.rootDirectory)) return [];
+	const root = context.rootDirectory;
+	let rawOutput;
+	try {
+		rawOutput = execSync("golangci-lint run --out-format=json ./...", {
+			cwd: root,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: GOLANGCI_TIMEOUT_MS,
+			encoding: "utf-8"
+		});
+	} catch (err) {
+		const e = err;
+		if (e.stdout && typeof e.stdout === "string") rawOutput = e.stdout;
+		else return [];
+	}
+	let report;
+	try {
+		report = JSON.parse(rawOutput);
+	} catch {
+		return [];
+	}
+	const issues = report.Issues;
+	if (!Array.isArray(issues)) return [];
+	const diagnostics = [];
+	for (const issue of issues) {
+		const filePath = relative(root, issue.Pos.Filename).replace(/\\/g, "/");
+		const linter = issue.FromLinter ?? "unknown";
+		const severity = mapSeverity$1(linter, issue.Severity ?? "");
+		diagnostics.push({
+			engine: "lint-external",
+			filePath,
+			rule: `lint-external/golangci-${linter}`,
+			severity,
+			message: issue.Text,
+			help: `See golangci-lint documentation for linter: ${linter}`,
+			line: issue.Pos.Line ?? 1,
+			column: issue.Pos.Column ?? 1,
+			category: "style",
+			fixable: issue.Replacement != null
+		});
+	}
+	return diagnostics;
+}
+/** Check if golangci-lint is installed (for skip detection) */
+function golangciAvailable() {
+	return isGolangciAvailable();
+}
+
+//#endregion
+//#region src/engines/lint-external/rust.ts
+/** Default timeout for cargo clippy execution (ms) */
+const CLIPPY_TIMEOUT_MS = 12e4;
+/** Check if cargo is available on PATH */
+function isCargoAvailable() {
+	try {
+		execSync("cargo --version", {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Check if Cargo.toml exists in the project */
+function hasCargoToml(root) {
+	return existsSync(join(root, "Cargo.toml"));
+}
+/** Map clippy level to our severity */
+function mapSeverity(level) {
+	if (level === "error") return "error";
+	if (level === "warning") return "warning";
+	return "info";
+}
+/** Map clippy lint code to a category */
+function mapCategory(code) {
+	if (code.startsWith("clippy::correctness")) return "syntax";
+	if (code.startsWith("clippy::suspicious")) return "security";
+	if (code.startsWith("clippy::style")) return "style";
+	if (code.startsWith("clippy::complexity")) return "architecture";
+	if (code.startsWith("clippy::perf")) return "performance";
+	if (code.startsWith("clippy::pedantic") || code.startsWith("clippy::restriction")) return "style";
+	if (code.startsWith("clippy::nursery")) return "style";
+	return "style";
+}
+/** Run cargo clippy and return diagnostics */
+function runClippy(context) {
+	if (!isCargoAvailable()) return [];
+	if (!hasCargoToml(context.rootDirectory)) return [];
+	const root = context.rootDirectory;
+	let rawOutput;
+	try {
+		rawOutput = execSync("cargo clippy --message-format=json 2>&1", {
+			cwd: root,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: CLIPPY_TIMEOUT_MS,
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+	} catch (err) {
+		const e = err;
+		if (e.stdout && typeof e.stdout === "string") rawOutput = e.stdout;
+		else return [];
+	}
+	const diagnostics = [];
+	const lines = rawOutput.split("\n").filter((l) => l.trim().length > 0);
+	for (const line of lines) {
+		let msg;
+		try {
+			msg = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (msg.reason !== "compiler-message" || !msg.message) continue;
+		const m = msg.message;
+		if (!m.spans || m.spans.length === 0) continue;
+		const primarySpan = m.spans.find((s) => s.is_primary) ?? m.spans[0];
+		const code = m.code?.code ?? "clippy::unknown";
+		const severity = mapSeverity(m.level);
+		const category = mapCategory(code);
+		const filePath = relative(root, primarySpan.file_name).replace(/\\/g, "/");
+		const help = m.children?.map((c) => c.message).join("; ") ?? `Run 'cargo clippy --explain ${code}' for details`;
+		diagnostics.push({
+			engine: "lint-external",
+			filePath,
+			rule: `lint-external/${code}`,
+			severity,
+			message: m.message ?? m.rendered?.split("\n")[0] ?? code,
+			help,
+			line: primarySpan.line_start ?? 1,
+			column: primarySpan.column_start ?? 1,
+			category,
+			fixable: false
+		});
+	}
+	return diagnostics;
+}
+/** Check if cargo/clippy is installed (for skip detection) */
+function clippyAvailable() {
+	return isCargoAvailable();
+}
+
+//#endregion
+//#region src/engines/lint-external/index.ts
+/** Lint-external engine: runs external linters (ruff, golangci-lint, clippy) */
+const lintExternalEngine = {
+	name: "lint-external",
+	description: "External linter integration: runs ruff (Python), golangci-lint (Go), and clippy (Rust) when available",
+	supportedLanguages: [
+		"python",
+		"go",
+		"rust"
+	],
+	async run(context) {
+		const start = performance.now();
+		const diagnostics = [];
+		const languages = context.languages;
+		const skipReasons = [];
+		let anyLinterRan = false;
+		if (languages.includes("python")) if (ruffAvailable()) {
+			const ruffDiags = runRuff(context);
+			diagnostics.push(...ruffDiags);
+			anyLinterRan = true;
+		} else skipReasons.push("python: ruff not installed");
+		if (languages.includes("go")) if (golangciAvailable()) {
+			const goDiags = runGolangciLint(context);
+			diagnostics.push(...goDiags);
+			anyLinterRan = true;
+		} else skipReasons.push("go: golangci-lint not installed");
+		if (languages.includes("rust")) if (clippyAvailable()) {
+			const rustDiags = runClippy(context);
+			diagnostics.push(...rustDiags);
+			anyLinterRan = true;
+		} else skipReasons.push("rust: cargo/clippy not installed");
+		if (!languages.some((l) => [
+			"python",
+			"go",
+			"rust"
+		].includes(l))) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: "No Python, Go, or Rust detected in project"
+		};
+		if (!anyLinterRan) return {
+			engine: this.name,
+			diagnostics: [],
+			elapsed: performance.now() - start,
+			skipped: true,
+			skipReason: `No external linters available (${skipReasons.join("; ")})`
+		};
+		return {
+			engine: this.name,
+			diagnostics,
+			elapsed: performance.now() - start,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { lintExternalEngine };