aislop 0.1.0

package/dist/json-DkpW9UQj.js

@@ -0,0 +1,30 @@
+import { r as APP_VERSION, t as ENGINE_INFO } from "./engine-info-DBG3uXLc.js";
+
+//#region src/output/json.ts
+const buildJsonOutput = (results, scoreResult, fileCount, elapsedMs) => {
+	const allDiagnostics = results.flatMap((r) => r.diagnostics);
+	const engines = {};
+	for (const result of results) engines[result.engine] = {
+		issues: result.diagnostics.length,
+		skipped: result.skipped,
+		elapsed: result.elapsed
+	};
+	return {
+		version: APP_VERSION,
+		score: scoreResult.score,
+		label: scoreResult.label,
+		engines,
+		engineDefinitions: ENGINE_INFO,
+		diagnostics: allDiagnostics,
+		summary: {
+			errors: allDiagnostics.filter((d) => d.severity === "error").length,
+			warnings: allDiagnostics.filter((d) => d.severity === "warning").length,
+			fixable: allDiagnostics.filter((d) => d.fixable).length,
+			files: fileCount,
+			elapsed: elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`
+		}
+	};
+};
+
+//#endregion
+export { buildJsonOutput };

package/dist/json-L5x3hQdy.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { n as ENGINE_INFO, t as APP_VERSION } from "./cli.js";
+
+//#region src/output/json.ts
+const buildJsonOutput = (results, scoreResult, fileCount, elapsedMs) => {
+	const allDiagnostics = results.flatMap((r) => r.diagnostics);
+	const engines = {};
+	for (const result of results) engines[result.engine] = {
+		issues: result.diagnostics.length,
+		skipped: result.skipped,
+		elapsed: result.elapsed
+	};
+	return {
+		version: APP_VERSION,
+		score: scoreResult.score,
+		label: scoreResult.label,
+		engines,
+		engineDefinitions: ENGINE_INFO,
+		diagnostics: allDiagnostics,
+		summary: {
+			errors: allDiagnostics.filter((d) => d.severity === "error").length,
+			warnings: allDiagnostics.filter((d) => d.severity === "warning").length,
+			fixable: allDiagnostics.filter((d) => d.fixable).length,
+			files: fileCount,
+			elapsed: elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(1)}s`
+		}
+	};
+};
+
+//#endregion
+export { buildJsonOutput };

