@alint-js/cli 0.0.8 → 0.0.10

package/dist/bin/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as executeCli } from "../cli-D7cUTZnE.mjs";
+import { t as executeCli } from "../cli-D4YC9Jnb.mjs";
 import process from "node:process";
 //#region src/bin/index.ts
 executeCli(process.argv, {

package/dist/{cli-D7cUTZnE.mjs → cli-D4YC9Jnb.mjs}

@@ -1,17 +1,17 @@
 import process from "node:process";
 import { inspect } from "node:util";
 import { cac } from "cac";
-import { getGlobalSetupConfigPath, getProjectSetupConfigPath, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, writeSetupConfig } from "@alint-js/config";
+import { getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, writeSetupConfig } from "@alint-js/config";
 import { AlintRunError, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, resolveConfigForFile, runAlint } from "@alint-js/core";
-import { relative, resolve } from "pathe";
+import { isAbsolute, join, relative, resolve } from "pathe";
 import { getBorderCharacters, table } from "table";
 import { errorMessageFrom } from "@moeru/std/error";
-import { readFile, readdir, stat } from "node:fs/promises";
+import { appendFile, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
 import c, { createColors } from "tinyrainbow";
 import cliSpinners from "cli-spinners";
 import { relative as relative$1 } from "node:path";
 import Gitignore from "gitignore-fs";
-import { minimatch } from "minimatch";
+import { Minimatch, minimatch } from "minimatch";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
 //#region src/cli/commands/command.ts
 function defineCommand(node) {
@@ -183,8 +183,10 @@ function rewriteUsageSection(sections, path, node) {
 function shouldSkipOptionValue(arg) {
 	if (arg.includes("=")) return false;
 	return [
+		"--by",
 		"--cache-location",
 		"--config",
+		"--cwd",
 		"--file-concurrency",
 		"--format",
 		"--model",
@@ -193,6 +195,7 @@ function shouldSkipOptionValue(arg) {
 		"--provider-id",
 		"--provider-model",
 		"--rule-concurrency",
+		"--since",
 		"--timeout-ms",
 		"-f",
 		"-l"
@@ -499,7 +502,7 @@ function formatJson(result) {
 }
 //#endregion
 //#region src/cli/reporters/stylish.ts
-const colors$1 = createColors({ force: true });
+const colors$2 = 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;
@@ -541,12 +544,12 @@ function createStyle(color) {
 		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
+		error: colors$2.red,
+		file: colors$2.underline,
+		location: colors$2.dim,
+		ruleId: colors$2.dim,
+		summaryToken: colors$2.cyan,
+		warning: colors$2.yellow
 	};
 }
 function formatSummary(diagnostics, totalTokens, style) {
@@ -594,7 +597,7 @@ function countDiagnostics$1(diagnostics, severity) {
 }
 //#endregion
 //#region src/cli/reporters/progress/summary.ts
-const colors = createColors({ force: true });
+const colors$1 = createColors({ force: true });
 function createSummaryProgressReporter(options) {
 	const now = () => options.clock?.() ?? Date.now();
 	const state = {
@@ -802,8 +805,8 @@ function replaceFirst(row, 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));
+	if (spinner) styledRow = replaceFirst(styledRow, spinner, colors$1.cyan(spinner));
+	styledRow = styledRow.replace(/\|/g, colors$1.gray("|")).replace(`${warnCount} warn`, colors$1.yellow(`${warnCount} warn`)).replace(`${errorCount} error`, (errorCount > 0 ? colors$1.red : colors$1.gray)(`${errorCount} error`)).replace(/(\d+\/\d+\/\d+\/\d+)/, (match) => state.errored > 0 ? colors$1.red(match) : colors$1.gray(match)).replace(/(\d[\d,]* tokens)/g, (match) => colors$1.cyan(match));
 	return styledRow;
 }
 //#endregion
@@ -933,9 +936,28 @@ function createRenderingProgressReporter(summary, renderer) {
 }
 //#endregion
 //#region src/cli/commands/lint/discovery.ts
-async function resolveLintFiles(files, config, cwd) {
+const minimatchOptions = { dot: true };
+var NoFilesFoundError = class extends Error {
+	globInputPaths;
+	pattern;
+	constructor(pattern, options) {
+		super(`No files matching "${pattern}" were found${options.globInputPaths ? "" : " (glob input is disabled)"}.`);
+		this.name = "NoFilesFoundError";
+		this.globInputPaths = options.globInputPaths;
+		this.pattern = pattern;
+	}
+};
+async function findFiles(options) {
+	const { config, cwd, errorOnUnmatchedPattern = true, globInputPaths = true, inputs } = options;
 	const gitignore = shouldFilterGitignoredFiles(config) ? new Gitignore() : void 0;
-	const candidates = files.length > 0 ? files : await discoverLintFiles(config, cwd, gitignore);
+	const candidates = await resolveInputFiles({
+		config,
+		cwd,
+		errorOnUnmatchedPattern,
+		gitignore,
+		globInputPaths,
+		inputs: inputs.length > 0 ? inputs : ["."]
+	});
 	if (!gitignore || candidates.length === 0) return candidates;
 	const lintFiles = [];
 	for (const file of candidates) {
@@ -947,31 +969,122 @@ async function resolveLintFiles(files, config, cwd) {
 function collectGlobalIgnorePatterns(config) {
 	return normalizeConfig(config).flatMap((item) => isGlobalIgnoreItem(item) ? [...item.ignores] : []);
 }
-async function discoverLintFiles(config, cwd, gitignore) {
-	if (!hasDiscoveryFilePatterns(config)) return [];
-	const candidates = (await walkFiles(cwd, {
-		cwd,
-		gitignore,
-		ignoredPatterns: collectGlobalIgnorePatterns(config)
-	})).map((file) => normalizeRelativePath(cwd, file)).filter((file) => matchesDiscoveryFile(file, config, { cwd }));
-	return [...new Set(candidates)].sort();
+function getGlobParent(input) {
+	const segments = input.replaceAll("\\", "/").split("/");
+	const parentSegments = [];
+	for (const segment of segments) {
+		if (isGlobPattern(segment)) break;
+		parentSegments.push(segment);
+	}
+	const parent = parentSegments.join("/");
+	return parent === "" ? "." : parent;
 }
 function isGlobalIgnoreItem(item) {
 	const keys = Object.keys(item).filter((key) => item[key] !== void 0);
 	return item.ignores !== void 0 && keys.every((key) => key === "ignores" || key === "name");
 }
+function isGlobPattern(input) {
+	return new Minimatch(input, minimatchOptions).hasMagic();
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+function matchesGlob(filePath, pattern) {
+	return minimatch(filePath, pattern.replaceAll("\\", "/"), minimatchOptions);
+}
 function matchesIgnoredDirectory(relativePath, patterns) {
-	return patterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }) || minimatch(`${relativePath}/`, pattern, { dot: true }) || minimatch(`${relativePath}/__alint__`, pattern, { dot: true }));
+	return patterns.some((pattern) => minimatch(relativePath, pattern, minimatchOptions) || minimatch(`${relativePath}/`, pattern, minimatchOptions) || minimatch(`${relativePath}/__alint__`, pattern, minimatchOptions));
+}
+function normalizeGlobPattern(cwd, pattern) {
+	return isAbsolute(pattern) ? normalizeRelativePath(cwd, pattern) : pattern.replaceAll("\\", "/");
 }
 function normalizeRelativePath(cwd, filePath) {
 	return relative(cwd, filePath).replaceAll("\\", "/");
 }
+async function resolveInputFiles(options) {
+	const hasFilePatterns = hasDiscoveryFilePatterns(options.config);
+	const ignoredPatterns = collectGlobalIgnorePatterns(options.config);
+	const candidates = [];
+	for (const input of options.inputs) {
+		const path = resolve(options.cwd, input);
+		const stats = await statPath(path);
+		if (stats?.isFile()) {
+			candidates.push(input);
+			continue;
+		}
+		if (stats?.isDirectory()) {
+			if (!hasFilePatterns) continue;
+			if (await shouldPruneDirectory(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})) continue;
+			const directoryFiles = (await walkFiles(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})).sort();
+			for (const directoryFile of directoryFiles) {
+				const relativePath = normalizeRelativePath(options.cwd, directoryFile);
+				if (hasFilePatterns && matchesDiscoveryFile(relativePath, options.config, { cwd: options.cwd })) candidates.push(relativePath);
+			}
+			continue;
+		}
+		if (options.globInputPaths && isGlobPattern(input)) {
+			const matches = await searchGlob({
+				config: options.config,
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				hasFilePatterns,
+				ignoredPatterns,
+				pattern: input
+			});
+			if (matches.length === 0 && options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+			candidates.push(...matches);
+			continue;
+		}
+		if (options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+	}
+	return [...new Set(candidates)];
+}
+async function searchGlob(options) {
+	const root = resolve(options.cwd, getGlobParent(options.pattern));
+	const rootStats = await statPath(root);
+	const pattern = normalizeGlobPattern(options.cwd, options.pattern);
+	if (!rootStats?.isDirectory()) return [];
+	const files = (await walkFiles(root, {
+		cwd: options.cwd,
+		gitignore: options.gitignore,
+		ignoredPatterns: options.ignoredPatterns
+	})).sort();
+	const candidates = [];
+	for (const file of files) {
+		const relativePath = normalizeRelativePath(options.cwd, file);
+		if (matchesGlob(relativePath, pattern) && shouldIncludeGlobCandidate(relativePath, options.config, {
+			cwd: options.cwd,
+			hasFilePatterns: options.hasFilePatterns
+		})) candidates.push(relativePath);
+	}
+	return candidates;
+}
 function shouldFilterGitignoredFiles(config) {
 	return normalizeConfig(config).some((item) => item.ignore?.gitignore === true);
 }
+function shouldIncludeGlobCandidate(filePath, config, options) {
+	if (options.hasFilePatterns) return matchesDiscoveryFile(filePath, config, { cwd: options.cwd });
+	return !resolveConfigForFile(filePath, config, { cwd: options.cwd }).ignored;
+}
 async function shouldPruneDirectory(path, options) {
 	if (matchesIgnoredDirectory(normalizeRelativePath(options.cwd, path), options.ignoredPatterns)) return true;
-	return await options.gitignore?.ignores(path) === true;
+	return await options.gitignore?.ignores(`${path}/`) === true;
+}
+async function statPath(path) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isNodeError$1(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) return;
+		throw error;
+	}
 }
 async function walkFiles(root, options) {
 	const entries = await readdir(root, { withFileTypes: true });
@@ -1011,6 +1124,7 @@ function resolveConfigRunner(config) {
 }
 function resolveRunnerConfig(setupConfig, config, options) {
 	const cache = resolveRunnerCacheConfig(setupConfig.runner?.cache, config.runner?.cache, options);
+	const stats = resolveRunnerStatsConfig(setupConfig.runner?.stats, config.runner?.stats, options);
 	const fileConcurrency = parsePositiveIntegerOption(options.fileConcurrency, "--file-concurrency");
 	const ruleConcurrency = parsePositiveIntegerOption(options.ruleConcurrency, "--rule-concurrency");
 	const timeoutMs = parsePositiveIntegerOption(options.timeoutMs, "--timeout-ms");
@@ -1020,6 +1134,7 @@ function resolveRunnerConfig(setupConfig, config, options) {
 		cache,
 		fileConcurrency: fileConcurrency ?? config.runner?.fileConcurrency ?? setupConfig.runner?.fileConcurrency,
 		ruleConcurrency: ruleConcurrency ?? config.runner?.ruleConcurrency ?? setupConfig.runner?.ruleConcurrency,
+		stats,
 		timeoutMs: timeoutMs ?? config.runner?.timeoutMs ?? setupConfig.runner?.timeoutMs
 	};
 	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
@@ -1033,6 +1148,15 @@ function mergeRunnerCacheConfig(setupCache, configCache) {
 	};
 	return configCache;
 }
+function mergeRunnerStatsConfig(setupStats, configStats) {
+	if (configStats === void 0) return setupStats;
+	if (typeof configStats === "boolean") return configStats;
+	if (typeof setupStats === "object") return {
+		...setupStats,
+		...configStats
+	};
+	return configStats;
+}
 function parsePositiveIntegerOption(value, label) {
 	if (value === void 0) return;
 	const parsed = Number(value);
@@ -1048,6 +1172,304 @@ function resolveRunnerCacheConfig(setupCache, configCache, options) {
 	} : { location: options.cacheLocation };
 	return configuredCache;
 }
+function resolveRunnerStatsConfig(setupStats, configStats, options) {
+	if (options.stats === false) return false;
+	return mergeRunnerStatsConfig(setupStats, configStats);
+}
+//#endregion
+//#region src/cli/stats/ci.ts
+function isCi(env = process.env) {
+	const ci = env.CI;
+	if (ci !== void 0 && ci !== "" && ci !== "0" && ci !== "false") return true;
+	return Boolean(env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.BUILDKITE || env.TF_BUILD);
+}
+//#endregion
+//#region src/cli/stats/since.ts
+/**
+* Parse a `--since` time into an inclusive lower-bound timestamp.
+* This is a tiny helper only to meet the needs.
+*
+* Supported formats:
+* - `Nd`/`Nh` — Now minus N days/hours.
+* - `YYYY-MM`/`YYYY-MM-DD` — Start of that UTC month/day.
+*
+* Edge cases:
+* - An empty time means "no lower bound".
+* - An unrecognized time will cause an error to be thrown.
+*/
+function parseSince(time, now) {
+	if (time === void 0 || time === "") return;
+	const relative = /^(\d+)([dh])$/u.exec(time);
+	if (relative) return now - Number(relative[1]) * (relative[2] === "d" ? 864e5 : 36e5);
+	const calendar = /^(\d{4})-(\d{2})(?:-(\d{2}))?$/u.exec(time);
+	if (calendar) {
+		const year = Number(calendar[1]);
+		const month = Number(calendar[2]);
+		const day = calendar[3] === void 0 ? 1 : Number(calendar[3]);
+		return Date.UTC(year, month - 1, day);
+	}
+	throw new Error(`Invalid --since "${time}": use e.g. 7d, 24h, 2025-01, or 2025-01-15.`);
+}
+//#endregion
+//#region src/cli/stats/jsonl.ts
+const DEFAULT_RETENTION_MONTHS = 12;
+const STATS_FILE_PATTERN = /^stats-(\d{4})-(\d{2})\.jsonl$/u;
+function createJsonlStatsStore(options) {
+	const now = options.clock ?? Date.now;
+	const retentionMonths = options.retentionMonths ?? DEFAULT_RETENTION_MONTHS;
+	return {
+		query: (filter) => query(options.dir, filter ?? {}, now),
+		record: (input) => record(options.dir, input, now(), retentionMonths)
+	};
+}
+function accumulate(rows, key, inTok, outTok, totalTok, countRun) {
+	const row = rows.get(key) ?? {
+		inTok: 0,
+		key,
+		outTok: 0,
+		runs: 0,
+		totalTok: 0
+	};
+	row.inTok += inTok;
+	row.outTok += outTok;
+	row.totalTok += totalTok;
+	if (countRun) row.runs += 1;
+	rows.set(key, row);
+}
+function isEnoent(error) {
+	return error instanceof Error && error.code === "ENOENT";
+}
+function monthIndexOf(ts) {
+	const date = new Date(ts);
+	return date.getUTCFullYear() * 12 + date.getUTCMonth();
+}
+function parseRunLine(line) {
+	try {
+		const value = JSON.parse(line);
+		if (typeof value.ts === "number" && typeof value.cwd === "string" && value.usage != null) return value;
+		return;
+	} catch {
+		return;
+	}
+}
+async function prune(dir, ts, retentionMonths) {
+	if (retentionMonths <= 0) return;
+	const cutoff = monthIndexOf(ts) - (retentionMonths - 1);
+	const files = await statsFiles(dir);
+	for (const { month, name } of files) if (month < cutoff) await rm(join(dir, name));
+}
+async function query(dir, filter, now) {
+	const dimension = filter.by ?? "model";
+	const since = parseSince(filter.since, now());
+	const runs = await readRuns(dir);
+	const rows = /* @__PURE__ */ new Map();
+	let totalRuns = 0;
+	let totalIn = 0;
+	let totalOut = 0;
+	let totalTok = 0;
+	for (const run of runs) {
+		if (since !== void 0 && run.ts < since) continue;
+		if (filter.cwd !== void 0 && run.cwd !== filter.cwd) continue;
+		totalRuns += 1;
+		totalIn += run.usage.inTok;
+		totalOut += run.usage.outTok;
+		totalTok += run.usage.totalTok;
+		if (dimension === "dir") {
+			accumulate(rows, run.cwd, run.usage.inTok, run.usage.outTok, run.usage.totalTok, true);
+			continue;
+		}
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const usageRecord of run.usage.records) {
+			const key = recordKey(usageRecord, dimension);
+			accumulate(rows, key, usageRecord.inTok, usageRecord.outTok, usageRecord.totalTok, !seenKeys.has(key));
+			seenKeys.add(key);
+		}
+	}
+	return {
+		dimension,
+		rows: [...rows.values()].sort((left, right) => right.totalTok - left.totalTok),
+		totalIn,
+		totalOut,
+		totalRuns,
+		totalTok
+	};
+}
+async function readRuns(dir) {
+	const files = await statsFiles(dir);
+	const runs = [];
+	for (const { name } of files) {
+		const content = await readFile(join(dir, name), "utf8");
+		for (const line of content.split("\n")) {
+			if (line.trim() === "") continue;
+			const run = parseRunLine(line);
+			if (run) runs.push(run);
+		}
+	}
+	return runs;
+}
+async function record(dir, input, ts, retentionMonths) {
+	const stat = {
+		ts,
+		...input
+	};
+	await mkdir(dir, { recursive: true });
+	await appendFile(join(dir, statsFileName(ts)), `${JSON.stringify(stat)}\n`, "utf8");
+	await prune(dir, ts, retentionMonths);
+}
+function recordKey(record, dimension) {
+	if (dimension === "rule") return record.ruleId;
+	if (dimension === "operation") return record.operation ?? record.ruleId;
+	return `${record.providerId}/${record.modelId}`;
+}
+function statsFileName(ts) {
+	const date = new Date(ts);
+	return `stats-${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}.jsonl`;
+}
+async function statsFiles(dir) {
+	let entries;
+	try {
+		entries = await readdir(dir);
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+	return entries.map((name) => {
+		const match = STATS_FILE_PATTERN.exec(name);
+		return match ? {
+			month: Number(match[1]) * 12 + (Number(match[2]) - 1),
+			name
+		} : void 0;
+	}).filter((entry) => entry !== void 0).sort((left, right) => left.month - right.month);
+}
+//#endregion
+//#region src/cli/stats/record.ts
+function createRunStat(input) {
+	return {
+		cwd: input.cwd,
+		durationMs: input.durationMs,
+		ruleCounts: input.ruleCounts,
+		usage: {
+			inTok: input.usage.inputTokens,
+			outTok: input.usage.outputTokens,
+			records: input.usage.records.map(toStatsUsageRecord),
+			totalTok: input.usage.totalTokens
+		}
+	};
+}
+function readOperation(metadata) {
+	if (typeof metadata !== "object" || metadata === null || !("operation" in metadata)) return;
+	const operation = metadata.operation;
+	return typeof operation === "string" ? operation : void 0;
+}
+function toStatsUsageRecord(record) {
+	return {
+		filePath: record.filePath,
+		inTok: record.inputTokens ?? 0,
+		modelId: record.modelId,
+		operation: readOperation(record.metadata),
+		outTok: record.outputTokens ?? 0,
+		providerId: record.providerId,
+		ruleId: record.ruleId,
+		totalTok: record.totalTokens ?? 0
+	};
+}
+//#endregion
+//#region src/cli/commands/lint/stats.ts
+function createStatsCollector() {
+	const counts = {
+		cached: 0,
+		completed: 0,
+		errored: 0,
+		planned: 0
+	};
+	let startedAt;
+	let endedAt;
+	return {
+		counts,
+		durationMs: () => startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0,
+		reporter: {
+			onRunEnd: (payload) => {
+				counts.cached = payload.cached;
+				counts.completed = payload.completed;
+				counts.errored = payload.errored;
+				counts.planned = payload.planned;
+				endedAt = payload.endedAt;
+			},
+			onRunStart: (payload) => {
+				startedAt = payload.startedAt;
+			}
+		}
+	};
+}
+function mergeProgressReporters(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return {
+		onDiagnostic: (payload) => {
+			base.onDiagnostic?.(payload);
+			extra.onDiagnostic?.(payload);
+		},
+		onFileEnd: (payload) => {
+			base.onFileEnd?.(payload);
+			extra.onFileEnd?.(payload);
+		},
+		onFileStart: (payload) => {
+			base.onFileStart?.(payload);
+			extra.onFileStart?.(payload);
+		},
+		onRuleEnd: (payload) => {
+			base.onRuleEnd?.(payload);
+			extra.onRuleEnd?.(payload);
+		},
+		onRuleStart: (payload) => {
+			base.onRuleStart?.(payload);
+			extra.onRuleStart?.(payload);
+		},
+		onRunEnd: (payload) => {
+			base.onRunEnd?.(payload);
+			extra.onRunEnd?.(payload);
+		},
+		onRunStart: (payload) => {
+			base.onRunStart?.(payload);
+			extra.onRunStart?.(payload);
+		},
+		onTargetEnd: (payload) => {
+			base.onTargetEnd?.(payload);
+			extra.onTargetEnd?.(payload);
+		},
+		onTargetStart: (payload) => {
+			base.onTargetStart?.(payload);
+			extra.onTargetStart?.(payload);
+		},
+		onUsage: (payload) => {
+			base.onUsage?.(payload);
+			extra.onUsage?.(payload);
+		}
+	};
+}
+function resolveStatsWrite(stats, env) {
+	if (isCi(env)) return;
+	if (!(stats === false ? false : stats === void 0 || stats === true ? true : stats.enabled !== false)) return;
+	const config = typeof stats === "object" ? stats : void 0;
+	return {
+		dir: config?.location ?? getStatsDir(env),
+		retentionMonths: config?.retentionMonths
+	};
+}
+async function writeRunStats(target, collector, result, cwd) {
+	const store = createJsonlStatsStore({
+		dir: target.dir,
+		retentionMonths: target.retentionMonths
+	});
+	try {
+		await store.record(createRunStat({
+			cwd,
+			durationMs: collector.durationMs(),
+			ruleCounts: collector.counts,
+			usage: result.usage
+		}));
+	} catch {}
+}
 //#endregion
 //#region src/cli/commands/lint/index.ts
 const lint = defineCommand({
@@ -1076,7 +1498,22 @@ function isNodeError(error) {
 async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	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);
+	let lintFiles;
+	try {
+		lintFiles = await findFiles({
+			config,
+			cwd: io.cwd,
+			errorOnUnmatchedPattern: true,
+			globInputPaths: true,
+			inputs: files
+		});
+	} catch (error) {
+		if (error instanceof NoFilesFoundError) {
+			io.stderr.write(`${error.message}\n`);
+			return 2;
+		}
+		throw error;
+	}
 	const runner = resolveRunnerConfig(setupConfig, { runner: resolveConfigRunner(config) }, options);
 	const progress = shouldEnableProgress(options, io) ? createCliProgressReporter({
 		color: io.stderr.isTTY === true,
@@ -1086,6 +1523,8 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 		write: (chunk) => io.stderr.write(chunk)
 	}) : void 0;
 	const restoreProgressConsole = progress ? interceptConsoleOutput({ write: progress.write }) : void 0;
+	const statsTarget = resolveStatsWrite(runner?.stats, io.env);
+	const statsCollector = statsTarget ? createStatsCollector() : void 0;
 	let result;
 	try {
 		result = await runAlint({
@@ -1094,7 +1533,7 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 			files: lintFiles,
 			modelOverride: options.model,
 			outputLanguage: options.outputLanguage,
-			progress: progress?.reporter,
+			progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
 			runner,
 			setupConfig
 		});
@@ -1109,6 +1548,7 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	}
 	restoreProgressConsole?.();
 	progress?.dispose();
+	if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, result, io.cwd);
 	io.stdout.write(formatDiagnostics(options.format, result, { color: io.stdout.isTTY === true }));
 	return result.diagnostics.length > 0 ? 1 : 0;
 }
@@ -1531,11 +1971,112 @@ function toArray(value) {
 	return (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string");
 }
 //#endregion
+//#region src/cli/commands/stats/format.ts
+const colors = createColors({ force: true });
+const DIMENSION_LABEL = {
+	dir: "directory",
+	model: "model",
+	operation: "operation",
+	rule: "rule"
+};
+function formatStatsAggregate(aggregate, options = {}) {
+	const paint = (text, style) => options.color === true ? style(text) : text;
+	const runLabel = aggregate.totalRuns === 1 ? "run" : "runs";
+	const lines = [`${aggregate.totalRuns} ${runLabel} — ${formatTokens(aggregate.totalIn)} in / ${formatTokens(aggregate.totalOut)} out / ${paint(`${formatTokens(aggregate.totalTok)} total`, colors.cyan)}`, ""];
+	if (aggregate.rows.length === 0) {
+		lines.push("No stats recorded yet.");
+		return `${lines.join("\n")}\n`;
+	}
+	const header = [
+		DIMENSION_LABEL[aggregate.dimension],
+		"runs",
+		"input",
+		"output",
+		"total"
+	];
+	const rows = aggregate.rows.map((row) => [
+		row.key,
+		String(row.runs),
+		formatTokens(row.inTok),
+		formatTokens(row.outTok),
+		formatTokens(row.totalTok)
+	]);
+	const widths = header.map((cell, index) => Math.max(cell.length, ...rows.map((row) => row[index].length)));
+	const renderRow = (cells, isHeader) => cells.map((cell, index) => {
+		const aligned = index === 0 ? cell.padEnd(widths[index]) : cell.padStart(widths[index]);
+		return isHeader ? paint(aligned, colors.bold) : aligned;
+	}).join("  ");
+	lines.push(renderRow(header, true), ...rows.map((row) => renderRow(row, false)));
+	return `${lines.join("\n")}\n`;
+}
+function formatTokens(value) {
+	return value.toLocaleString("en-US");
+}
+//#endregion
+//#region src/cli/commands/stats/stats.ts
+const DIMENSIONS = /* @__PURE__ */ new Set([
+	"dir",
+	"model",
+	"operation",
+	"rule"
+]);
+async function runStatsCommand(options, io) {
+	try {
+		const dimension = parseDimension(options.by);
+		const [setupConfig, config] = await Promise.all([loadMergedSetupConfig(io), loadAlintConfig(io.cwd)]);
+		const aggregate = await createJsonlStatsStore({ dir: statsLocation(resolveConfigRunner(config)?.stats) ?? statsLocation(setupConfig.runner?.stats) ?? getStatsDir(io.env) }).query({
+			by: dimension,
+			cwd: options.here === true ? io.cwd : options.cwd,
+			since: options.since
+		});
+		io.stdout.write(options.json === true ? `${JSON.stringify(aggregate, null, 2)}\n` : formatStatsAggregate(aggregate, { color: io.stdout.isTTY === true }));
+		return 0;
+	} catch (error) {
+		io.stderr.write(`${errorMessageFrom$1(error) ?? "Failed to read stats."}\n`);
+		return 2;
+	}
+}
+function parseDimension(value) {
+	if (value === void 0) return "model";
+	if (DIMENSIONS.has(value)) return value;
+	throw new Error(`Invalid --by "${value}": use rule, operation, model, or dir.`);
+}
+function statsLocation(stats) {
+	return typeof stats === "object" ? stats.location : void 0;
+}
+//#endregion
 //#region src/cli/commands/index.ts
 const commandTree = [
 	setup,
 	config,
 	output,
+	defineCommand({
+		action: (context, options) => runStatsCommand(options, context.io),
+		description: "Show recorded run stats",
+		name: "stats",
+		options: [
+			{
+				description: "Group by rule, operation, model, or dir",
+				flags: "--by <dimension>"
+			},
+			{
+				description: "Only include runs since this time (e.g. 7d, 24h, 2025-01)",
+				flags: "--since <time>"
+			},
+			{
+				description: "Only include runs from this directory",
+				flags: "--cwd <path>"
+			},
+			{
+				description: "Only include runs from the current directory",
+				flags: "--here"
+			},
+			{
+				description: "Output JSON",
+				flags: "--json"
+			}
+		]
+	}),
 	lint
 ];
 //#endregion
@@ -1549,7 +2090,7 @@ async function executeCli(argv, io) {
 		pendingResult = result;
 		return result;
 	};
-	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("-l, --lang <language>", "Ask model-backed rules to write diagnostics in this language").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.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("-l, --lang <language>", "Ask model-backed rules to write diagnostics in this language").option("--progress", "Show run progress").option("--rule-concurrency <count>", "Number of rules to run concurrently within a file").option("--no-stats", "Do not record run stats for this run").option("--timeout-ms <ms>", "Rule execution timeout in milliseconds").help();
 	registerCommandTree(cli, commandTree, {
 		globalOptions,
 		interceptConsoleOutput,

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-D7cUTZnE.mjs";
+import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-D4YC9Jnb.mjs";
 export { executeCli, formatDiagnostics, formatJson, formatStylish };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -25,8 +25,8 @@
     "pathe": "^2.0.3",
     "table": "^6.9.0",
     "tinyrainbow": "^3.1.0",
-    "@alint-js/core": "0.0.8",
-    "@alint-js/config": "0.0.8"
+    "@alint-js/core": "0.0.10",
+    "@alint-js/config": "0.0.10"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",