@alint-js/cli 0.0.1

package/dist/cli-BnA9jEVr.mjs

@@ -0,0 +1,1755 @@
+import process from "node:process";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "pathe";
+import { isMacOS } from "std-env";
+import { xdgConfig } from "xdg-basedir";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { isPlainObject } from "es-toolkit/compat";
+import { parse, stringify } from "smol-toml";
+import { inspect } from "node:util";
+import c, { createColors } from "tinyrainbow";
+import { cac } from "cac";
+import { loadConfig } from "c12";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { parseSync } from "oxc-parser";
+import { extname, relative } from "node:path";
+import cliSpinners from "cli-spinners";
+//#region src/config/paths.ts
+function getGlobalSetupConfigPath(env = process.env, options = {}) {
+	return join(env.XDG_CONFIG_HOME ?? resolveDefaultConfigHome(options), "alint", "config.toml");
+}
+function getProjectSetupConfigPath(cwd) {
+	return join(cwd, ".alint", "config.toml");
+}
+function resolveDefaultConfigHome(options) {
+	if (options.isMacOS ?? isMacOS) return join(homedir(), ".config");
+	return options.xdgConfig ?? xdgConfig ?? join(homedir(), ".config");
+}
+//#endregion
+//#region src/config/setup-toml.ts
+const modelSizes = /* @__PURE__ */ new Set([
+	"large",
+	"medium",
+	"small"
+]);
+function parseSetupConfigToml(toml) {
+	const rawConfig = parse(toml);
+	if (rawConfig.version !== 1) throw new Error("Invalid setup config: version must be 1.");
+	if (!Array.isArray(rawConfig.providers)) throw new TypeError("Invalid setup config: providers must be an array.");
+	const parsedConfig = {
+		providers: rawConfig.providers.map((provider) => parseProvider(provider)),
+		version: 1
+	};
+	if (rawConfig.runner !== void 0) parsedConfig.runner = parseRunner(rawConfig.runner);
+	return parsedConfig;
+}
+function stringifySetupConfigToml(config) {
+	const stringifiableConfig = {
+		providers: config.providers.map(toTomlProvider),
+		version: config.version
+	};
+	if (config.runner !== void 0) stringifiableConfig.runner = toTomlRunner(config.runner);
+	return stringify(stringifiableConfig);
+}
+function isModelSize(value) {
+	return typeof value === "string" && modelSizes.has(value);
+}
+function parseModel(providerId, model) {
+	const id = readNonEmptyString(model.id, `provider "${providerId}" model id`);
+	const parsedModel = { id };
+	if (model.name !== void 0) parsedModel.name = readString(model.name, `model "${id}" name`);
+	if (model.aliases !== void 0) parsedModel.aliases = readStringArray(model.aliases, `model "${id}" aliases`);
+	if (model.capabilities !== void 0) parsedModel.capabilities = readStringArray(model.capabilities, `model "${id}" capabilities`);
+	if (model.size !== void 0) {
+		if (!isModelSize(model.size)) throw new Error(`Invalid model "${id}": size must be "small", "medium", or "large".`);
+		parsedModel.size = model.size;
+	}
+	if (model.context_window !== void 0) parsedModel.contextWindow = readFiniteNumber(model.context_window, `model "${id}" context_window`);
+	if (model.default_params !== void 0) parsedModel.defaultParams = readRecord(model.default_params, `model "${id}" default_params`);
+	return parsedModel;
+}
+function parsePositiveInteger(value, label) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new TypeError(`Invalid ${label}: must be a positive integer.`);
+	return value;
+}
+function parseProvider(provider) {
+	const id = readNonEmptyString(provider.id, "provider id");
+	if (provider.type !== "openai-compatible") throw new Error(`Invalid provider "${id}": type must be "openai-compatible".`);
+	const endpoint = readNonEmptyString(provider.endpoint, `provider "${id}" endpoint`);
+	if (!Array.isArray(provider.models)) throw new TypeError(`Invalid provider "${id}": models must be an array.`);
+	const parsedProvider = {
+		endpoint,
+		id,
+		models: provider.models.map((model) => parseModel(id, model)),
+		type: provider.type
+	};
+	if (provider.headers !== void 0) parsedProvider.headers = readStringMap(provider.headers, `provider "${id}" headers`);
+	return parsedProvider;
+}
+function parseRunner(runner) {
+	const parsedRunner = {};
+	if (runner.file_concurrency !== void 0) parsedRunner.fileConcurrency = parsePositiveInteger(runner.file_concurrency, "runner file_concurrency");
+	if (runner.rule_concurrency !== void 0) parsedRunner.ruleConcurrency = parsePositiveInteger(runner.rule_concurrency, "runner rule_concurrency");
+	if (runner.timeout_ms !== void 0) parsedRunner.timeoutMs = parsePositiveInteger(runner.timeout_ms, "runner timeout_ms");
+	return parsedRunner;
+}
+function readFiniteNumber(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`Invalid ${label}: must be a finite number.`);
+	return value;
+}
+function readNonEmptyString(value, label) {
+	const stringValue = readString(value, label);
+	if (stringValue.length === 0) throw new Error(`Invalid ${label}: must be a non-empty string.`);
+	return stringValue;
+}
+function readRecord(value, label) {
+	if (!isPlainObject(value)) throw new Error(`Invalid ${label}: must be a table.`);
+	return value;
+}
+function readString(value, label) {
+	if (typeof value !== "string") throw new TypeError(`Invalid ${label}: must be a string.`);
+	return value;
+}
+function readStringArray(value, label) {
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`Invalid ${label}: must be an array of strings.`);
+	return value;
+}
+function readStringMap(value, label) {
+	const record = readRecord(value, label);
+	if (!Object.values(record).every((item) => typeof item === "string")) throw new Error(`Invalid ${label}: must be a string map.`);
+	return record;
+}
+function toTomlModel(model) {
+	const tomlModel = { id: model.id };
+	if (model.name !== void 0) tomlModel.name = model.name;
+	if (model.aliases !== void 0) tomlModel.aliases = model.aliases;
+	if (model.capabilities !== void 0) tomlModel.capabilities = model.capabilities;
+	if (model.size !== void 0) tomlModel.size = model.size;
+	if (model.contextWindow !== void 0) tomlModel.context_window = model.contextWindow;
+	if (model.defaultParams !== void 0) tomlModel.default_params = model.defaultParams;
+	return tomlModel;
+}
+function toTomlProvider(provider) {
+	const tomlProvider = {
+		endpoint: provider.endpoint,
+		id: provider.id,
+		models: provider.models.map(toTomlModel),
+		type: provider.type
+	};
+	if (provider.headers !== void 0) tomlProvider.headers = provider.headers;
+	return tomlProvider;
+}
+function toTomlRunner(runner) {
+	return {
+		file_concurrency: runner.fileConcurrency,
+		rule_concurrency: runner.ruleConcurrency,
+		timeout_ms: runner.timeoutMs
+	};
+}
+//#endregion
+//#region src/config/setup-load.ts
+const emptySetupConfig = {
+	providers: [],
+	version: 1
+};
+async function loadSetupConfig(filePath) {
+	try {
+		return parseSetupConfigToml(await readFile(filePath, "utf8"));
+	} catch (error) {
+		if (isNodeError$1(error) && error.code === "ENOENT") return createEmptySetupConfig();
+		throw error;
+	}
+}
+function mergeSetupConfigs(...configs) {
+	let providers = [];
+	let runner;
+	const providersById = /* @__PURE__ */ new Map();
+	for (const config of configs) {
+		const configProviders = [];
+		if (config.runner !== void 0) runner = {
+			...runner ?? {},
+			...config.runner
+		};
+		for (const provider of config.providers) {
+			const existingProvider = providersById.get(provider.id);
+			if (existingProvider === void 0) {
+				const mergedProvider = cloneProvider(provider);
+				providers.push(mergedProvider);
+				providersById.set(provider.id, mergedProvider);
+				configProviders.push(mergedProvider);
+				continue;
+			}
+			existingProvider.endpoint = provider.endpoint;
+			existingProvider.type = provider.type;
+			configProviders.push(existingProvider);
+			if (provider.headers !== void 0) existingProvider.headers = {
+				...existingProvider.headers,
+				...provider.headers
+			};
+			const nextModels = [];
+			for (const incomingModel of provider.models) {
+				const existingModelIndex = existingProvider.models.findIndex((model) => model.id === incomingModel.id);
+				if (existingModelIndex === -1) {
+					nextModels.push(cloneModel(incomingModel));
+					continue;
+				}
+				const existingModel = existingProvider.models[existingModelIndex];
+				existingProvider.models.splice(existingModelIndex, 1);
+				nextModels.push(mergeModel(existingModel, incomingModel));
+			}
+			existingProvider.models = [...nextModels, ...existingProvider.models];
+		}
+		providers = prioritizeProviders(providers, configProviders);
+	}
+	const mergedConfig = {
+		providers,
+		version: 1
+	};
+	if (runner !== void 0) mergedConfig.runner = runner;
+	return mergedConfig;
+}
+function cloneModel(model) {
+	const clonedModel = { ...model };
+	if (model.aliases !== void 0) clonedModel.aliases = [...model.aliases];
+	if (model.capabilities !== void 0) clonedModel.capabilities = [...model.capabilities];
+	if (model.defaultParams !== void 0) clonedModel.defaultParams = { ...model.defaultParams };
+	return clonedModel;
+}
+function cloneProvider(provider) {
+	const clonedProvider = {
+		...provider,
+		models: provider.models.map(cloneModel)
+	};
+	if (provider.headers !== void 0) clonedProvider.headers = { ...provider.headers };
+	return clonedProvider;
+}
+function createEmptySetupConfig() {
+	return {
+		providers: [],
+		version: 1
+	};
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+function mergeModel(existingModel, incomingModel) {
+	const existing = cloneModel(existingModel);
+	const incoming = cloneModel(incomingModel);
+	return {
+		...existing,
+		...incoming,
+		aliases: incoming.aliases ?? existing.aliases,
+		capabilities: incoming.capabilities ?? existing.capabilities,
+		defaultParams: incoming.defaultParams ?? existing.defaultParams
+	};
+}
+function prioritizeProviders(providers, prioritizedProviders) {
+	const prioritizedProviderIds = new Set(prioritizedProviders.map((provider) => provider.id));
+	return [...prioritizedProviders, ...providers.filter((provider) => !prioritizedProviderIds.has(provider.id))];
+}
+//#endregion
+//#region src/config/setup-write.ts
+async function writeSetupConfig(filePath, config) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, stringifySetupConfigToml(config), "utf8");
+}
+//#endregion
+//#region src/config/load-config.ts
+async function loadAlintConfig(cwd, configFile) {
+	return (await loadConfig({
+		configFile,
+		cwd,
+		defaults: {
+			plugins: [],
+			rules: {}
+		},
+		dotenv: true,
+		name: "alint"
+	})).config;
+}
+//#endregion
+//#region src/dsl/registry.ts
+function buildRuleRegistry(config) {
+	const rules = /* @__PURE__ */ new Map();
+	const enabledRules = [];
+	for (const plugin of config.plugins ?? []) for (const [localId, rule] of Object.entries(plugin.rules)) {
+		const id = `${plugin.scope}/${localId}`;
+		if (rules.has(id)) throw new Error(`Duplicate rule id "${id}".`);
+		rules.set(id, rule);
+		const severity = normalizeSeverity(config.rules?.[id]);
+		if (severity !== "off") enabledRules.push({
+			id,
+			localId,
+			rule,
+			scope: plugin.scope,
+			severity
+		});
+	}
+	for (const id of Object.keys(config.rules ?? {})) if (!rules.has(id)) throw new Error(`Unknown rule "${id}".`);
+	return {
+		enabledRules,
+		rules
+	};
+}
+function normalizeSeverity(entry) {
+	if (Array.isArray(entry)) return entry[0] ?? "warn";
+	return entry ?? "warn";
+}
+//#endregion
+//#region src/models/resolve.ts
+function resolveModel(registry, options = {}) {
+	const candidates = flattenModels(registry);
+	const ruleId = options.ruleId ?? "<unknown>";
+	if (options.request !== void 0) {
+		const request = options.request;
+		const candidate = candidates.find(({ model }) => matchesRequest(model, request));
+		if (candidate === void 0) throw new Error(`Unknown model "${request}".`);
+		if (!satisfiesHardRequirements(candidate.model, options.requirement)) throw new Error(`Model "${request}" does not satisfy requirement for rule "${ruleId}".`);
+		return toResolvedModel(candidate, options.requirement);
+	}
+	const candidate = preferSize(candidates.filter(({ model }) => satisfiesHardRequirements(model, options.requirement)), options.requirement);
+	if (candidate === void 0) throw new Error(`No model satisfies requirement for rule "${ruleId}".`);
+	return toResolvedModel(candidate, options.requirement);
+}
+function flattenModels(registry) {
+	return registry.providers.flatMap((provider) => provider.models.map((model) => ({
+		model,
+		provider
+	})));
+}
+function matchesRequest(model, request) {
+	return model.id === request || model.name === request || (model.aliases ?? []).includes(request);
+}
+function preferSize(candidates, requirement) {
+	if (requirement?.size === void 0) return candidates[0];
+	return candidates.find(({ model }) => model.size === requirement.size) ?? candidates[0];
+}
+function satisfiesHardRequirements(model, requirement) {
+	if (requirement === void 0) return true;
+	if (requirement.capabilities !== void 0 && !requirement.capabilities.every((capability) => (model.capabilities ?? []).includes(capability))) return false;
+	if (requirement.minContextWindow !== void 0 && (model.contextWindow === void 0 || model.contextWindow < requirement.minContextWindow)) return false;
+	return true;
+}
+function toResolvedModel(candidate, requirement) {
+	const { model, provider } = candidate;
+	return {
+		aliases: [...model.aliases ?? []],
+		capabilities: [...model.capabilities ?? []],
+		contextWindow: model.contextWindow,
+		id: model.id,
+		name: model.name ?? model.id,
+		params: {
+			...model.defaultParams ?? {},
+			...requirement?.params ?? {}
+		},
+		provider: {
+			endpoint: provider.endpoint,
+			headers: { ...provider.headers ?? {} },
+			id: provider.id,
+			type: provider.type
+		},
+		size: model.size
+	};
+}
+//#endregion
+//#region src/core/source/runtime.ts
+function createSourceFile(path, text) {
+	return {
+		language: inferLanguage(path),
+		lines: text.split(/\r?\n/),
+		path,
+		text
+	};
+}
+function createSourceRuntime() {
+	return {
+		getText: (target) => target.text,
+		readFile: async (filePath) => createSourceFile(filePath, await readFile(filePath, "utf8")),
+		sliceLines,
+		sliceRange
+	};
+}
+function sliceLines(file, range) {
+	const startLine = clampLine(range.startLine, file.lines.length);
+	const endLine = clampLine(range.endLine, file.lines.length);
+	const orderedStartLine = Math.min(startLine, endLine);
+	const orderedEndLine = Math.max(startLine, endLine);
+	const text = file.lines.slice(orderedStartLine - 1, orderedEndLine).join("\n");
+	return {
+		filePath: file.path,
+		loc: {
+			end: {
+				column: file.lines[orderedEndLine - 1]?.length ?? 0,
+				line: orderedEndLine
+			},
+			start: {
+				column: 0,
+				line: orderedStartLine
+			}
+		},
+		text
+	};
+}
+function sliceRange(file, range) {
+	const start = clampOffset(range.start, file.text.length);
+	const end = clampOffset(range.end, file.text.length);
+	const orderedStart = Math.min(start, end);
+	const orderedEnd = Math.max(start, end);
+	return {
+		filePath: file.path,
+		loc: {
+			end: getPosition(file.text, orderedEnd),
+			start: getPosition(file.text, orderedStart)
+		},
+		text: file.text.slice(orderedStart, orderedEnd)
+	};
+}
+function clampLine(line, lineCount) {
+	if (lineCount === 0) return 1;
+	return Math.min(Math.max(Math.trunc(line), 1), lineCount);
+}
+function clampOffset(offset, textLength) {
+	return Math.min(Math.max(Math.trunc(offset), 0), textLength);
+}
+function getPosition(text, offset) {
+	let line = 1;
+	let column = 0;
+	let index = 0;
+	while (index < offset) {
+		const character = text[index];
+		if (character === "\r") {
+			if (text[index + 1] === "\n" && index + 1 < offset) index += 1;
+			line += 1;
+			column = 0;
+		} else if (character === "\n") {
+			line += 1;
+			column = 0;
+		} else column += 1;
+		index += 1;
+	}
+	return {
+		column,
+		line
+	};
+}
+function inferLanguage(path) {
+	switch (extname(path)) {
+		case ".cjs":
+		case ".js":
+		case ".jsx":
+		case ".mjs": return "javascript";
+		case ".cts":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "typescript";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/core/source/js.ts
+function extractJsSourceUnits(file) {
+	const result = parseSync(file.path, file.text, { sourceType: "module" });
+	const state = {
+		bindingNodes: /* @__PURE__ */ new Map(),
+		classes: [],
+		exportedNodes: /* @__PURE__ */ new Set(),
+		file,
+		functions: [],
+		inferredNames: /* @__PURE__ */ new Map(),
+		seenClasses: /* @__PURE__ */ new Set(),
+		seenFunctions: /* @__PURE__ */ new Set(),
+		visited: /* @__PURE__ */ new Set()
+	};
+	collectModuleBindings(result.program, state);
+	collectExportedBindings(result.program, state);
+	visit(result.program, state);
+	return {
+		classes: state.classes,
+		functions: state.functions
+	};
+}
+function addClassUnit(node, state) {
+	if (state.seenClasses.has(node)) return;
+	const unit = createClassUnit(node, state);
+	if (!unit) return;
+	state.seenClasses.add(node);
+	state.classes.push(unit);
+}
+function addFunctionUnit(node, state) {
+	if (state.seenFunctions.has(node)) return;
+	const unit = createFunctionUnit(node, state);
+	if (!unit) return;
+	state.seenFunctions.add(node);
+	state.functions.push(unit);
+}
+function asAstNode(value) {
+	return isAstNode(value) ? value : void 0;
+}
+function collectDeclarationBindings(node, state) {
+	const name = getNodeName(node);
+	if (name && (isClassNode(node) || isFunctionNode(node))) {
+		state.bindingNodes.set(name, node);
+		return;
+	}
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const id = asAstNode(declarator.id);
+		const initializer = asAstNode(declarator.init);
+		if (typeof id?.name === "string" && initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.bindingNodes.set(id.name, initializer);
+	}
+}
+function collectExportedBindings(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectExportedBindings(child, state);
+		return;
+	}
+	if (node.type === "ExportNamedDeclaration" && !node.source && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+		if (!isAstNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+		const local = asAstNode(specifier.local);
+		if (typeof local?.name === "string") markExportedBinding(local.name, state);
+	}
+	else if (node.type === "ExportDefaultDeclaration") {
+		const declaration = asAstNode(node.declaration);
+		if (typeof declaration?.name === "string") markExportedBinding(declaration.name, state);
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) collectExportedBindings(value.filter(isAstNode), state);
+	else if (isAstNode(value)) collectExportedBindings(value, state);
+}
+function collectModuleBindings(program, state) {
+	if (!Array.isArray(program.body)) return;
+	for (const statement of program.body) {
+		if (!isAstNode(statement)) continue;
+		const declaration = isExportDeclaration(statement) ? asAstNode(statement.declaration) : statement;
+		if (declaration) collectDeclarationBindings(declaration, state);
+	}
+}
+function createClassUnit(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	return {
+		exported: isExportedUnit(node, state),
+		file: state.file,
+		kind: "class",
+		loc: source.loc,
+		name: getNodeName(node) ?? state.inferredNames.get(node),
+		range,
+		text: source.text
+	};
+}
+function createFunctionUnit(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
+	return {
+		async: functionNode?.async === true,
+		exported: isExportedUnit(node, state),
+		file: state.file,
+		kind: "function",
+		loc: source.loc,
+		name: getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node),
+		range,
+		text: source.text
+	};
+}
+function getNodeName(node) {
+	if (!node) return;
+	if (typeof node.name === "string") return node.name;
+	const id = asAstNode(node.id);
+	if (typeof id?.name === "string") return id.name;
+	const key = asAstNode(node.key);
+	if (typeof key?.name === "string") return key.name;
+	if (typeof key?.value === "string" || typeof key?.value === "number") return String(key.value);
+}
+function getRange(node) {
+	if (typeof node.start === "number" && typeof node.end === "number") return {
+		end: node.end,
+		start: node.start
+	};
+	if (Array.isArray(node.range) && node.range.length === 2) return {
+		end: node.range[1],
+		start: node.range[0]
+	};
+}
+function inferChildName(parent, key, child, state) {
+	if (state.inferredNames.has(child)) return;
+	if (parent.type === "VariableDeclarator" && key === "init") {
+		const id = asAstNode(parent.id);
+		if (typeof id?.name === "string") state.inferredNames.set(child, id.name);
+	}
+	if (parent.type === "Property" && key === "value") {
+		const name = getNodeName(parent);
+		if (name) state.inferredNames.set(child, name);
+	}
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isClassNode(node) {
+	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+function isExportDeclaration(node) {
+	return node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
+}
+function isExportedUnit(node, state) {
+	return state.exportedNodes.has(node);
+}
+function isFunctionNode(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function markExportedBinding(name, state) {
+	const bindingNode = state.bindingNodes.get(name);
+	if (bindingNode) state.exportedNodes.add(bindingNode);
+}
+function markExportedDeclaration(node, state) {
+	state.exportedNodes.add(node);
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const initializer = asAstNode(declarator.init);
+		if (initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.exportedNodes.add(initializer);
+	}
+}
+function visit(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) visit(child, state);
+		return;
+	}
+	if (state.visited.has(node)) return;
+	state.visited.add(node);
+	if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			markExportedDeclaration(node.declaration, state);
+			visit(node.declaration, state);
+		}
+		visitChildren(node, state, /* @__PURE__ */ new Set(["declaration"]));
+		return;
+	}
+	if (isClassNode(node)) addClassUnit(node, state);
+	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
+		addFunctionUnit(node, state);
+		const methodValue = node.type === "MethodDefinition" ? asAstNode(node.value) : void 0;
+		if (methodValue) state.seenFunctions.add(methodValue);
+	}
+	visitChildren(node, state);
+}
+function visitChildren(node, state, skippedKeys = /* @__PURE__ */ new Set()) {
+	for (const [key, value] of Object.entries(node)) {
+		if (skippedKeys.has(key) || key === "type" || key === "start" || key === "end" || key === "range") continue;
+		if (Array.isArray(value)) {
+			for (const child of value) if (isAstNode(child)) {
+				inferChildName(node, key, child, state);
+				visit(child, state);
+			}
+		} else if (isAstNode(value)) {
+			inferChildName(node, key, value, state);
+			visit(value, state);
+		}
+	}
+}
+//#endregion
+//#region src/core/run.ts
+var AlintRuleExecutionError = class extends Error {
+	cause;
+	failure;
+	constructor(error, path) {
+		const message = toErrorMessage(error);
+		super(message);
+		this.name = "AlintRuleExecutionError";
+		this.cause = error;
+		this.failure = {
+			filePath: path.file.path,
+			message,
+			ruleId: path.rule.id,
+			target: {
+				kind: path.target.kind,
+				name: path.target.name
+			}
+		};
+	}
+};
+var AlintRunError = class extends Error {
+	cause;
+	failure;
+	result;
+	constructor(message, result, options = {}) {
+		super(message);
+		this.name = "AlintRunError";
+		this.cause = options.cause;
+		this.failure = options.failure;
+		this.result = result;
+	}
+};
+async function runAlint(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const config = options.config ?? await loadAlintConfig(cwd);
+	const setupConfig = options.setupConfig ?? emptySetupConfig;
+	const clock = options.runner?.clock ?? Date.now;
+	const diagnostics = [];
+	const usage = createUsageAccumulator();
+	const registry = buildRuleRegistry(config);
+	const src = createSourceRuntime();
+	const files = await Promise.all((options.files ?? []).map(async (filePath) => {
+		const file = await src.readFile(resolve(cwd, filePath));
+		return {
+			file,
+			units: file.language === "javascript" || file.language === "typescript" ? extractJsSourceUnits(file) : void 0
+		};
+	}));
+	let planned = 0;
+	const counters = createRuleEndCounters();
+	const primaryError = createPrimaryErrorState();
+	let runStartedAt;
+	let runError;
+	try {
+		const filePlans = createPreparedFileExecutionPlans(registry.enabledRules.map((enabledRule) => {
+			const executionState = new AsyncLocalStorage();
+			const context = {
+				cwd,
+				id: enabledRule.id,
+				localId: enabledRule.localId,
+				logger: { debug: () => {} },
+				metering: { recordUsage: (record) => {
+					const usageRecord = usage.record({
+						...record,
+						ruleId: record.ruleId ?? enabledRule.id
+					});
+					options.progress?.onUsage?.({
+						path: executionState.getStore()?.progressPath,
+						record: usageRecord,
+						total: usage.toJSON()
+					});
+				} },
+				model: async (selector) => {
+					const request = options.modelOverride ?? (typeof selector === "string" ? selector : void 0);
+					const resolvedModel = resolveModel(setupConfig, {
+						request,
+						requirement: mergeModelRequirement(enabledRule.rule.model, typeof selector === "string" ? void 0 : selector),
+						ruleId: enabledRule.id
+					});
+					const state = executionState.getStore();
+					if (state) state.currentModel = toDiagnosticModel(resolvedModel, request);
+					return resolvedModel;
+				},
+				report: (descriptor) => {
+					const state = executionState.getStore();
+					const filePath = descriptor.filePath ?? state?.activeFilePath;
+					if (!filePath) throw new Error(`Diagnostic for rule "${enabledRule.id}" is missing filePath.`);
+					const diagnosticModel = state?.currentModel ? { ...state.currentModel } : void 0;
+					if (state) state.currentModel = void 0;
+					const diagnostic = {
+						evidence: descriptor.evidence,
+						filePath,
+						loc: descriptor.loc,
+						message: descriptor.message,
+						model: diagnosticModel,
+						ruleId: enabledRule.id,
+						severity: enabledRule.severity
+					};
+					diagnostics.push(diagnostic);
+					options.progress?.onDiagnostic?.({
+						diagnostic,
+						diagnostics: [...diagnostics],
+						path: state?.progressPath
+					});
+				},
+				scope: enabledRule.scope,
+				src
+			};
+			return {
+				enabledRule,
+				executionState,
+				handlers: enabledRule.rule.create(context)
+			};
+		}), files);
+		planned = calculatePlannedExecutions(filePlans);
+		runStartedAt = clock();
+		options.progress?.onRunStart?.({
+			files: filePlans.map((filePlan) => toProgressFilePath(filePlan, files.length)),
+			filesTotal: files.length,
+			planned,
+			rulesTotal: registry.enabledRules.length,
+			startedAt: runStartedAt
+		});
+		await runConcurrently(filePlans.filter((filePlan) => filePlan.targets.length > 0), resolveFileConcurrency(options.runner?.fileConcurrency), (filePlan) => executeFilePlan(filePlan, files.length, clock, counters, options));
+	} catch (error) {
+		primaryError.set();
+		runError = error;
+	} finally {
+		emitCleanupProgress(() => options.progress?.onRunEnd?.({
+			...counters.snapshot(planned),
+			diagnostics,
+			endedAt: clock(),
+			startedAt: runStartedAt ?? clock(),
+			usage: usage.toJSON()
+		}), primaryError);
+	}
+	const result = {
+		diagnostics,
+		usage: usage.toJSON()
+	};
+	if (runError) throw createAlintRunError(runError, result);
+	return result;
+}
+function addTokenCount(base, value) {
+	return typeof value === "number" && Number.isFinite(value) ? base + value : base;
+}
+function calculateFilePlanExecutions(filePlan) {
+	return filePlan.targets.reduce((total, target) => total + target.executions.length, 0);
+}
+function calculatePlannedExecutions(filePlans) {
+	return filePlans.reduce((total, filePlan) => total + filePlan.planned, 0);
+}
+function collectExecutionTargets(ruleRuntimes, preparedFile) {
+	const targets = [];
+	const fileExecutions = ruleRuntimes.map((runtime) => {
+		if (!runtime.handlers.onFile) return void 0;
+		return {
+			run: () => runtime.handlers.onFile?.(preparedFile.file),
+			runtime
+		};
+	}).filter((execution) => execution !== void 0);
+	if (fileExecutions.length > 0) targets.push({
+		executions: fileExecutions,
+		kind: "file"
+	});
+	if (preparedFile.units) {
+		for (const classNode of preparedFile.units.classes) {
+			const executions = ruleRuntimes.map((runtime) => {
+				if (!runtime.handlers.onClass) return void 0;
+				return {
+					run: () => runtime.handlers.onClass?.(classNode),
+					runtime
+				};
+			}).filter((execution) => execution !== void 0);
+			if (executions.length > 0) targets.push({
+				executions,
+				kind: "class",
+				name: classNode.name
+			});
+		}
+		for (const functionNode of preparedFile.units.functions) {
+			const executions = ruleRuntimes.map((runtime) => {
+				if (!runtime.handlers.onFunction) return void 0;
+				return {
+					run: () => runtime.handlers.onFunction?.(functionNode),
+					runtime
+				};
+			}).filter((execution) => execution !== void 0);
+			if (executions.length > 0) targets.push({
+				executions,
+				kind: "function",
+				name: functionNode.name
+			});
+		}
+	}
+	return targets;
+}
+function createAlintRunError(error, result) {
+	if (error instanceof AlintRunError) return error;
+	if (error instanceof AlintRuleExecutionError) return new AlintRunError(error.message, result, {
+		cause: error.cause,
+		failure: error.failure
+	});
+	return new AlintRunError(toErrorMessage(error), result, { cause: error });
+}
+function createPreparedFileExecutionPlans(ruleRuntimes, files) {
+	return files.map((preparedFile, fileOffset) => {
+		const filePlan = {
+			fileIndex: fileOffset + 1,
+			planned: 0,
+			preparedFile,
+			targets: collectExecutionTargets(ruleRuntimes, preparedFile)
+		};
+		filePlan.planned = calculateFilePlanExecutions(filePlan);
+		return filePlan;
+	});
+}
+function createPrimaryErrorState() {
+	let hasError = false;
+	return {
+		get hasError() {
+			return hasError;
+		},
+		set() {
+			hasError = true;
+		}
+	};
+}
+function createProgressPath(filePath, ruleId, entry) {
+	return {
+		file: {
+			index: entry.fileIndex,
+			path: filePath,
+			planned: entry.filePlanned,
+			total: entry.fileTotal
+		},
+		rule: {
+			id: ruleId,
+			index: entry.ruleIndex,
+			total: entry.ruleTotal
+		},
+		target: {
+			index: entry.targetIndex,
+			kind: entry.targetKind,
+			name: entry.targetName,
+			total: entry.targetTotal
+		}
+	};
+}
+function createRuleEndCounters() {
+	let completed = 0;
+	let errored = 0;
+	return {
+		complete() {
+			completed += 1;
+		},
+		error() {
+			errored += 1;
+		},
+		snapshot(planned) {
+			return {
+				cached: 0,
+				completed,
+				errored,
+				planned
+			};
+		}
+	};
+}
+function createUsageAccumulator() {
+	const records = [];
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let totalTokens = 0;
+	return {
+		record(record) {
+			records.push(record);
+			inputTokens = addTokenCount(inputTokens, record.inputTokens);
+			outputTokens = addTokenCount(outputTokens, record.outputTokens);
+			totalTokens = addTokenCount(totalTokens, record.totalTokens);
+			return record;
+		},
+		toJSON() {
+			return {
+				inputTokens,
+				outputTokens,
+				records,
+				totalTokens
+			};
+		}
+	};
+}
+function emitCleanupProgress(callback, primaryError) {
+	try {
+		callback();
+	} catch (error) {
+		if (!primaryError.hasError) throw error;
+	}
+}
+async function executeFilePlan(filePlan, filesTotal, clock, counters, options) {
+	const preparedFile = filePlan.preparedFile;
+	const fileStartedAt = clock();
+	const fileProgress = {
+		index: filePlan.fileIndex,
+		path: preparedFile.file.path,
+		planned: filePlan.planned,
+		total: filesTotal
+	};
+	options.progress?.onFileStart?.({
+		file: fileProgress,
+		startedAt: fileStartedAt
+	});
+	const fileError = createPrimaryErrorState();
+	try {
+		for (const [targetOffset, target] of filePlan.targets.entries()) {
+			const targetPath = createProgressPath(preparedFile.file.path, target.executions[0]?.runtime.enabledRule.id ?? "", {
+				fileIndex: filePlan.fileIndex,
+				filePlanned: filePlan.planned,
+				fileTotal: filesTotal,
+				ruleIndex: 1,
+				ruleTotal: target.executions.length,
+				targetIndex: targetOffset + 1,
+				targetKind: target.kind,
+				targetName: target.name,
+				targetTotal: filePlan.targets.length
+			});
+			const targetError = createPrimaryErrorState();
+			const targetStartedAt = clock();
+			options.progress?.onTargetStart?.({
+				path: targetPath,
+				startedAt: targetStartedAt
+			});
+			try {
+				for (const [executionOffset, execution] of target.executions.entries()) await executeProgressTarget(execution, createProgressPath(preparedFile.file.path, execution.runtime.enabledRule.id, {
+					fileIndex: filePlan.fileIndex,
+					filePlanned: filePlan.planned,
+					fileTotal: filesTotal,
+					ruleIndex: executionOffset + 1,
+					ruleTotal: target.executions.length,
+					targetIndex: targetOffset + 1,
+					targetKind: target.kind,
+					targetName: target.name,
+					targetTotal: filePlan.targets.length
+				}), clock, counters, options);
+			} catch (error) {
+				targetError.set();
+				throw error;
+			} finally {
+				emitCleanupProgress(() => options.progress?.onTargetEnd?.({
+					endedAt: clock(),
+					path: targetPath,
+					startedAt: targetStartedAt
+				}), targetError);
+			}
+		}
+	} catch (error) {
+		fileError.set();
+		throw error;
+	} finally {
+		emitCleanupProgress(() => options.progress?.onFileEnd?.({
+			endedAt: clock(),
+			file: fileProgress,
+			startedAt: fileStartedAt
+		}), fileError);
+	}
+}
+async function executeProgressTarget(execution, path, clock, counters, options) {
+	const startedAt = clock();
+	options.progress?.onRuleStart?.({
+		path,
+		startedAt
+	});
+	let handlerError;
+	let handlerSucceeded = false;
+	try {
+		await execution.runtime.executionState.run({
+			activeFilePath: path.file.path,
+			progressPath: path
+		}, execution.run);
+		handlerSucceeded = true;
+	} catch (error) {
+		handlerError = error;
+	}
+	if (handlerSucceeded) {
+		counters.complete();
+		options.progress?.onRuleEnd?.({
+			cache: "miss",
+			endedAt: clock(),
+			path,
+			startedAt,
+			state: "completed"
+		});
+		return;
+	}
+	counters.error();
+	try {
+		options.progress?.onRuleEnd?.({
+			cache: "miss",
+			endedAt: clock(),
+			path,
+			startedAt,
+			state: "errored"
+		});
+	} catch {}
+	throw new AlintRuleExecutionError(handlerError, path);
+}
+function mergeCapabilities(base, extra) {
+	if (!base && !extra) return;
+	return [.../* @__PURE__ */ new Set([...base ?? [], ...extra ?? []])];
+}
+function mergeMinContextWindow(base, extra) {
+	if (base === void 0) return extra;
+	if (extra === void 0) return base;
+	return Math.max(base, extra);
+}
+function mergeModelRequirement(base, extra) {
+	if (!base && !extra) return;
+	const capabilities = mergeCapabilities(base?.capabilities, extra?.capabilities);
+	const params = {
+		...base?.params ?? {},
+		...extra?.params ?? {}
+	};
+	return {
+		capabilities,
+		minContextWindow: mergeMinContextWindow(base?.minContextWindow, extra?.minContextWindow),
+		params: Object.keys(params).length > 0 ? params : void 0,
+		size: extra?.size ?? base?.size
+	};
+}
+function resolveFileConcurrency(fileConcurrency) {
+	return fileConcurrency ?? 1;
+}
+async function runConcurrently(items, concurrency, runItem) {
+	let firstError;
+	let nextIndex = 0;
+	const workerCount = Math.min(Math.max(concurrency, 1), items.length);
+	async function runWorker() {
+		while (firstError === void 0) {
+			const currentIndex = nextIndex;
+			nextIndex += 1;
+			if (currentIndex >= items.length) return;
+			try {
+				await runItem(items[currentIndex]);
+			} catch (error) {
+				firstError ??= error;
+				return;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+	if (firstError !== void 0) throw firstError;
+}
+function toDiagnosticModel(model, request) {
+	return {
+		providerId: model.provider.id,
+		requested: request,
+		resolvedId: model.id
+	};
+}
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function toProgressFilePath(filePlan, filesTotal) {
+	return {
+		index: filePlan.fileIndex,
+		path: filePlan.preparedFile.file.path,
+		planned: filePlan.planned,
+		total: filesTotal
+	};
+}
+//#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 errored = payload.errored > 0 ? `, ${payload.errored} errored` : "";
+			writeLine(`alint ${state}: ${warnCount} warn, ${errorCount} error, ${payload.usage.totalTokens} tokens${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("--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-model <model>", "Provider model").option("--provider-header <Key=Value>", "Provider header").action((options) => {
+		pendingResult = runSetupCommand({
+			...options,
+			noInteractive: setupNoInteractive
+		}, 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 createSetupConfig(providerEndpoint, options) {
+	const models = toArray(options.providerModel).map((model) => ({
+		id: model,
+		name: model
+	}));
+	return {
+		providers: [{
+			endpoint: providerEndpoint,
+			headers: parseHeaders(toArray(options.providerHeader)),
+			id: providerEndpoint,
+			models,
+			type: "openai-compatible"
+		}],
+		version: 1
+	};
+}
+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;
+}
+function isNoInteractive(options) {
+	return options.noInteractive === true;
+}
+function parseHeaders(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;
+}
+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;
+}
+function resolveRunnerConfig(setupConfig, config, 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 ?? {},
+		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 runDefaultCommand(files, options, io) {
+	if (options.config) await assertConfigExists(io.cwd, options.config);
+	const globalSetupConfigPath = getGlobalSetupConfigPath(io.env ?? process.env);
+	const projectSetupConfigPath = getProjectSetupConfigPath(io.cwd);
+	const [globalSetupConfig, projectSetupConfig, config] = await Promise.all([
+		loadSetupConfig(globalSetupConfigPath),
+		loadSetupConfig(projectSetupConfigPath),
+		loadAlintConfig(io.cwd, options.config)
+	]);
+	const setupConfig = mergeSetupConfigs(globalSetupConfig, projectSetupConfig);
+	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,
+			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 runSetupCommand(options, io) {
+	if (!options.providerEndpoint) {
+		if (!isNoInteractive(options)) {
+			io.stderr.write("interactive setup is not implemented yet. Use -N/--no-interactive with --provider-endpoint.\n");
+			return 2;
+		}
+		io.stderr.write("setup requires --provider-endpoint 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.providerEndpoint, options)));
+	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 { mergeSetupConfigs as _, runAlint as a, getGlobalSetupConfigPath as b, createSourceRuntime as c, resolveModel as d, buildRuleRegistry as f, loadSetupConfig as g, emptySetupConfig as h, formatJson as i, sliceLines as l, writeSetupConfig as m, formatDiagnostics as n, extractJsSourceUnits as o, loadAlintConfig as p, formatStylish as r, createSourceFile as s, executeCli as t, sliceRange as u, parseSetupConfigToml as v, getProjectSetupConfigPath as x, stringifySetupConfigToml as y };