package/dist/subprocess-99puEEGl.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+
+//#region src/utils/subprocess.ts
+const runSubprocess = (command, args, options = {}) => {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...options.env
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true
+		});
+		const stdoutBuffers = [];
+		const stderrBuffers = [];
+		child.stdout?.on("data", (buffer) => stdoutBuffers.push(buffer));
+		child.stderr?.on("data", (buffer) => stderrBuffers.push(buffer));
+		let settled = false;
+		let timer;
+		const finalize = (callback) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			callback();
+		};
+		if (options.timeout && options.timeout > 0) {
+			timer = setTimeout(() => {
+				child.kill("SIGTERM");
+				setTimeout(() => child.kill("SIGKILL"), 1e3).unref();
+				finalize(() => reject(/* @__PURE__ */ new Error(`Command timed out after ${options.timeout}ms: ${command}`)));
+			}, options.timeout);
+			timer.unref();
+		}
+		child.once("error", (error) => finalize(() => reject(/* @__PURE__ */ new Error(`Failed to run ${command}: ${error.message}`))));
+		child.once("close", (code) => {
+			finalize(() => resolve({
+				stdout: Buffer.concat(stdoutBuffers).toString("utf-8").trim(),
+				stderr: Buffer.concat(stderrBuffers).toString("utf-8").trim(),
+				exitCode: code
+			}));
+		});
+	});
+};
+const isToolInstalled = async (tool) => {
+	try {
+		const result = await runSubprocess("which", [tool]);
+		return result.exitCode === 0 && result.stdout.length > 0;
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+export { runSubprocess as n, isToolInstalled as t };

package/package.json

@@ -0,0 +1,81 @@
+{
+	"name": "aislop",
+	"version": "0.1.0",
+	"description": "Stop AI slop from shipping. A unified code quality CLI that catches the lazy patterns AI coding tools leave behind.",
+	"type": "module",
+	"bin": {
+		"aislop": "./dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"scripts"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"dev": "tsdown --watch",
+		"build": "rm -rf dist && NODE_ENV=production tsdown",
+		"postinstall": "node scripts/postinstall-tools.mjs",
+		"typecheck": "tsc --noEmit",
+		"test": "pnpm build && vitest run",
+		"scan": "pnpm build && node dist/cli.js scan .",
+		"scan:json": "pnpm build && node dist/cli.js scan . --json",
+		"quality": "pnpm typecheck && pnpm test && node dist/cli.js scan . --json"
+	},
+	"keywords": [
+		"aislop",
+		"ai-slop",
+		"code-quality",
+		"linter",
+		"formatter",
+		"cli",
+		"ai",
+		"copilot",
+		"code-review",
+		"static-analysis",
+		"typescript",
+		"javascript",
+		"python",
+		"go",
+		"rust",
+		"ruby",
+		"php"
+	],
+	"author": "heavykenny",
+	"license": "MIT",
+	"homepage": "https://github.com/heavykenny/aislop#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/heavykenny/aislop.git"
+	},
+	"bugs": {
+		"url": "https://github.com/heavykenny/aislop/issues"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"packageManager": "pnpm@10.28.0",
+	"dependencies": {
+		"@biomejs/biome": "^2.4.5",
+		"adm-zip": "^0.5.16",
+		"commander": "^14.0.3",
+		"expo-doctor": "^1.18.10",
+		"knip": "^5.85.0",
+		"ora": "^9.3.0",
+		"oxlint": "^1.51.0",
+		"picocolors": "^1.1.1",
+		"tar": "^7.5.11",
+		"yaml": "^2.8.2",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"@types/node": "^25.3.3",
+		"tsdown": "^0.20.3",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.18"
+	}
+}

package/scripts/postinstall-tools.mjs

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import AdmZip from "adm-zip";
+import * as tar from "tar";
+
+const THIS_FILE = fileURLToPath(import.meta.url);
+const PACKAGE_ROOT = path.resolve(path.dirname(THIS_FILE), "..");
+const TOOLS_BIN_DIR = path.join(PACKAGE_ROOT, "tools", "bin");
+const USER_AGENT = "aislop-installer";
+
+const PLATFORM_KEY = `${process.platform}-${process.arch}`;
+
+const TOOL_DEFINITIONS = [
+	{
+		name: "ruff",
+		repo: "astral-sh/ruff",
+		version: "0.15.4",
+		tag: "0.15.4",
+		binaryName: "ruff",
+		assets: {
+			"darwin-arm64": ["ruff-aarch64-apple-darwin.tar.gz"],
+			"darwin-x64": ["ruff-x86_64-apple-darwin.tar.gz"],
+			"linux-arm64": ["ruff-aarch64-unknown-linux-gnu.tar.gz"],
+			"linux-x64": ["ruff-x86_64-unknown-linux-gnu.tar.gz"],
+			"win32-arm64": ["ruff-aarch64-pc-windows-msvc.zip"],
+			"win32-x64": ["ruff-x86_64-pc-windows-msvc.zip"],
+		},
+	},
+	{
+		name: "golangci-lint",
+		repo: "golangci/golangci-lint",
+		version: "2.10.1",
+		tag: "v2.10.1",
+		binaryName: "golangci-lint",
+		assets: {
+			"darwin-arm64": [
+				"golangci-lint-2.10.1-darwin-arm64.tar.gz",
+				"golangci-lint-v2.10.1-darwin-arm64.tar.gz",
+			],
+			"darwin-x64": [
+				"golangci-lint-2.10.1-darwin-amd64.tar.gz",
+				"golangci-lint-v2.10.1-darwin-amd64.tar.gz",
+			],
+			"linux-arm64": [
+				"golangci-lint-2.10.1-linux-arm64.tar.gz",
+				"golangci-lint-v2.10.1-linux-arm64.tar.gz",
+			],
+			"linux-x64": [
+				"golangci-lint-2.10.1-linux-amd64.tar.gz",
+				"golangci-lint-v2.10.1-linux-amd64.tar.gz",
+			],
+			"win32-arm64": [
+				"golangci-lint-2.10.1-windows-arm64.zip",
+				"golangci-lint-v2.10.1-windows-arm64.zip",
+			],
+			"win32-x64": [
+				"golangci-lint-2.10.1-windows-amd64.zip",
+				"golangci-lint-v2.10.1-windows-amd64.zip",
+			],
+		},
+	},
+];
+
+const isWindows = process.platform === "win32";
+const withExecutableExtension = (name) => (isWindows ? `${name}.exe` : name);
+
+const info = (message) => console.log(`[aislop] ${message}`);
+const warn = (message) => console.warn(`[aislop] ${message}`);
+
+const downloadFile = async (url, destination) => {
+	const response = await fetch(url, {
+		headers: { "User-Agent": USER_AGENT },
+	});
+	if (!response.ok || !response.body) {
+		throw new Error(`Failed to download ${url} (${response.status})`);
+	}
+	await pipeline(
+		Readable.fromWeb(response.body),
+		fs.createWriteStream(destination),
+	);
+};
+
+const extractArchive = async (archivePath, extractDir) => {
+	if (archivePath.endsWith(".tar.gz")) {
+		await tar.x({ file: archivePath, cwd: extractDir });
+		return;
+	}
+	if (archivePath.endsWith(".zip")) {
+		const zip = new AdmZip(archivePath);
+		zip.extractAllTo(extractDir, true);
+		return;
+	}
+	throw new Error(`Unsupported archive format for ${archivePath}`);
+};
+
+const getTagCandidates = (tag) => {
+	if (tag.startsWith("v")) {
+		return [tag, tag.slice(1)];
+	}
+	return [tag, `v${tag}`];
+};
+
+const getAssetUrls = (tool, assetName) =>
+	getTagCandidates(tool.tag).map(
+		(tag) =>
+			`https://github.com/${tool.repo}/releases/download/${tag}/${assetName}`,
+	);
+
+const downloadFromCandidates = async (urls, archivePath) => {
+	const failures = [];
+	for (const url of urls) {
+		try {
+			await downloadFile(url, archivePath);
+			return url;
+		} catch (error) {
+			failures.push(error instanceof Error ? error.message : String(error));
+		}
+	}
+	throw new Error(
+		`Could not download from candidate URLs: ${failures.join(" | ")}`,
+	);
+};
+
+const findBinary = (rootDir, binaryName) => {
+	const queue = [rootDir];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current) continue;
+		const entries = fs.readdirSync(current, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(current, entry.name);
+			if (entry.isDirectory()) {
+				queue.push(fullPath);
+				continue;
+			}
+			if (entry.name === binaryName) return fullPath;
+		}
+	}
+	return null;
+};
+
+const installTool = async (tool) => {
+	const assetNames = tool.assets[PLATFORM_KEY];
+	if (!assetNames || assetNames.length === 0) {
+		warn(`No bundled ${tool.name} build for ${PLATFORM_KEY}; skipping.`);
+		return false;
+	}
+
+	const destinationBinary = path.join(
+		TOOLS_BIN_DIR,
+		withExecutableExtension(tool.binaryName),
+	);
+	if (fs.existsSync(destinationBinary)) {
+		info(`${tool.name} already present.`);
+		return true;
+	}
+
+	const tempDir = fs.mkdtempSync(
+		path.join(os.tmpdir(), `aislop-${tool.name}-`),
+	);
+	const archivePath = path.join(tempDir, assetNames[0]);
+	const extractDir = path.join(tempDir, "extract");
+	fs.mkdirSync(extractDir, { recursive: true });
+
+	try {
+		const candidateUrls = assetNames.flatMap((assetName) =>
+			getAssetUrls(tool, assetName),
+		);
+		info(`Downloading ${tool.name} ${tool.version}...`);
+		await downloadFromCandidates(candidateUrls, archivePath);
+		await extractArchive(archivePath, extractDir);
+
+		const extractedBinary = findBinary(
+			extractDir,
+			withExecutableExtension(tool.binaryName),
+		);
+		if (!extractedBinary) {
+			throw new Error(
+				`Unable to locate ${tool.binaryName} in extracted archive`,
+			);
+		}
+
+		fs.mkdirSync(TOOLS_BIN_DIR, { recursive: true });
+		fs.copyFileSync(extractedBinary, destinationBinary);
+		if (!isWindows) fs.chmodSync(destinationBinary, 0o755);
+
+		info(`Installed bundled ${tool.name} at ${destinationBinary}`);
+		return true;
+	} finally {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	}
+};
+
+const main = async () => {
+	if (process.env.AISLOP_SKIP_TOOL_DOWNLOAD === "1") {
+		info("Skipping bundled tool download (AISLOP_SKIP_TOOL_DOWNLOAD=1).");
+		return;
+	}
+
+	const failures = [];
+	for (const tool of TOOL_DEFINITIONS) {
+		try {
+			const installed = await installTool(tool);
+			if (!installed) {
+				failures.push(`${tool.name}: unsupported platform`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			failures.push(`${tool.name}: ${message}`);
+			warn(`Failed to install ${tool.name}: ${message}`);
+		}
+	}
+
+	if (failures.length > 0) {
+		warn("Some bundled tools could not be installed:");
+		for (const failure of failures) {
+			warn(`  - ${failure}`);
+		}
+		warn(
+			"aislop will still run, but coverage for those tools may be reduced until installation succeeds.",
+		);
+	}
+};
+
+main().catch((error) => {
+	warn(
+		`postinstall failed: ${error instanceof Error ? error.message : String(error)}`,
+	);
+});