aislop 0.4.0 → 0.5.1

package/dist/{expo-doctor-Cm5892Y8.js → expo-doctor-Bz0LZhQ6.js}

@@ -1,81 +1,9 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { n as runSubprocess } from "./subprocess-CQUJDGgn.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
-import { spawn } from "node:child_process";
 
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-//#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
 //#region src/engines/lint/expo-doctor.ts
 var expo_doctor_exports = /* @__PURE__ */ __exportAll({ runExpoDoctor: () => runExpoDoctor });
 const esmRequire = createRequire(import.meta.url);
@@ -146,7 +74,16 @@ const toDiagnostics = (issues) => issues.map((issue) => {
 		fixable: false
 	};
 });
+const hasExpoInstalled = (rootDirectory) => {
+	try {
+		createRequire(path.join(rootDirectory, "package.json")).resolve("expo/package.json");
+		return true;
+	} catch {
+		return false;
+	}
+};
 const runExpoDoctor = async (context) => {
+	if (!hasExpoInstalled(context.rootDirectory)) return [];
 	const scriptPath = resolveExpoDoctorScript();
 	let stdout = "";
 	let stderr = "";
@@ -187,7 +124,7 @@ const runExpoDoctor = async (context) => {
 		rule: "expo-doctor/config-error",
 		severity: "warning",
 		message: configError,
-		help: "Install project dependencies, then re-run `aislop scan`.",
+		help: "Install project dependencies, then re-run `npx aislop scan`.",
 		line: 0,
 		column: 0,
 		category: "Expo",
@@ -197,4 +134,4 @@ const runExpoDoctor = async (context) => {
 };
 
 //#endregion
-export { runSubprocess as i, runExpoDoctor as n, isToolInstalled as r, expo_doctor_exports as t };
+export { runExpoDoctor as n, expo_doctor_exports as t };

package/dist/generic-BrcWMW7E.js

@@ -0,0 +1,109 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { n as runSubprocess } from "./subprocess-CQUJDGgn.js";
+
+//#region src/engines/lint/generic.ts
+var generic_exports = /* @__PURE__ */ __exportAll({
+	fixRubyLint: () => fixRubyLint,
+	runGenericLinter: () => runGenericLinter
+});
+const runGenericLinter = async (context, language) => {
+	switch (language) {
+		case "rust": return runClippy(context);
+		case "ruby": return runRubocop(context);
+		default: return [];
+	}
+};
+const fixRubyLint = async (rootDirectory) => {
+	const result = await runSubprocess("rubocop", [
+		"-a",
+		"--except",
+		"Layout"
+	], {
+		cwd: rootDirectory,
+		timeout: 6e4
+	});
+	if (result.exitCode !== null && result.exitCode > 1) throw new Error(result.stderr || result.stdout || `rubocop exited with code ${result.exitCode}`);
+};
+const runClippy = async (context) => {
+	try {
+		return parseClippyDiagnostics((await runSubprocess("cargo", [
+			"clippy",
+			"--message-format=json",
+			"--quiet"
+		], {
+			cwd: context.rootDirectory,
+			timeout: 12e4
+		})).stdout);
+	} catch {
+		return [];
+	}
+};
+const parseClippyEntry = (line) => {
+	if (!line.startsWith("{")) return null;
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+};
+const toClippyDiagnostic = (entry) => {
+	if (entry.reason !== "compiler-message" || !entry.message) return null;
+	const message = entry.message;
+	const span = message.spans?.[0];
+	return {
+		filePath: span?.file_name ?? "",
+		engine: "lint",
+		rule: `clippy/${message.code?.code ?? "unknown"}`,
+		severity: message.level === "error" ? "error" : "warning",
+		message: message.message ?? "",
+		help: message.children?.[0]?.message ?? "",
+		line: span?.line_start ?? 0,
+		column: span?.column_start ?? 0,
+		category: "Rust Lint",
+		fixable: false
+	};
+};
+const parseClippyDiagnostics = (output) => {
+	const diagnostics = [];
+	for (const line of output.split("\n")) {
+		const entry = parseClippyEntry(line);
+		if (!entry) continue;
+		const diagnostic = toClippyDiagnostic(entry);
+		if (diagnostic) diagnostics.push(diagnostic);
+	}
+	return diagnostics;
+};
+const runRubocop = async (context) => {
+	try {
+		const output = (await runSubprocess("rubocop", [
+			"--format",
+			"json",
+			"--except",
+			"Layout"
+		], {
+			cwd: context.rootDirectory,
+			timeout: 6e4
+		})).stdout;
+		if (!output) return [];
+		const parsed = JSON.parse(output);
+		const diagnostics = [];
+		for (const file of parsed.files ?? []) for (const offense of file.offenses ?? []) diagnostics.push({
+			filePath: file.path,
+			engine: "lint",
+			rule: `rubocop/${offense.cop_name}`,
+			severity: offense.severity === "error" || offense.severity === "fatal" ? "error" : "warning",
+			message: offense.message,
+			help: "",
+			line: offense.location?.start_line ?? 0,
+			column: offense.location?.start_column ?? 0,
+			category: "Ruby Lint",
+			fixable: offense.correctable ?? false
+		});
+		return diagnostics;
+	} catch {
+		return [];
+	}
+};
+
+//#endregion
+export { generic_exports as n, runGenericLinter as r, fixRubyLint as t };

package/dist/index.d.ts

@@ -1,7 +1,25 @@
 import { z } from "zod/v4";
 
 //#region src/commands/doctor.d.ts
-declare const doctorCommand: (directory: string) => Promise<void>;
+interface DoctorEngineRow {
+  engine: string;
+  tool: string;
+  status: "ok" | "missing" | "skipped";
+  remediation?: string;
+  skipReason?: string;
+}
+interface BuildDoctorRenderInput {
+  projectName: string;
+  languageLabel: string;
+  rows: DoctorEngineRow[];
+  invocation: string;
+  printBrand?: boolean;
+}
+declare const buildDoctorRender: (input: BuildDoctorRenderInput) => string;
+interface DoctorOptions {
+  printBrand?: boolean;
+}
+declare const doctorCommand: (directory: string, options?: DoctorOptions) => Promise<void>;
 //#endregion
 //#region src/config/schema.d.ts
 declare const AislopConfigSchema: z.ZodObject<{
@@ -47,6 +65,14 @@ type AislopConfig = z.infer<typeof AislopConfigSchema>;
 //#region src/config/index.d.ts
 declare const loadConfig: (directory: string) => AislopConfig;
 //#endregion
+//#region src/ui/rail.d.ts
+type RailStepStatus = "active" | "done" | "warn" | "failed" | "skipped";
+interface RailStep {
+  status: RailStepStatus;
+  label: string;
+  notes?: string[];
+}
+//#endregion
 //#region src/commands/fix.d.ts
 interface FixOptions {
   verbose: boolean;
@@ -56,29 +82,44 @@ interface FixOptions {
   /** Print the prompt to stdout instead of launching an agent */
   prompt?: boolean;
   showHeader?: boolean;
+  printBrand?: boolean;
 }
 declare const fixCommand: (directory: string, config: AislopConfig, options?: FixOptions) => Promise<void>;
 //#endregion
 //#region src/commands/init.d.ts
-declare const initCommand: (directory: string) => Promise<void>;
+interface BuildInitRenderInput {
+  steps: RailStep[];
+  nextCommand: string;
+  includeHeader?: boolean;
+  printBrand?: boolean;
+}
+declare const buildInitSuccessRender: (input: BuildInitRenderInput) => string;
+interface InitOptions {
+  printBrand?: boolean;
+}
+declare const initCommand: (directory: string, options?: InitOptions) => Promise<void>;
 //#endregion
-//#region src/commands/scan.d.ts
-interface ScanOptions {
-  changes: boolean;
-  staged: boolean;
-  verbose: boolean;
-  json: boolean;
-  showHeader?: boolean;
-  /** Used for telemetry to distinguish scan vs ci invocation */
-  command?: "scan" | "ci";
+//#region src/commands/rules.d.ts
+interface RuleEntry {
+  id: string;
+  engine: string;
+  severity: "error" | "warning" | "info";
+  fixable: boolean;
 }
-declare const scanCommand: (directory: string, config: AislopConfig, options: ScanOptions) => Promise<{
-  exitCode: number;
-}>;
+interface BuildRulesRenderInput {
+  rules: RuleEntry[];
+  invocation?: string;
+  printBrand?: boolean;
+}
+declare const buildRulesRender: (input: BuildRulesRenderInput) => string;
+interface RulesOptions {
+  printBrand?: boolean;
+}
+declare const rulesCommand: (directory: string, options?: RulesOptions) => Promise<void>;
 //#endregion
 //#region src/utils/discover.d.ts
 type Language = "typescript" | "javascript" | "python" | "go" | "rust" | "java" | "ruby" | "php";
-type Framework = "nextjs" | "react" | "vite" | "remix" | "expo" | "django" | "flask" | "fastapi" | "none";
+type Framework = "nextjs" | "react" | "vite" | "remix" | "expo" | "astro" | "django" | "flask" | "fastapi" | "none";
 interface ProjectInfo {
   rootDirectory: string;
   projectName: string;
@@ -112,6 +153,21 @@ interface EngineResult {
   skipReason?: string;
 }
 //#endregion
+//#region src/commands/scan.d.ts
+interface ScanOptions {
+  changes: boolean;
+  staged: boolean;
+  verbose: boolean;
+  json: boolean;
+  showHeader?: boolean;
+  printBrand?: boolean;
+  /** Used for telemetry to distinguish scan vs ci invocation */
+  command?: "scan" | "ci";
+}
+declare const scanCommand: (directory: string, config: AislopConfig, options: ScanOptions) => Promise<{
+  exitCode: number;
+}>;
+//#endregion
 //#region src/scoring/index.d.ts
 interface ScoreResult {
   score: number;
@@ -122,4 +178,4 @@ declare const calculateScore: (diagnostics: Diagnostic[], weights: Record<string
   ok: number;
 }, sourceFileCount?: number, smoothing?: number) => ScoreResult;
 //#endregion
-export { type AislopConfig, type Diagnostic, type EngineName, type EngineResult, type Framework, type Language, type ProjectInfo, type ScoreResult, type Severity, calculateScore, discoverProject, doctorCommand, fixCommand, initCommand, loadConfig, scanCommand };
+export { type AislopConfig, type Diagnostic, type EngineName, type EngineResult, type Framework, type Language, type ProjectInfo, type ScoreResult, type Severity, buildDoctorRender, buildInitSuccessRender, buildRulesRender, calculateScore, discoverProject, doctorCommand, fixCommand, initCommand, loadConfig, rulesCommand, scanCommand };