@alint-js/cli 0.0.1 → 0.0.4

package/dist/cli-CoS-NVz_.mjs

@@ -0,0 +1,1099 @@
+import process from "node:process";
+import { stat } from "node:fs/promises";
+import { inspect } from "node:util";
+import Gitignore from "gitignore-fs";
+import c, { createColors } from "tinyrainbow";
+import { getGlobalSetupConfigPath, getProjectSetupConfigPath, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, writeSetupConfig } from "@alint-js/config";
+import { AlintRunError, runAlint } from "@alint-js/core";
+import { errorMessageFrom } from "@moeru/std/error";
+import { cac } from "cac";
+import { resolve } from "pathe";
+import { getBorderCharacters, table } from "table";
+import cliSpinners from "cli-spinners";
+import { relative } from "node:path";
+//#region src/cli/provider-registry.ts
+function buildModelsUrl(endpoint) {
+	return new URL("models", endpoint.endsWith("/") ? endpoint : `${endpoint}/`).toString();
+}
+function createProviderId(endpoint, existingIds) {
+	let base = "provider";
+	try {
+		base = new URL(endpoint).hostname.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "provider";
+	} catch {
+		base = "provider";
+	}
+	if (!existingIds.has(base)) return base;
+	for (let index = 2;; index += 1) {
+		const candidate = `${base}-${index}`;
+		if (!existingIds.has(candidate)) return candidate;
+	}
+}
+function findModel(config, request) {
+	return flattenModels(config).find(({ model }) => model.id === request || model.name === request || (model.aliases ?? []).includes(request));
+}
+function flattenModels(config) {
+	return config.providers.flatMap((provider) => provider.models.map((model) => ({
+		model,
+		provider
+	})));
+}
+function formatModelList(config) {
+	return formatTable([[
+		"id",
+		"provider",
+		"name"
+	], ...flattenModels(config).map(({ model, provider }) => [
+		model.id,
+		provider.id,
+		model.name ?? model.id
+	])]);
+}
+function formatModelShow(candidate) {
+	const { model, provider } = candidate;
+	const lines = [
+		`id: ${model.id}`,
+		`name: ${model.name ?? model.id}`,
+		`provider: ${provider.id}`,
+		`endpoint: ${provider.endpoint}`
+	];
+	if (model.aliases?.length) lines.push(`aliases: ${model.aliases.join(", ")}`);
+	if (model.capabilities?.length) lines.push(`capabilities: ${model.capabilities.join(", ")}`);
+	if (model.size !== void 0) lines.push(`size: ${model.size}`);
+	if (model.contextWindow !== void 0) lines.push(`contextWindow: ${model.contextWindow}`);
+	if (model.defaultParams !== void 0) lines.push(`defaultParams: ${JSON.stringify(model.defaultParams)}`);
+	return `${lines.join("\n")}\n`;
+}
+function formatProviderList(config) {
+	return formatTable([[
+		"id",
+		"type",
+		"endpoint",
+		"models"
+	], ...config.providers.map((provider) => [
+		provider.id,
+		provider.type,
+		provider.endpoint,
+		String(provider.models.length)
+	])]);
+}
+function formatProviderShow(provider) {
+	const lines = [
+		`id: ${provider.id}`,
+		`type: ${provider.type}`,
+		`endpoint: ${provider.endpoint}`,
+		`models: ${provider.models.map((model) => model.id).join(", ")}`
+	];
+	const headerKeys = Object.keys(provider.headers ?? {});
+	if (headerKeys.length > 0) lines.push(`headers: ${headerKeys.join(", ")}`);
+	return `${lines.join("\n")}\n`;
+}
+function parseHeaderList(headers) {
+	if (headers.length === 0) return;
+	const parsedHeaders = {};
+	for (const header of headers) {
+		const separatorIndex = header.indexOf("=");
+		if (separatorIndex <= 0) throw new Error(`Invalid provider header "${header}". Expected Key=Value.`);
+		parsedHeaders[header.slice(0, separatorIndex)] = header.slice(separatorIndex + 1);
+	}
+	return parsedHeaders;
+}
+async function probeModels(endpoint, headers = {}) {
+	const response = await fetch(buildModelsUrl(endpoint), { headers });
+	if (!response.ok) throw new Error(`GET ${buildModelsUrl(endpoint)} returned ${response.status}.`);
+	const body = await response.json();
+	if (!Array.isArray(body.data)) throw new TypeError("Expected OpenAI-compatible models response with data array.");
+	return body.data.map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0);
+}
+function formatTable(rows) {
+	if (rows.length <= 1) return "";
+	return table(rows, {
+		border: getBorderCharacters("void"),
+		columnDefault: {
+			paddingLeft: 0,
+			paddingRight: 2
+		},
+		drawHorizontalLine: () => false
+	});
+}
+//#endregion
+//#region src/cli/commands/setup/interactive.ts
+const nonTtyMessage = "interactive setup requires a TTY. Use -N/--no-interactive with --provider-id and --provider-endpoint.\n";
+const backValue = "__alint_back__";
+function formatProbeModelsFailure(endpoint, error) {
+	const hint = endpoint.startsWith("https://localhost:11434") ? " Ollama usually uses http://localhost:11434/v1." : "";
+	return `Could not probe models: ${errorMessageFrom(error)}.${hint}`;
+}
+function isBackInput(value) {
+	return value.trim() === "..";
+}
+async function runInteractiveSetup(io) {
+	if (io.stdin?.isTTY !== true || io.stdout.isTTY !== true) {
+		io.stderr.write(nonTtyMessage);
+		return 2;
+	}
+	const prompts = await import("@clack/prompts");
+	const cancelPrompt = () => {
+		prompts.cancel("Setup cancelled.");
+		return 1;
+	};
+	prompts.intro("alint setup");
+	const draft = {};
+	let step = "scope";
+	while (true) {
+		if (step === "scope") {
+			const scope = await prompts.select({
+				message: "Where should alint write setup config?",
+				options: [{
+					label: "Global",
+					value: "global"
+				}, {
+					label: "Local project",
+					value: "local"
+				}]
+			});
+			if (prompts.isCancel(scope)) return cancelPrompt();
+			draft.scope = scope;
+			step = "source";
+			continue;
+		}
+		if (step === "source") {
+			const source = await prompts.select({
+				message: "Choose provider setup mode.",
+				options: withBackOption([
+					{
+						label: "Custom OpenAI-compatible provider",
+						value: "custom"
+					},
+					{
+						label: "Ollama",
+						value: "ollama"
+					},
+					{
+						label: "Manual model entry",
+						value: "manual"
+					}
+				])
+			});
+			if (prompts.isCancel(source)) return cancelPrompt();
+			if (source === backValue) {
+				step = "scope";
+				continue;
+			}
+			draft.source = source;
+			step = "endpoint";
+			continue;
+		}
+		if (step === "endpoint") {
+			const endpoint = await promptEndpoint(prompts, draft.source ?? "custom");
+			if (prompts.isCancel(endpoint)) return cancelPrompt();
+			if (typeof endpoint !== "string") return cancelPrompt();
+			if (isBackInput(endpoint)) {
+				step = "source";
+				continue;
+			}
+			draft.endpoint = endpoint;
+			step = "providerId";
+			continue;
+		}
+		if (step === "providerId") {
+			const existingConfig = await loadSetupConfig(getConfigPath(io, draft.scope ?? "global"));
+			const providerId = await prompts.text({
+				defaultValue: draft.providerId ?? createProviderId(draft.endpoint ?? "", new Set(existingConfig.providers.map((provider) => provider.id))),
+				message: "Provider id",
+				placeholder: "Type .. to go back",
+				validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider id is required."
+			});
+			if (prompts.isCancel(providerId)) return cancelPrompt();
+			if (typeof providerId !== "string") return cancelPrompt();
+			if (isBackInput(providerId)) {
+				step = "endpoint";
+				continue;
+			}
+			draft.providerId = providerId;
+			step = "headers";
+			continue;
+		}
+		if (step === "headers") {
+			const headerInput = await prompts.text({
+				defaultValue: draft.headerInput ?? "",
+				message: "Headers",
+				placeholder: "Authorization=Bearer token, X-Test=true; type .. to go back",
+				validate: (value) => {
+					if (isBackInput(value ?? "")) return;
+					try {
+						parseHeaderList(splitHeaderInput(value ?? ""));
+						return;
+					} catch {
+						return "Headers must be comma-separated Key=Value entries.";
+					}
+				}
+			});
+			if (prompts.isCancel(headerInput)) return cancelPrompt();
+			if (typeof headerInput !== "string") return cancelPrompt();
+			if (isBackInput(headerInput)) {
+				step = "providerId";
+				continue;
+			}
+			draft.headerInput = headerInput;
+			draft.headers = parseHeaderList(splitHeaderInput(headerInput));
+			draft.discoveredModels = draft.source === "manual" ? [] : await probeModelsWithSpinner(prompts, draft.endpoint ?? "", draft.headers);
+			step = "models";
+			continue;
+		}
+		if (step === "models") {
+			const selectedModels = await promptModels(prompts, draft.discoveredModels ?? []);
+			if (prompts.isCancel(selectedModels)) return cancelPrompt();
+			if (selectedModels === backValue) {
+				step = "headers";
+				continue;
+			}
+			if (!Array.isArray(selectedModels)) return cancelPrompt();
+			draft.selectedModels = selectedModels;
+			step = "defaultAlias";
+			continue;
+		}
+		if (step === "defaultAlias") {
+			const addDefaultAlias = await prompts.select({
+				message: `Add alias "default" to ${draft.selectedModels?.[0]}?`,
+				options: withBackOption([{
+					label: "Yes",
+					value: "yes"
+				}, {
+					label: "No",
+					value: "no"
+				}])
+			});
+			if (prompts.isCancel(addDefaultAlias)) return cancelPrompt();
+			if (addDefaultAlias === backValue) {
+				step = "models";
+				continue;
+			}
+			draft.addDefaultAlias = addDefaultAlias === "yes";
+			step = "confirm";
+			continue;
+		}
+		const nextProvider = createProviderConfig((draft.providerId ?? "").trim(), (draft.endpoint ?? "").trim(), draft.headers, draft.selectedModels ?? [], draft.addDefaultAlias ?? true);
+		const confirmed = await prompts.select({
+			message: [
+				`Write ${draft.scope} setup config?`,
+				`Provider: ${nextProvider.id}`,
+				`Endpoint: ${nextProvider.endpoint}`,
+				`Models: ${(draft.selectedModels ?? []).join(", ")}`
+			].join("\n"),
+			options: withBackOption([{
+				label: "Yes",
+				value: "yes"
+			}, {
+				label: "No",
+				value: "no"
+			}])
+		});
+		if (prompts.isCancel(confirmed)) return cancelPrompt();
+		if (confirmed === backValue) {
+			step = "defaultAlias";
+			continue;
+		}
+		if (confirmed === "no") return cancelPrompt();
+		const configPath = getConfigPath(io, draft.scope ?? "global");
+		await writeSetupConfig(configPath, mergeSetupConfigs(await loadSetupConfig(configPath), {
+			providers: [nextProvider],
+			version: 1
+		}));
+		prompts.outro(`Wrote ${configPath}`);
+		return 0;
+	}
+}
+function withBackOption(options) {
+	return [...options, {
+		label: "Back",
+		value: backValue
+	}];
+}
+function createProviderConfig(providerId, endpoint, headers, modelIds, addDefaultAlias) {
+	return {
+		endpoint,
+		headers,
+		id: providerId,
+		models: modelIds.map((modelId, index) => ({
+			aliases: index === 0 && addDefaultAlias ? ["default"] : void 0,
+			id: modelId,
+			name: modelId
+		})),
+		type: "openai-compatible"
+	};
+}
+function getConfigPath(io, scope) {
+	return scope === "local" ? getProjectSetupConfigPath(io.cwd) : getGlobalSetupConfigPath(io.env ?? process.env);
+}
+async function probeModelsWithSpinner(prompts, endpoint, headers) {
+	const spinner = prompts.spinner();
+	spinner.start("Probing models");
+	try {
+		const models = await probeModels(endpoint, headers ?? {});
+		spinner.stop(models.length > 0 ? `Found ${models.length} models` : "No models discovered");
+		return models;
+	} catch (error) {
+		spinner.stop(formatProbeModelsFailure(endpoint, error));
+		return [];
+	}
+}
+async function promptEndpoint(prompts, source) {
+	return prompts.text({
+		defaultValue: source === "ollama" ? "http://localhost:11434/v1" : void 0,
+		message: "Provider endpoint",
+		placeholder: source === "ollama" ? "http://localhost:11434/v1; type .. to go back" : "https://example.test/v1; type .. to go back",
+		validate: (value) => isBackInput(value ?? "") || (value ?? "").trim().length > 0 ? void 0 : "Provider endpoint is required."
+	});
+}
+async function promptModels(prompts, discoveredModels) {
+	if (discoveredModels.length > 0) {
+		const selectedModels = await prompts.multiselect({
+			message: "Select models",
+			options: withBackOption(discoveredModels.map((model) => ({
+				label: model,
+				value: model
+			}))),
+			required: true
+		});
+		return Array.isArray(selectedModels) && selectedModels.includes(backValue) ? backValue : selectedModels;
+	}
+	const modelInput = await prompts.text({
+		message: "Models",
+		placeholder: "qwen:8b, qwen:32b; type .. to go back",
+		validate: (value) => isBackInput(value ?? "") || splitModelInput(value ?? "").length > 0 ? void 0 : "At least one model is required."
+	});
+	if (prompts.isCancel(modelInput)) return modelInput;
+	return isBackInput(modelInput) ? backValue : splitModelInput(modelInput);
+}
+function splitHeaderInput(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function splitModelInput(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+//#endregion
+//#region src/cli/commands/setup/index.ts
+async function runSetupCommand(options, io) {
+	if (!options.providerEndpoint) {
+		if (options.noInteractive !== true) return runInteractiveSetup({
+			...io,
+			stdin: io.stdin ?? process.stdin
+		});
+		io.stderr.write("setup requires --provider-endpoint in --no-interactive mode.\n");
+		return 2;
+	}
+	if (!options.providerId) {
+		io.stderr.write("setup requires --provider-id in --no-interactive mode.\n");
+		return 2;
+	}
+	const setupConfigPath = options.local ? getProjectSetupConfigPath(io.cwd) : getGlobalSetupConfigPath(io.env ?? process.env);
+	await writeSetupConfig(setupConfigPath, mergeSetupConfigs(await loadSetupConfig(setupConfigPath), createSetupConfig(options.providerId, options.providerEndpoint, options)));
+	return 0;
+}
+function createSetupConfig(providerId, providerEndpoint, options) {
+	const models = toArray$1(options.providerModel).map((model) => ({
+		id: model,
+		name: model
+	}));
+	return {
+		providers: [{
+			endpoint: providerEndpoint,
+			headers: parseHeaderList(toArray$1(options.providerHeader)),
+			id: providerId,
+			models,
+			type: "openai-compatible"
+		}],
+		version: 1
+	};
+}
+function toArray$1(value) {
+	if (value === void 0) return [];
+	return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
+}
+//#endregion
+//#region src/cli/reporters/json.ts
+function formatJson(result) {
+	return `${JSON.stringify(result, null, 2)}\n`;
+}
+//#endregion
+//#region src/cli/reporters/stylish.ts
+const colors$1 = createColors({ force: true });
+function formatStylish(input, options = {}) {
+	const diagnostics = Array.isArray(input) ? input : input.diagnostics;
+	const totalTokens = Array.isArray(input) ? void 0 : input.usage.totalTokens;
+	if (diagnostics.length === 0) return "";
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const fileDiagnostics = diagnosticsByFile.get(diagnostic.filePath);
+		if (fileDiagnostics) {
+			fileDiagnostics.push(diagnostic);
+			continue;
+		}
+		diagnosticsByFile.set(diagnostic.filePath, [diagnostic]);
+	}
+	const lines = [];
+	const style = createStyle(options.color === true);
+	for (const [filePath, fileDiagnostics] of diagnosticsByFile) {
+		lines.push(style.file(filePath));
+		for (const diagnostic of fileDiagnostics) {
+			const line = diagnostic.loc?.start.line ?? 0;
+			const column = diagnostic.loc?.start.column ?? 0;
+			const severity = diagnostic.severity === "warn" ? style.warning("warning") : style.error("error");
+			lines.push(`  ${style.location(`${line}:${column}`)}  ${severity}  ${diagnostic.message}  ${style.ruleId(diagnostic.ruleId)}`);
+		}
+		lines.push("");
+	}
+	lines.push("", formatSummary(diagnostics, totalTokens, style));
+	return `${lines.join("\n")}\n`;
+}
+function countDiagnostics$2(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}
+function createStyle(color) {
+	if (!color) return {
+		error: identity,
+		file: identity,
+		location: identity,
+		ruleId: identity,
+		summaryToken: identity,
+		warning: identity
+	};
+	return {
+		error: colors$1.red,
+		file: colors$1.underline,
+		location: colors$1.dim,
+		ruleId: colors$1.dim,
+		summaryToken: colors$1.cyan,
+		warning: colors$1.yellow
+	};
+}
+function formatSummary(diagnostics, totalTokens, style) {
+	const warnCount = countDiagnostics$2(diagnostics, "warn");
+	const errorCount = countDiagnostics$2(diagnostics, "error");
+	const tokens = totalTokens === void 0 ? void 0 : `${totalTokens.toLocaleString("en-US")} tokens`;
+	const problemSummary = [style.warning(`${warnCount} warn`), style.error(`${errorCount} error`)].join(" / ");
+	if (tokens === void 0) return problemSummary;
+	return `${problemSummary} | ${style.summaryToken(tokens)}`;
+}
+function identity(value) {
+	return value;
+}
+//#endregion
+//#region src/cli/reporters/index.ts
+function formatDiagnostics(format, result, options = {}) {
+	if (format === "json") return formatJson(result);
+	if (format === "stylish") return formatStylish(result, { color: options.color });
+	throw new Error(`Unknown reporter "${format}".`);
+}
+//#endregion
+//#region src/cli/reporters/progress/plain.ts
+function createPlainProgressReporter(options) {
+	const writeLine = (line) => options.write(`${line}\n`);
+	return {
+		onRuleStart: (payload) => {
+			const target = payload.path.target.name ? `${payload.path.target.kind} ${payload.path.target.name}` : payload.path.target.kind;
+			writeLine(`scan ${payload.path.file.path} > ${target} > ${payload.path.rule.id}`);
+		},
+		onRunEnd: (payload) => {
+			const warnCount = countDiagnostics$1(payload.diagnostics, "warn");
+			const errorCount = countDiagnostics$1(payload.diagnostics, "error");
+			const state = payload.errored > 0 ? "failed" : "finished";
+			const cached = payload.cached > 0 ? `, ${payload.cached} cached` : "";
+			const errored = payload.errored > 0 ? `, ${payload.errored} errored` : "";
+			writeLine(`alint ${state}: ${warnCount} warn, ${errorCount} error, ${payload.usage.totalTokens} tokens${cached}${errored}`);
+		},
+		onRunStart: (payload) => {
+			writeLine(`alint started: ${payload.filesTotal} files, ${payload.rulesTotal} rules, ${payload.planned} planned executions`);
+		}
+	};
+}
+function countDiagnostics$1(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}
+//#endregion
+//#region src/cli/reporters/progress/summary.ts
+const colors = createColors({ force: true });
+function createSummaryProgressReporter(options) {
+	const now = () => options.clock?.() ?? Date.now();
+	const state = {
+		cached: 0,
+		completed: 0,
+		diagnostics: [],
+		errored: 0,
+		files: /* @__PURE__ */ new Map(),
+		planned: 0,
+		spinnerIndex: 0,
+		totalTokens: 0
+	};
+	return {
+		getRows: () => createRows(state, options, now()),
+		onDiagnostic: (payload) => {
+			state.diagnostics = payload.diagnostics;
+		},
+		onFileEnd: (payload) => {
+			const file = getFileState(state, payload.file);
+			file.endedAt = payload.endedAt ?? now();
+			file.rule = void 0;
+			file.target = void 0;
+		},
+		onFileStart: (payload) => {
+			const file = getFileState(state, payload.file);
+			file.startedAt = payload.startedAt ?? now();
+			file.endedAt = void 0;
+		},
+		onRuleEnd: (payload) => {
+			const file = getFileState(state, payload.path.file);
+			if (payload.cache === "hit") {
+				state.cached += 1;
+				file.cached += 1;
+			}
+			if (payload.state === "completed") {
+				state.completed += 1;
+				file.completed += 1;
+			}
+			if (payload.state === "errored") {
+				state.errored += 1;
+				file.errored += 1;
+			}
+			if (file.rule?.id === payload.path.rule.id) file.rule = void 0;
+		},
+		onRuleStart: (payload) => {
+			const file = getFileState(state, payload.path.file);
+			file.startedAt ??= payload.startedAt ?? now();
+			file.rule = {
+				id: payload.path.rule.id,
+				startedAt: payload.startedAt ?? now(),
+				target: formatTarget(payload)
+			};
+			file.target = file.rule.target;
+		},
+		onRunEnd: (payload) => {
+			state.cached = payload.cached;
+			state.completed = payload.completed;
+			state.diagnostics = payload.diagnostics;
+			state.endedAt = payload.endedAt ?? now();
+			state.errored = payload.errored;
+			state.planned = payload.planned;
+			state.runStartedAt = payload.startedAt ?? state.runStartedAt;
+			state.totalTokens = payload.usage.totalTokens;
+		},
+		onRunStart: (payload) => {
+			state.cached = 0;
+			state.completed = 0;
+			state.diagnostics = [];
+			state.endedAt = void 0;
+			state.errored = 0;
+			state.files = /* @__PURE__ */ new Map();
+			state.planned = payload.planned;
+			state.runStartedAt = payload.startedAt ?? now();
+			state.spinnerIndex = 0;
+			state.totalTokens = 0;
+			for (const file of payload.files ?? []) state.files.set(file.path, createFileState(file));
+		},
+		onTargetEnd: (payload) => {
+			const file = getFileState(state, payload.path.file);
+			const target = formatTarget(payload);
+			if (file.target === target) file.target = void 0;
+		},
+		onTargetStart: (payload) => {
+			const file = getFileState(state, payload.path.file);
+			file.startedAt ??= payload.startedAt ?? now();
+			file.target = formatTarget(payload);
+		},
+		onUsage: (payload) => {
+			state.totalTokens = payload.total.totalTokens;
+		},
+		tick: () => {
+			state.spinnerIndex = (state.spinnerIndex + 1) % Math.max(options.spinnerFrames.length, 1);
+		}
+	};
+}
+function countDiagnostics(diagnostics, severity) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+}
+function countQueuedFiles(state) {
+	return [...state.files.values()].filter((file) => file.startedAt === void 0 && file.endedAt === void 0 && (file.file.planned ?? 0) > 0).length;
+}
+function createFileState(file) {
+	return {
+		cached: 0,
+		completed: 0,
+		errored: 0,
+		file
+	};
+}
+function createRows(state, options, now) {
+	const rows = getActiveFiles(state).flatMap((file) => formatFileRows(file, state, options, now));
+	const queued = countQueuedFiles(state);
+	const warnCount = countDiagnostics(state.diagnostics, "warn");
+	const errorCount = countDiagnostics(state.diagnostics, "error");
+	const footer = formatFooter(state, warnCount, errorCount, queued, options, now);
+	if (queued > 0) rows.push(formatQueuedRow(queued, options));
+	if (rows.length === 0) rows.push(formatIdleRow(state, options));
+	rows.push("", footer);
+	return options.color ? rows.map((row) => styleRow(row, state, warnCount, errorCount, options)) : rows;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function estimateTotal(elapsedMs, completed, planned) {
+	if (completed <= 0 || planned <= 0) return;
+	return elapsedMs * planned / completed;
+}
+function fitRow(row, columns) {
+	if (columns <= 0) return "";
+	if (row.length <= columns) return row;
+	if (columns === 1) return "…";
+	return `${row.slice(0, columns - 1)}…`;
+}
+function formatDuration(ms) {
+	if (ms === void 0 || !Number.isFinite(ms)) return "?";
+	return `${(Math.max(ms, 0) / 1e3).toFixed(1)}s`;
+}
+function formatEstimatedDuration(ms) {
+	return `~${formatDuration(ms)}`;
+}
+function formatFilePath(filePath, cwd) {
+	if (!cwd) return filePath;
+	return relative(cwd, filePath) || filePath;
+}
+function formatFileRows(file, state, options, now) {
+	const firstRow = formatFileSummaryRow(file, state, options);
+	if (!file.rule) return [firstRow];
+	const elapsed = now - file.rule.startedAt;
+	const done = file.completed + file.cached + file.errored;
+	const estimated = estimateTotal(file.startedAt === void 0 ? elapsed : now - file.startedAt, done, file.file.planned ?? 0);
+	return [firstRow, fitRow(`    ${file.rule.target} > ${file.rule.id} (${formatDuration(elapsed)}, ${formatEstimatedDuration(estimated)})`, options.columns)];
+}
+function formatFileSummaryRow(file, state, options) {
+	const prefix = `${options.spinnerFrames[state.spinnerIndex] ?? ""} ${formatFilePath(file.file.path, options.cwd)}`;
+	const counter = `${file.completed}/${file.cached}/${file.errored}/${file.file.planned ?? 0}`;
+	return fitRow(`${prefix}${" ".repeat(Math.max(1, options.columns - prefix.length - counter.length))}${counter}`, options.columns);
+}
+function formatFooter(state, warnCount, errorCount, queued, options, now) {
+	const endedAt = state.endedAt ?? now;
+	const elapsed = state.runStartedAt === void 0 ? void 0 : endedAt - state.runStartedAt;
+	const completed = state.completed + state.cached + state.errored;
+	const estimated = elapsed === void 0 ? void 0 : estimateTotal(elapsed, completed, state.planned);
+	const estimatedTokens = completed > 0 && state.planned > 0 ? Math.ceil(state.totalTokens * state.planned / completed).toLocaleString("en-US") : "?";
+	return fitRow([
+		`${formatDuration(elapsed)} -> ${formatEstimatedDuration(estimated)}`,
+		`${state.totalTokens.toLocaleString("en-US")} tokens -> ~${estimatedTokens} tokens`,
+		`${queued} queued / ${state.cached} cached / ${warnCount} warn / ${errorCount} error`
+	].join(" | "), options.columns);
+}
+function formatIdleRow(state, options) {
+	const prefix = `${options.spinnerFrames[state.spinnerIndex] ?? ""} alint`;
+	const counter = `${state.completed}/${state.cached}/${state.errored}/${state.planned}`;
+	return fitRow(`${prefix}${" ".repeat(Math.max(1, options.columns - prefix.length - counter.length))}${counter}`, options.columns);
+}
+function formatQueuedRow(queued, options) {
+	return fitRow(`  ${queued} ${queued === 1 ? "file" : "files"} queued`, options.columns);
+}
+function formatTarget(payload) {
+	return payload.path.target.name ? `${payload.path.target.kind} ${payload.path.target.name}` : payload.path.target.kind;
+}
+function getActiveFiles(state) {
+	return [...state.files.values()].filter((file) => file.startedAt !== void 0 && file.endedAt === void 0).sort((left, right) => left.file.index - right.file.index);
+}
+function getFileState(state, file) {
+	const existingFile = state.files.get(file.path);
+	if (existingFile) {
+		existingFile.file = {
+			...existingFile.file,
+			...file,
+			planned: file.planned ?? existingFile.file.planned
+		};
+		return existingFile;
+	}
+	const nextFile = createFileState({
+		...file,
+		planned: file.planned ?? (state.files.size === 0 ? state.planned : void 0)
+	});
+	state.files.set(file.path, nextFile);
+	return nextFile;
+}
+function replaceFirst(row, search, replacement) {
+	if (search.length === 0) return row;
+	return row.replace(new RegExp(escapeRegExp(search)), replacement);
+}
+function styleRow(row, state, warnCount, errorCount, options) {
+	let styledRow = row;
+	const spinner = options.spinnerFrames[state.spinnerIndex] ?? "";
+	if (spinner) styledRow = replaceFirst(styledRow, spinner, colors.cyan(spinner));
+	styledRow = styledRow.replace(/\|/g, colors.gray("|")).replace(`${warnCount} warn`, colors.yellow(`${warnCount} warn`)).replace(`${errorCount} error`, (errorCount > 0 ? colors.red : colors.gray)(`${errorCount} error`)).replace(/(\d+\/\d+\/\d+\/\d+)/, (match) => state.errored > 0 ? colors.red(match) : colors.gray(match)).replace(/(\d[\d,]* tokens)/g, (match) => colors.cyan(match));
+	return styledRow;
+}
+//#endregion
+//#region src/cli/reporters/progress/tty.ts
+const clearCurrentLine = "\r\x1B[K";
+const clearPreviousLine = "\r\x1B[1A\x1B[K";
+function createTtyProgressRenderer(options) {
+	let interval;
+	let previousRows = 0;
+	const clearPreviousFrame = () => {
+		if (previousRows === 0) return;
+		let sequence = clearCurrentLine;
+		for (let row = 1; row < previousRows; row += 1) sequence += clearPreviousLine;
+		options.write(sequence);
+		previousRows = 0;
+	};
+	const render = () => {
+		clearPreviousFrame();
+		const rows = options.getRows();
+		if (rows.length === 0) return;
+		options.write(rows.join("\n"));
+		previousRows = rows.length;
+	};
+	const write = (chunk) => {
+		const wasRendering = interval !== void 0;
+		clearPreviousFrame();
+		options.write(chunk);
+		if (wasRendering) render();
+	};
+	return {
+		finish: () => {
+			if (interval) {
+				options.clearInterval(interval);
+				interval = void 0;
+			}
+			clearPreviousFrame();
+		},
+		render,
+		start: () => {
+			if (!interval) {
+				interval = options.createInterval(render, options.intervalMs);
+				if (isUnrefableInterval(interval)) interval.unref();
+			}
+			render();
+		},
+		write
+	};
+}
+function isUnrefableInterval(interval) {
+	if (typeof interval !== "object" || interval === null || !("unref" in interval)) return false;
+	return typeof interval.unref === "function";
+}
+//#endregion
+//#region src/cli/reporters/progress/index.ts
+function createCliProgressReporter(options) {
+	if (!options.isTty) return {
+		dispose: () => {},
+		reporter: createPlainProgressReporter({ write: options.write }),
+		write: options.write
+	};
+	const summary = createSummaryProgressReporter({
+		color: options.color,
+		columns: options.columns,
+		cwd: options.cwd,
+		spinnerFrames: cliSpinners.dots.frames
+	});
+	const renderer = createTtyProgressRenderer({
+		clearInterval: (handle) => globalThis.clearInterval(handle),
+		createInterval: (callback, intervalMs) => globalThis.setInterval(() => {
+			summary.tick();
+			callback();
+		}, intervalMs),
+		getRows: summary.getRows,
+		intervalMs: 120,
+		write: options.write
+	});
+	const reporter = createRenderingProgressReporter(summary, renderer);
+	return {
+		dispose: renderer.finish,
+		reporter,
+		write: renderer.write
+	};
+}
+function createRenderingProgressReporter(summary, renderer) {
+	return {
+		onDiagnostic: (payload) => {
+			summary.onDiagnostic?.(payload);
+			renderer.render();
+		},
+		onFileEnd: (payload) => {
+			summary.onFileEnd?.(payload);
+			renderer.render();
+		},
+		onFileStart: (payload) => {
+			summary.onFileStart?.(payload);
+			renderer.render();
+		},
+		onRuleEnd: (payload) => {
+			summary.onRuleEnd?.(payload);
+			renderer.render();
+		},
+		onRuleStart: (payload) => {
+			summary.onRuleStart?.(payload);
+			renderer.render();
+		},
+		onRunEnd: (payload) => {
+			summary.onRunEnd?.(payload);
+			renderer.render();
+		},
+		onRunStart: (payload) => {
+			summary.onRunStart?.(payload);
+			renderer.start();
+		},
+		onTargetEnd: (payload) => {
+			summary.onTargetEnd?.(payload);
+			renderer.render();
+		},
+		onTargetStart: (payload) => {
+			summary.onTargetStart?.(payload);
+			renderer.render();
+		},
+		onUsage: (payload) => {
+			summary.onUsage?.(payload);
+			renderer.render();
+		}
+	};
+}
+//#endregion
+//#region src/cli/cli.ts
+async function executeCli(argv, io) {
+	const cli = cac("alint");
+	const setupNoInteractive = argv.includes("-N") || argv.includes("--no-interactive");
+	let pendingResult;
+	cli.option("--no-cache", "Disable cache for this run").option("--cache-location <path>", "Path to the alint cache file or directory").option("--config <path>", "Path to alint config file").option("--file-concurrency <count>", "Number of files to lint concurrently").option("--format <format>", "Reporter format", { default: "stylish" }).option("--model <model>", "Force a model override").option("--progress", "Show run progress").option("--rule-concurrency <count>", "Number of rules to run concurrently within a file").option("--timeout-ms <ms>", "Rule execution timeout in milliseconds").help();
+	cli.command("setup", "Write alint provider configuration").option("--local", "Write project-local config").option("-N, --no-interactive", "Disable interactive setup").option("--provider-endpoint <endpoint>", "Provider endpoint").option("--provider-id <id>", "Provider id").option("--provider-model <model>", "Provider model").option("--provider-header <Key=Value>", "Provider header").action((options) => {
+		pendingResult = runSetupCommand({
+			...options,
+			noInteractive: setupNoInteractive
+		}, io);
+		return pendingResult;
+	});
+	cli.command("config [...args]", "Manage alint configuration").option("--endpoint <url>", "Provider endpoint").option("--provider-header <Key=Value>", "Provider header").action((args, options) => {
+		pendingResult = runConfigCommand(args, options, io);
+		return pendingResult;
+	});
+	cli.command("[...files]", "Run alint").action((files = [], options) => {
+		pendingResult = runDefaultCommand(files, options, io);
+		return pendingResult;
+	});
+	const restoreConsole = interceptConsoleOutput(shouldCaptureHelp(argv) ? io.stdout : io.stderr);
+	try {
+		cli.parse(argv);
+		return await (pendingResult ?? Promise.resolve(0));
+	} finally {
+		restoreConsole();
+	}
+}
+async function assertConfigExists(cwd, configPath) {
+	const resolvedConfigPath = resolve(cwd, configPath);
+	try {
+		if (!(await stat(resolvedConfigPath)).isFile()) throw new Error(`Config file "${configPath}" is not a file.`);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") throw new Error(`Config file "${configPath}" does not exist.`);
+		throw error;
+	}
+}
+function formatRunError(error, color) {
+	return `${color ? c.red("error") : "error"} ${formatRunErrorContext(error)}\n  Rule running failed due to ${error.failure?.message ?? error.message}\n`;
+}
+function formatRunErrorContext(error) {
+	const failure = error.failure;
+	if (!failure) return "alint run failed";
+	const target = failure.target ? failure.target.name ? `${failure.target.kind} ${failure.target.name}` : failure.target.kind : void 0;
+	return [
+		failure.filePath,
+		target,
+		failure.ruleId
+	].filter(Boolean).join(" > ");
+}
+function interceptConsoleOutput(stdout) {
+	const cliConsole = globalThis.console;
+	const originalConsoleDebug = cliConsole.debug;
+	const originalConsoleDir = cliConsole.dir;
+	const originalConsoleInfo = console.info;
+	const originalConsoleLog = cliConsole.log;
+	const writeConsoleLine = (...args) => {
+		stdout.write(`${args.map(String).join(" ")}\n`);
+	};
+	const writeConsoleDir = (item, options) => {
+		stdout.write(`${inspect(item, options)}\n`);
+	};
+	cliConsole.debug = writeConsoleLine;
+	cliConsole.dir = writeConsoleDir;
+	console.info = writeConsoleLine;
+	cliConsole.log = writeConsoleLine;
+	return () => {
+		cliConsole.debug = originalConsoleDebug;
+		cliConsole.dir = originalConsoleDir;
+		console.info = originalConsoleInfo;
+		cliConsole.log = originalConsoleLog;
+	};
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+async function loadMergedSetupConfig(io) {
+	const globalSetupConfigPath = getGlobalSetupConfigPath(io.env ?? process.env);
+	const projectSetupConfigPath = getProjectSetupConfigPath(io.cwd);
+	const [globalSetupConfig, projectSetupConfig] = await Promise.all([loadSetupConfig(globalSetupConfigPath), loadSetupConfig(projectSetupConfigPath)]);
+	return mergeSetupConfigs(globalSetupConfig, projectSetupConfig);
+}
+function mergeRunnerCacheConfig(setupCache, configCache) {
+	if (configCache === void 0) return setupCache;
+	if (typeof configCache === "boolean") return configCache;
+	if (typeof setupCache === "object") return {
+		...setupCache,
+		...configCache
+	};
+	return configCache;
+}
+function parsePositiveIntegerOption(value, label) {
+	if (value === void 0) return;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${label} must be a positive integer.`);
+	return parsed;
+}
+async function resolveLintFiles(files, config, cwd) {
+	if (config.ignore?.gitignore !== true || files.length === 0) return files;
+	const gitignore = new Gitignore();
+	const lintFiles = [];
+	for (const file of files) {
+		if (await gitignore.ignores(resolve(cwd, file))) continue;
+		lintFiles.push(file);
+	}
+	return lintFiles;
+}
+function resolveRunnerCacheConfig(setupCache, configCache, options) {
+	if (options.cache === false) return false;
+	const configuredCache = mergeRunnerCacheConfig(setupCache, configCache);
+	if (options.cacheLocation !== void 0) return typeof configuredCache === "object" ? {
+		...configuredCache,
+		location: options.cacheLocation
+	} : { location: options.cacheLocation };
+	return configuredCache;
+}
+function resolveRunnerConfig(setupConfig, config, options) {
+	const cache = resolveRunnerCacheConfig(setupConfig.runner?.cache, config.runner?.cache, options);
+	const fileConcurrency = parsePositiveIntegerOption(options.fileConcurrency, "--file-concurrency");
+	const ruleConcurrency = parsePositiveIntegerOption(options.ruleConcurrency, "--rule-concurrency");
+	const timeoutMs = parsePositiveIntegerOption(options.timeoutMs, "--timeout-ms");
+	const runner = {
+		...setupConfig.runner ?? {},
+		...config.runner ?? {},
+		cache,
+		fileConcurrency: fileConcurrency ?? config.runner?.fileConcurrency ?? setupConfig.runner?.fileConcurrency,
+		ruleConcurrency: ruleConcurrency ?? config.runner?.ruleConcurrency ?? setupConfig.runner?.ruleConcurrency,
+		timeoutMs: timeoutMs ?? config.runner?.timeoutMs ?? setupConfig.runner?.timeoutMs
+	};
+	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
+}
+async function runConfigCommand(args, options, io) {
+	if (args[0] === "models" && args[1] === "probe" && args.length === 2) return runModelsProbeCommand(options, io);
+	if (args[0] === "models" && args[1] === "ls" && args.length === 2) return runModelsListCommand(io);
+	if (args[0] === "models" && args[1] === "show" && args.length === 3) return runModelsShowCommand(args[2], io);
+	if (args[0] === "providers" && args[1] === "ls" && args.length === 2) return runProvidersListCommand(io);
+	if (args[0] === "providers" && args[1] === "show" && args.length === 3) return runProvidersShowCommand(args[2], io);
+	if (args[0] === "providers" && args[1] === "probe" && args.length === 2) return runProvidersProbeCommand(options, io);
+	io.stderr.write(`unknown config command: ${args.join(" ")}\n`);
+	return 2;
+}
+async function runDefaultCommand(files, options, io) {
+	if (options.config) await assertConfigExists(io.cwd, options.config);
+	const [setupConfig, config] = await Promise.all([loadMergedSetupConfig(io), loadAlintConfig(io.cwd, options.config)]);
+	const lintFiles = await resolveLintFiles(files, config, io.cwd);
+	const runner = resolveRunnerConfig(setupConfig, config, options);
+	const progress = shouldEnableProgress(options, io) ? createCliProgressReporter({
+		color: io.stderr.isTTY === true,
+		columns: io.stderr.columns ?? 80,
+		cwd: io.cwd,
+		isTty: io.stderr.isTTY === true,
+		write: (chunk) => io.stderr.write(chunk)
+	}) : void 0;
+	const restoreProgressConsole = progress ? interceptConsoleOutput({ write: progress.write }) : void 0;
+	let result;
+	try {
+		result = await runAlint({
+			config,
+			cwd: io.cwd,
+			files: lintFiles,
+			modelOverride: options.model,
+			progress: progress?.reporter,
+			runner,
+			setupConfig
+		});
+	} catch (error) {
+		restoreProgressConsole?.();
+		progress?.dispose();
+		if (error instanceof AlintRunError) {
+			io.stderr.write(formatRunError(error, io.stderr.isTTY === true));
+			return 2;
+		}
+		throw error;
+	}
+	restoreProgressConsole?.();
+	progress?.dispose();
+	io.stdout.write(formatDiagnostics(options.format, result, { color: io.stdout.isTTY === true }));
+	return result.diagnostics.length > 0 ? 1 : 0;
+}
+async function runModelsListCommand(io) {
+	io.stdout.write(formatModelList(await loadMergedSetupConfig(io)));
+	return 0;
+}
+async function runModelsProbeCommand(options, io) {
+	if (!options.endpoint) {
+		io.stderr.write("config models probe requires --endpoint.\n");
+		return 2;
+	}
+	try {
+		const models = await probeModels(options.endpoint, parseHeaderList(toArray(options.providerHeader)) ?? {});
+		io.stdout.write(`${models.join("\n")}${models.length > 0 ? "\n" : ""}`);
+		return 0;
+	} catch (error) {
+		io.stderr.write(`failed to probe models: ${errorMessageFrom(error) ?? String(error)}\n`);
+		return 2;
+	}
+}
+async function runModelsShowCommand(model, io) {
+	const candidate = findModel(await loadMergedSetupConfig(io), model);
+	if (candidate === void 0) {
+		io.stderr.write(`unknown model "${model}".\n`);
+		return 2;
+	}
+	io.stdout.write(formatModelShow(candidate));
+	return 0;
+}
+async function runProvidersListCommand(io) {
+	io.stdout.write(formatProviderList(await loadMergedSetupConfig(io)));
+	return 0;
+}
+async function runProvidersProbeCommand(options, io) {
+	if (!options.endpoint) {
+		io.stderr.write("config providers probe requires --endpoint.\n");
+		return 2;
+	}
+	try {
+		const models = await probeModels(options.endpoint, parseHeaderList(toArray(options.providerHeader)) ?? {});
+		io.stdout.write(`endpoint: ${options.endpoint}\nmodels: ${models.length}\n`);
+		return 0;
+	} catch (error) {
+		io.stderr.write(`failed to probe provider: ${errorMessageFrom(error) ?? String(error)}\n`);
+		return 2;
+	}
+}
+async function runProvidersShowCommand(providerId, io) {
+	const provider = (await loadMergedSetupConfig(io)).providers.find((item) => item.id === providerId);
+	if (provider === void 0) {
+		io.stderr.write(`unknown provider "${providerId}".\n`);
+		return 2;
+	}
+	io.stdout.write(formatProviderShow(provider));
+	return 0;
+}
+function shouldCaptureHelp(argv) {
+	return argv.includes("--help") || argv.includes("-h");
+}
+function shouldEnableProgress(options, io) {
+	if (options.progress !== void 0) return options.progress;
+	return options.format === "stylish" && io.stderr.isTTY === true;
+}
+function toArray(value) {
+	if (value === void 0) return [];
+	return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
+}
+//#endregion
+export { formatJson as i, formatDiagnostics as n, formatStylish as r, executeCli as t };