@alint-js/cli 0.0.36 → 0.0.37

package/dist/bin/index.mjs

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

package/dist/{cli-Ct9DDkxy.mjs → cli-Dm3rTcjL.mjs}

@@ -16,7 +16,7 @@ import Gitignore from "gitignore-fs";
 import { Minimatch, minimatch } from "minimatch";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
 //#region package.json
-var version = "0.0.36";
+var version = "0.0.37";
 //#endregion
 //#region src/cli/commands/command.ts
 function defineCommand(node) {
@@ -67,13 +67,14 @@ function formatCommandHelp(sections, nodes, argv, rootHelp) {
 		body: commands.map((command) => `  ${command.pattern.padEnd(longestCommand)}  ${command.description}`).join("\n"),
 		title: "Commands"
 	};
+	const optionSection = formatOptionsSection(node.options ?? []);
 	const usageIndex = normalizedSections.findIndex((section) => section.title === "Usage");
-	if (usageIndex === -1) return [commandSection, ...normalizedSections];
-	return [
+	const withCommands = usageIndex === -1 ? [commandSection, ...normalizedSections] : [
 		...normalizedSections.slice(0, usageIndex + 1),
 		commandSection,
 		...normalizedSections.slice(usageIndex + 1)
 	];
+	return optionSection ? [...withCommands, optionSection] : withCommands;
 }
 function formatExamples(examples) {
 	return examples.map((example) => example.split("\n").map((line) => `  ${line}`).join("\n")).join("\n\n");
@@ -193,11 +194,14 @@ function shouldSkipOptionValue(arg) {
 		"--config",
 		"--cwd",
 		"--format",
+		"--interval",
+		"--metric",
 		"--model",
 		"--provider-endpoint",
 		"--provider-header",
 		"--provider-id",
 		"--provider-model",
+		"--rule",
 		"--rule-concurrency",
 		"--since",
 		"--timeout-ms",
@@ -873,7 +877,7 @@ function createRuleGroups(state) {
 }
 function estimateEta(durationMs, terminal, planned) {
 	if (terminal <= 0 || planned <= 0 || durationMs <= 0) return "eta ?";
-	return `eta ~${formatDuration$1(durationMs * (planned - terminal) / terminal)}`;
+	return `eta ~${formatDuration(durationMs * (planned - terminal) / terminal)}`;
 }
 function fitRow(row, columns) {
 	if (columns <= 0) return "";
@@ -927,7 +931,7 @@ function formatContentRows(groups, state, options, now, contentBudget) {
 	}
 	return rows;
 }
-function formatDuration$1(ms) {
+function formatDuration(ms) {
 	return `${(Math.max(ms, 0) / 1e3).toFixed(1)}s`;
 }
 function formatFooters(state, options, now) {
@@ -937,7 +941,7 @@ function formatFooters(state, options, now) {
 	const eta = estimateEta(elapsed, terminal, state.execution.planned);
 	const projectedTokens = terminal > 0 && state.execution.planned > 0 ? Math.ceil((state.totalTokens + state.cachedTokens) * state.execution.planned / terminal) : void 0;
 	return [
-		fitRow(`${terminal}/${state.execution.planned}${progressBar} ${formatDuration$1(elapsed)} -> ${eta === "eta ?" ? "~?" : eta.replace("eta ", "")}`, options.columns),
+		fitRow(`${terminal}/${state.execution.planned}${progressBar} ${formatDuration(elapsed)} -> ${eta === "eta ?" ? "~?" : eta.replace("eta ", "")}`, options.columns),
 		fitRow(`${state.execution.running} concurrency / ${state.execution.queued} queued / ${state.execution.cached} cached / ${state.execution.failed} failed`, options.columns),
 		fitRow(`${state.totalTokens.toLocaleString("en-US")} tokens (${state.cachedTokens.toLocaleString("en-US")} cached) -> ${projectedTokens === void 0 ? "~?" : `~${projectedTokens.toLocaleString("en-US")} tokens`}`, options.columns)
 	];
@@ -965,7 +969,7 @@ function formatTargetRow(jobState, options, now, last) {
 	const inputPath = options.cwd ? relative$1(options.cwd, jobState.job.inputPath) || "." : jobState.job.inputPath;
 	const target = jobState.job.target.name ? `${jobState.job.target.kind} ${jobState.job.target.name}` : jobState.job.target.kind;
 	const startedAt = jobState.retry?.startedAt ?? jobState.startedAt ?? now;
-	return fitRow(`${last ? "   └─" : "   ├─"} ${inputPath} > ${target} ${jobState.retry ? `${jobState.retry.attempt}/${jobState.retry.maxAttempts} retrying elapsed ${formatDuration$1(now - startedAt)}` : `running ${formatDuration$1(now - startedAt)}`}`, options.columns);
+	return fitRow(`${last ? "   └─" : "   ├─"} ${inputPath} > ${target} ${jobState.retry ? `${jobState.retry.attempt}/${jobState.retry.maxAttempts} retrying elapsed ${formatDuration(now - startedAt)}` : `running ${formatDuration(now - startedAt)}`}`, options.columns);
 }
 function styleRow(row, state, warnCount, errorCount, options) {
 	let styledRow = row;
@@ -1386,20 +1390,29 @@ function isCi(env = process.env) {
 //#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.
+* - `Nh`/`Nd`/`Nw`/`Nm`/`Ny` — now minus N hours/days/weeks/months/years.
+*   Weeks, months, and years are fixed approximations (7/30/365 days). `m` is
+*   months here, not minutes — a day is the finest window this tool tracks.
+* - `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.
+* - An unrecognized time throws.
 */
+const HOUR_MS = 36e5;
+const UNIT_MS = {
+	d: 24 * HOUR_MS,
+	h: HOUR_MS,
+	m: 720 * HOUR_MS,
+	w: 168 * HOUR_MS,
+	y: 365 * 24 * HOUR_MS
+};
 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 relative = /^(\d+)([dhmwy])$/u.exec(time);
+	if (relative) return now - Number(relative[1]) * UNIT_MS[relative[2]];
 	const calendar = /^(\d{4})-(\d{2})(?:-(\d{2}))?$/u.exec(time);
 	if (calendar) {
 		const year = Number(calendar[1]);
@@ -1407,16 +1420,32 @@ function parseSince(time, now) {
 		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.`);
+	throw new Error(`Invalid --since "${time}": use e.g. 24h, 7d, 2w, 3m, 1y, 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;
+const DAY_MS = 864e5;
+const MONTH_LABELS$1 = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
 function createJsonlStatsStore(options) {
 	const retentionMonths = options.retentionMonths ?? DEFAULT_RETENTION_MONTHS;
 	return {
 		query: (filter) => query(options.dir, filter ?? {}, Date.now),
+		querySeries: (filter) => querySeries(options.dir, filter ?? {}, Date.now),
 		record: (input) => record(options.dir, input, Date.now(), retentionMonths)
 	};
 }
@@ -1435,6 +1464,44 @@ function accumulate(rows, key, inTok, outTok, totalTok, countRun) {
 	rows.set(key, row);
 	return row;
 }
+function bucketLabel(startMs, interval) {
+	const date = new Date(startMs);
+	if (interval === "month") return MONTH_LABELS$1[date.getUTCMonth()];
+	return `${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+}
+function bucketStart(ts, interval) {
+	const date = new Date(ts);
+	if (interval === "month") return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+	const dayStart = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+	if (interval === "week") return dayStart - (new Date(dayStart).getUTCDay() + 6) % 7 * DAY_MS;
+	return dayStart;
+}
+function chooseInterval(since, nowMs, timestamps) {
+	if (since !== void 0) return intervalForDuration(nowMs - since);
+	if (timestamps.length < 2) return "day";
+	return intervalForDuration(Math.max(...timestamps) - Math.min(...timestamps));
+}
+function fillBuckets(buckets, interval) {
+	if (buckets.size === 0) return [];
+	const starts = [...buckets.keys()].sort((left, right) => left - right);
+	const last = starts.at(-1);
+	const filled = [];
+	for (let startMs = starts[0]; startMs <= last; startMs = nextBucketStart(startMs, interval)) filled.push(buckets.get(startMs) ?? {
+		inTok: 0,
+		key: bucketLabel(startMs, interval),
+		outTok: 0,
+		runs: 0,
+		startMs,
+		totalTok: 0
+	});
+	return filled;
+}
+function intervalForDuration(ms) {
+	const days = ms / DAY_MS;
+	if (days <= 21) return "day";
+	if (days <= 120) return "week";
+	return "month";
+}
 function isEnoent(error) {
 	return error instanceof Error && error.code === "ENOENT";
 }
@@ -1442,6 +1509,13 @@ function monthIndexOf(ts) {
 	const date = new Date(ts);
 	return date.getUTCFullYear() * 12 + date.getUTCMonth();
 }
+function nextBucketStart(startMs, interval) {
+	if (interval === "month") {
+		const date = new Date(startMs);
+		return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
+	}
+	return startMs + (interval === "week" ? 7 * DAY_MS : DAY_MS);
+}
 function parseRunLine(line) {
 	try {
 		const value = JSON.parse(line);
@@ -1460,42 +1534,84 @@ async function prune(dir, ts, retentionMonths) {
 async function query(dir, filter, now) {
 	const dimension = filter.by ?? "model";
 	const since = parseSince(filter.since, now());
+	const rules = ruleSet(filter.rules);
 	const runs = await readRuns(dir);
 	const rows = /* @__PURE__ */ new Map();
 	let totalRuns = 0;
 	let totalIn = 0;
 	let totalOut = 0;
 	let totalTok = 0;
-	let totalDuration;
 	for (const run of runs) {
-		if (since !== void 0 && run.ts < since) continue;
-		if (filter.cwd !== void 0 && run.cwd !== filter.cwd) continue;
+		if (!runInWindow(run, since, filter.cwd)) continue;
+		const slice = sliceRun(run, rules);
+		if (!slice.touched) continue;
 		totalRuns += 1;
-		totalIn += run.usage.inTok;
-		totalOut += run.usage.outTok;
-		totalTok += run.usage.totalTok;
+		totalIn += slice.inTok;
+		totalOut += slice.outTok;
+		totalTok += slice.totalTok;
 		if (dimension === "dir") {
-			accumulate(rows, run.cwd, run.usage.inTok, run.usage.outTok, run.usage.totalTok, true);
+			accumulate(rows, run.cwd, slice.inTok, slice.outTok, slice.totalTok, true);
 			continue;
 		}
 		const seenKeys = /* @__PURE__ */ new Set();
-		for (const usageRecord of run.usage.records) {
+		for (const usageRecord of slice.usageRecords) {
 			const key = recordKey(usageRecord, dimension);
 			accumulate(rows, key, usageRecord.inTok, usageRecord.outTok, usageRecord.totalTok, !seenKeys.has(key));
 			seenKeys.add(key);
 		}
-		if (dimension !== "rule") continue;
-		for (const { durationMs, ruleId } of run.ruleDurations ?? []) {
-			const row = accumulate(rows, ruleId, 0, 0, 0, !seenKeys.has(ruleId));
-			seenKeys.add(ruleId);
-			row.durationMs = (row.durationMs ?? 0) + durationMs;
-			totalDuration = (totalDuration ?? 0) + durationMs;
-		}
 	}
 	return {
 		dimension,
 		rows: [...rows.values()].sort((left, right) => right.totalTok - left.totalTok),
-		totalDuration,
+		totalIn,
+		totalOut,
+		totalRuns,
+		totalTok
+	};
+}
+async function querySeries(dir, filter, now) {
+	const nowMs = now();
+	const since = parseSince(filter.since, nowMs);
+	const rules = ruleSet(filter.rules);
+	const runs = await readRuns(dir);
+	const sliced = [];
+	for (const run of runs) {
+		if (!runInWindow(run, since, filter.cwd)) continue;
+		const slice = sliceRun(run, rules);
+		if (slice.touched) sliced.push({
+			slice,
+			ts: run.ts
+		});
+	}
+	const interval = filter.interval ?? chooseInterval(since, nowMs, sliced.map((entry) => entry.ts));
+	const buckets = /* @__PURE__ */ new Map();
+	let totalRuns = 0;
+	let totalIn = 0;
+	let totalOut = 0;
+	let totalTok = 0;
+	for (const { slice, ts } of sliced) {
+		const startMs = bucketStart(ts, interval);
+		const bucket = buckets.get(startMs) ?? {
+			inTok: 0,
+			key: bucketLabel(startMs, interval),
+			outTok: 0,
+			runs: 0,
+			startMs,
+			totalTok: 0
+		};
+		bucket.runs += 1;
+		bucket.inTok += slice.inTok;
+		bucket.outTok += slice.outTok;
+		bucket.totalTok += slice.totalTok;
+		buckets.set(startMs, bucket);
+		totalRuns += 1;
+		totalIn += slice.inTok;
+		totalOut += slice.outTok;
+		totalTok += slice.totalTok;
+	}
+	return {
+		buckets: fillBuckets(buckets, interval),
+		interval,
 		totalIn,
 		totalOut,
 		totalRuns,
@@ -1529,6 +1645,29 @@ function recordKey(record, dimension) {
 	if (dimension === "operation") return record.operation ?? record.ruleId;
 	return `${record.providerId}/${record.modelId}`;
 }
+function ruleSet(rules) {
+	return rules && rules.length > 0 ? new Set(rules) : void 0;
+}
+function runInWindow(run, since, cwd) {
+	return (since === void 0 || run.ts >= since) && (cwd === void 0 || run.cwd === cwd);
+}
+function sliceRun(run, rules) {
+	if (rules === void 0) return {
+		inTok: run.usage.inTok,
+		outTok: run.usage.outTok,
+		totalTok: run.usage.totalTok,
+		touched: true,
+		usageRecords: run.usage.records
+	};
+	const usageRecords = run.usage.records.filter((record) => rules.has(record.ruleId));
+	return {
+		inTok: sumBy(usageRecords, (record) => record.inTok),
+		outTok: sumBy(usageRecords, (record) => record.outTok),
+		totalTok: sumBy(usageRecords, (record) => record.totalTok),
+		touched: usageRecords.length > 0,
+		usageRecords
+	};
+}
 function statsFileName(ts) {
 	const date = new Date(ts);
 	return `stats-${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}.jsonl`;
@@ -1549,6 +1688,11 @@ async function statsFiles(dir) {
 		} : void 0;
 	}).filter((entry) => entry !== void 0).sort((left, right) => left.month - right.month);
 }
+function sumBy(items, select) {
+	let total = 0;
+	for (const item of items) total += select(item);
+	return total;
+}
 //#endregion
 //#region src/cli/stats/record.ts
 function createRunStat(input) {
@@ -1556,7 +1700,6 @@ function createRunStat(input) {
 		cwd: input.cwd,
 		durationMs: input.durationMs,
 		ruleCounts: input.ruleCounts,
-		ruleDurations: input.ruleDurations,
 		usage: {
 			inTok: input.usage.inputTokens,
 			outTok: input.usage.outputTokens,
@@ -1594,16 +1737,10 @@ function createStatsCollector() {
 	};
 	let startedAt;
 	let endedAt;
-	const ruleMs = /* @__PURE__ */ new Map();
 	return {
 		counts,
 		durationMs: () => startedAt !== void 0 && endedAt !== void 0 ? endedAt - startedAt : void 0,
 		reporter: {
-			onJobEnd: (payload) => {
-				if (payload.startedAt === void 0 || payload.endedAt === void 0) return;
-				const elapsed = Math.max(payload.endedAt - payload.startedAt, 0);
-				ruleMs.set(payload.job.ruleId, (ruleMs.get(payload.job.ruleId) ?? 0) + elapsed);
-			},
 			onRunEnd: (payload) => {
 				counts.cached = payload.execution.cached;
 				counts.cancelled = payload.execution.cancelled;
@@ -1615,11 +1752,7 @@ function createStatsCollector() {
 			onRunStart: (payload) => {
 				startedAt = payload.startedAt;
 			}
-		},
-		ruleDurations: () => ruleMs.size === 0 ? void 0 : [...ruleMs].map(([ruleId, durationMs]) => ({
-			durationMs,
-			ruleId
-		}))
+		}
 	};
 }
 function mergeProgressReporters(base, extra) {
@@ -1700,7 +1833,6 @@ async function writeRunStats(target, collector, result, cwd) {
 				failed: result.execution.failed,
 				planned: result.execution.planned
 			},
-			ruleDurations: collector.ruleDurations(),
 			usage: result.usage
 		}));
 	} catch {}
@@ -2354,25 +2486,21 @@ const DIMENSION_LABEL = {
 	operation: "operation",
 	rule: "rule"
 };
-const METRIC_LABEL = {
-	duration: "time",
-	runs: "runs",
-	tokens: "total"
-};
-function formatMetric(row, metric) {
-	if (metric === "runs") return String(row.runs);
-	if (metric === "duration") return formatDuration(row.durationMs);
-	return formatTokens(row.totalTok);
+function formatMetric(row, metric, exact = false) {
+	return formatMetricValue(metricValue(row, metric), metric, exact);
+}
+function formatMetricValue(value, metric, exact = false) {
+	return metric === "runs" ? String(value) : formatTokens(value, exact);
 }
 function formatStatsAggregate(aggregate, options = {}) {
 	const paint = (text, style) => options.color === true ? style(text) : text;
 	const metric = options.metric ?? "tokens";
-	const lines = [summaryLine(aggregate, paint), ""];
+	const exact = options.exact === true;
+	const lines = [summaryLine(aggregate, paint, exact), ""];
 	if (aggregate.rows.length === 0) {
 		lines.push("No stats recorded yet.");
 		return `${lines.join("\n")}\n`;
 	}
-	const withTime = aggregate.dimension === "rule";
 	const header = [
 		DIMENSION_LABEL[aggregate.dimension],
 		"runs",
@@ -2380,18 +2508,13 @@ function formatStatsAggregate(aggregate, options = {}) {
 		"output",
 		"total"
 	];
-	if (withTime) header.push("time");
-	const rows = sortRows(aggregate.rows, metric).map((row) => {
-		const cells = [
-			row.key,
-			String(row.runs),
-			formatTokens(row.inTok),
-			formatTokens(row.outTok),
-			formatTokens(row.totalTok)
-		];
-		if (withTime) cells.push(formatDuration(row.durationMs));
-		return cells;
-	});
+	const rows = sortRows(aggregate.rows, metric).map((row) => [
+		row.key,
+		String(row.runs),
+		formatTokens(row.inTok, exact),
+		formatTokens(row.outTok, exact),
+		formatTokens(row.totalTok, exact)
+	]);
 	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]);
@@ -2400,30 +2523,39 @@ function formatStatsAggregate(aggregate, options = {}) {
 	lines.push(renderRow(header, true), ...rows.map((row) => renderRow(row, false)));
 	return `${lines.join("\n")}\n`;
 }
-function formatTokens(value) {
-	return value.toLocaleString("en-US");
+function formatTokens(value, exact = false) {
+	if (exact || value < 1e4) return value.toLocaleString("en-US");
+	if (value >= 1e9) return `${(value / 1e9).toFixed(2)}B`;
+	if (value >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
+	return `${(value / 1e3).toFixed(2)}k`;
 }
 function metricValue(row, metric) {
-	if (metric === "runs") return row.runs;
-	if (metric === "duration") return row.durationMs ?? 0;
-	return row.totalTok;
+	return metric === "runs" ? row.runs : row.totalTok;
 }
 function sortRows(rows, metric) {
 	return [...rows].sort((left, right) => metricValue(right, metric) - metricValue(left, metric));
 }
-function summaryLine(aggregate, paint) {
-	const runLabel = aggregate.totalRuns === 1 ? "run" : "runs";
-	const time = aggregate.totalDuration === void 0 ? "" : ` / ${formatDuration(aggregate.totalDuration)} time`;
-	return `${aggregate.totalRuns} ${runLabel} — ${formatTokens(aggregate.totalIn)} in / ${formatTokens(aggregate.totalOut)} out / ${paint(`${formatTokens(aggregate.totalTok)} total`, colors.cyan)}${time}`;
-}
-function formatDuration(ms) {
-	return ms === void 0 ? "—" : `${(Math.max(ms, 0) / 1e3).toFixed(1)}s`;
+function summaryLine(totals, paint, exact = false) {
+	const runLabel = totals.totalRuns === 1 ? "run" : "runs";
+	return `${totals.totalRuns} ${runLabel} — ${formatTokens(totals.totalIn, exact)} in / ${formatTokens(totals.totalOut, exact)} out / ${paint(`${formatTokens(totals.totalTok, exact)} total`, colors.cyan)}`;
 }
 //#endregion
-//#region src/cli/commands/stats/chart.ts
-const BAR_WIDTH = 32;
-const FULL_BLOCK = "█";
-const PARTIAL_BLOCKS = [
+//#region src/cli/commands/stats/timeline.ts
+const CHART_HEIGHT = 6;
+const BAR_GAP = 2;
+const COLUMN_STRIDE = 3;
+const VERTICAL_BLOCKS = [
+	" ",
+	"▁",
+	"▂",
+	"▃",
+	"▄",
+	"▅",
+	"▆",
+	"▇",
+	"█"
+];
+const HORIZONTAL_BLOCKS = [
 	"",
 	"▏",
 	"▎",
@@ -2433,36 +2565,143 @@ const PARTIAL_BLOCKS = [
 	"▊",
 	"▉"
 ];
-function formatStatsChart(aggregate, options = {}) {
+const FULL_BLOCK = "█";
+const HORIZONTAL_BAR_MIN = 8;
+const HORIZONTAL_BAR_MAX = 40;
+const SUMMARY_GAP = 3;
+const SUMMARY_MAX_COLUMNS = 4;
+const MONTH_LABELS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+function formatStatsTimeline(series, options = {}) {
 	const paint = (text, style) => options.color === true ? style(text) : text;
 	const metric = options.metric ?? "tokens";
-	const lines = [summaryLine(aggregate, paint), ""];
-	if (aggregate.rows.length === 0) {
+	const exact = options.exact === true;
+	const ctx = {
+		exact,
+		interval: series.interval,
+		metric,
+		paint
+	};
+	const lines = [
+		summaryLine(series, paint, exact),
+		"",
+		caption(series, metric, options.rules)
+	];
+	if (series.buckets.length === 0) {
 		lines.push("No stats recorded yet.");
 		return `${lines.join("\n")}\n`;
 	}
-	const rows = sortRows(aggregate.rows, metric);
-	const maxValue = Math.max(...rows.map((row) => metricValue(row, metric)));
-	const columnTotal = rows.reduce((sum, row) => sum + metricValue(row, metric), 0);
-	const label = DIMENSION_LABEL[aggregate.dimension];
-	const valueLabel = METRIC_LABEL[metric];
-	const keyWidth = Math.max(label.length, ...rows.map((row) => row.key.length));
-	const values = rows.map((row) => formatMetric(row, metric));
-	const valueWidth = Math.max(valueLabel.length, ...values.map((value) => value.length));
-	lines.push(paint(`${label.padEnd(keyWidth)}  ${" ".repeat(BAR_WIDTH)}  ${valueLabel.padStart(valueWidth)}  share`, colors.bold));
-	rows.forEach((row, index) => {
-		const value = metricValue(row, metric);
-		const bar = renderBar(maxValue === 0 ? 0 : value / maxValue);
-		const share = columnTotal === 0 ? 0 : value / columnTotal * 100;
-		lines.push(`${row.key.padEnd(keyWidth)}  ${paint(bar, colors.cyan)}  ${values[index].padStart(valueWidth)}  ${share.toFixed(1).padStart(5)}%`);
+	const values = series.buckets.map((bucket) => metricValue(bucket, metric));
+	const maxValue = Math.max(...values);
+	const axisWidth = Math.max(formatMetricValue(maxValue, metric, exact).length, 1);
+	const verticalWidth = axisWidth + 2 + series.buckets.length * COLUMN_STRIDE;
+	const width = options.columns ?? 80;
+	if (options.vertical === true && verticalWidth <= width) {
+		const chart = renderVertical(series.buckets, values, maxValue, axisWidth, ctx);
+		const list = summaryList(series.buckets, width, ctx);
+		return `${[
+			...lines,
+			...chart,
+			"",
+			...list
+		].join("\n")}\n`;
+	}
+	return `${[...lines, ...renderHorizontal(series.buckets, values, maxValue, width, ctx)].join("\n")}\n`;
+}
+function axisRows(buckets, interval, chartWidth) {
+	if (interval === "month") return [endpointAxis(buckets, chartWidth)];
+	const days = Array.from({ length: chartWidth + 4 }).fill(" ");
+	const months = Array.from({ length: chartWidth + 4 }).fill(" ");
+	buckets.forEach((bucket, index) => {
+		const date = new Date(bucket.startMs);
+		const at = BAR_GAP + index * COLUMN_STRIDE;
+		const previous = index === 0 ? void 0 : new Date(buckets[index - 1].startMs);
+		writeAt(days, at, String(date.getUTCDate()).padStart(2, "0"));
+		if (startsNewMonth(previous, date)) writeAt(months, at, MONTH_LABELS[date.getUTCMonth()]);
+	});
+	return [days.join("").replace(/\s+$/u, ""), months.join("").replace(/\s+$/u, "")];
+}
+function caption(series, metric, rules) {
+	const filter = rules && rules.length > 0 ? ` — ${rules.join(", ")}` : "";
+	return `${metric} by ${series.interval}${filter}`;
+}
+function endpointAxis(buckets, chartWidth) {
+	const first = buckets[0].key;
+	if (buckets.length === 1) return `${" ".repeat(BAR_GAP)}${first}`;
+	const last = buckets.at(-1).key;
+	const lastStart = chartWidth - last.length;
+	const firstEnd = BAR_GAP + first.length;
+	return lastStart > firstEnd ? `${" ".repeat(BAR_GAP)}${first}${" ".repeat(lastStart - firstEnd)}${last}` : `${" ".repeat(BAR_GAP)}${first} … ${last}`;
+}
+function renderHorizontal(buckets, values, maxValue, width, ctx) {
+	const labels = buckets.map((bucket) => formatMetric(bucket, ctx.metric, ctx.exact));
+	const keyWidth = Math.max(...buckets.map((bucket) => bucket.key.length));
+	const valueWidth = Math.max(...labels.map((label) => label.length));
+	const barWidth = Math.max(HORIZONTAL_BAR_MIN, Math.min(HORIZONTAL_BAR_MAX, width - keyWidth - valueWidth - 6));
+	return buckets.map((bucket, index) => {
+		const bar = renderHorizontalBar(maxValue === 0 ? 0 : values[index] / maxValue, barWidth);
+		return `${bucket.key.padEnd(keyWidth)}  ${ctx.paint(bar, colors.cyan)}  ${labels[index].padStart(valueWidth)}`;
 	});
-	return `${lines.join("\n")}\n`;
 }
-function renderBar(fraction) {
-	const eighths = fraction <= 0 ? 0 : Math.max(1, Math.round(fraction * BAR_WIDTH * 8));
+function renderHorizontalBar(fraction, width) {
+	const eighths = fraction <= 0 ? 0 : Math.max(1, Math.round(fraction * width * 8));
 	const full = Math.floor(eighths / 8);
-	const remainder = eighths % 8;
-	return `${FULL_BLOCK.repeat(full)}${PARTIAL_BLOCKS[remainder]}`.padEnd(BAR_WIDTH);
+	return `${FULL_BLOCK.repeat(full)}${HORIZONTAL_BLOCKS[eighths % 8]}`.padEnd(width);
+}
+function renderVertical(buckets, values, maxValue, axisWidth, ctx) {
+	const columnAt = (index) => BAR_GAP + index * COLUMN_STRIDE;
+	const chartWidth = columnAt(buckets.length - 1) + 1;
+	const eighths = values.map((value) => {
+		if (value <= 0 || maxValue === 0) return 0;
+		return Math.max(1, Math.round(value / maxValue * CHART_HEIGHT * 8));
+	});
+	const gutter = " ".repeat(axisWidth);
+	const lines = [];
+	for (let row = CHART_HEIGHT - 1; row >= 0; row -= 1) {
+		const cells = Array.from({ length: chartWidth }).fill(" ");
+		eighths.forEach((total, index) => {
+			cells[columnAt(index)] = VERTICAL_BLOCKS[Math.max(0, Math.min(8, total - row * 8))];
+		});
+		const label = row === CHART_HEIGHT - 1 ? formatMetricValue(maxValue, ctx.metric, ctx.exact).padStart(axisWidth) : gutter;
+		const axis = row === CHART_HEIGHT - 1 ? "┤" : "│";
+		lines.push(`${label} ${axis}${ctx.paint(cells.join("").replace(/\s+$/u, ""), colors.cyan)}`);
+	}
+	const baseline = Array.from({ length: chartWidth }).fill("─");
+	buckets.forEach((_, index) => {
+		baseline[columnAt(index)] = "┴";
+	});
+	lines.push(`${"0".padStart(axisWidth)} ┼${baseline.join("")}`);
+	for (const labelRow of axisRows(buckets, ctx.interval, chartWidth)) lines.push(`${gutter}  ${labelRow}`);
+	return lines;
+}
+function startsNewMonth(previous, date) {
+	if (previous === void 0) return true;
+	return previous.getUTCFullYear() !== date.getUTCFullYear() || previous.getUTCMonth() !== date.getUTCMonth();
+}
+function summaryList(buckets, width, ctx) {
+	const labels = buckets.map((bucket) => formatMetric(bucket, ctx.metric, ctx.exact));
+	const keyWidth = Math.max(...buckets.map((bucket) => bucket.key.length));
+	const valueWidth = Math.max(...labels.map((label) => label.length));
+	const cellWidth = keyWidth + 2 + valueWidth;
+	const perRow = Math.max(1, Math.min(SUMMARY_MAX_COLUMNS, Math.floor((width + SUMMARY_GAP) / (cellWidth + SUMMARY_GAP))));
+	const rows = [];
+	for (let start = 0; start < buckets.length; start += perRow) rows.push(buckets.slice(start, start + perRow).map((bucket, offset) => `${bucket.key.padEnd(keyWidth)}  ${labels[start + offset].padStart(valueWidth)}`).join(" ".repeat(SUMMARY_GAP)));
+	return rows;
+}
+function writeAt(cells, at, text) {
+	for (let index = 0; index < text.length && at + index < cells.length; index += 1) cells[at + index] = text[index];
 }
 //#endregion
 //#region src/cli/commands/stats/stats.ts
@@ -2472,23 +2711,48 @@ const DIMENSIONS = /* @__PURE__ */ new Set([
 	"operation",
 	"rule"
 ]);
-const METRICS = /* @__PURE__ */ new Set([
-	"duration",
-	"runs",
-	"tokens"
+const METRICS = /* @__PURE__ */ new Set(["runs", "tokens"]);
+const INTERVALS = /* @__PURE__ */ new Set([
+	"day",
+	"month",
+	"week"
 ]);
 async function runStatsCommand(options, io) {
 	try {
-		const dimension = parseDimension(options.by);
 		const metric = parseMetric(options.metric);
-		if (metric === "duration" && dimension !== "rule") throw new Error("The duration metric is only available with --by rule.");
-		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,
+		const rules = parseRules(options.rule);
+		const cwd = options.here === true ? io.cwd : options.cwd;
+		const color = io.stdout.isTTY === true;
+		const exact = options.exactNumbers === true;
+		const store = await resolveStore(io);
+		if (options.chart === true) {
+			const series = await store.querySeries({
+				cwd,
+				interval: parseInterval(options.interval),
+				rules,
+				since: options.since
+			});
+			io.stdout.write(options.json === true ? `${JSON.stringify(series, null, 2)}\n` : formatStatsTimeline(series, {
+				color,
+				columns: io.stdout.columns,
+				exact,
+				metric,
+				rules,
+				vertical: options.vertical === true
+			}));
+			return 0;
+		}
+		const aggregate = await store.query({
+			by: parseDimension(options.by),
+			cwd,
+			rules,
 			since: options.since
 		});
-		io.stdout.write(render(aggregate, options, metric, io.stdout.isTTY === true));
+		io.stdout.write(options.json === true ? `${JSON.stringify(aggregate, null, 2)}\n` : formatStatsAggregate(aggregate, {
+			color,
+			exact,
+			metric
+		}));
 		return 0;
 	} catch (error) {
 		io.stderr.write(`${errorMessageFrom$1(error) ?? "Failed to read stats."}\n`);
@@ -2500,21 +2764,24 @@ function parseDimension(value) {
 	if (DIMENSIONS.has(value)) return value;
 	throw new Error(`Invalid --by "${value}": use rule, operation, model, or dir.`);
 }
+function parseInterval(value) {
+	if (value === void 0) return;
+	if (INTERVALS.has(value)) return value;
+	throw new Error(`Invalid --interval "${value}": use day, week, or month.`);
+}
 function parseMetric(value) {
 	if (value === void 0) return "tokens";
 	if (METRICS.has(value)) return value;
-	throw new Error(`Invalid --metric "${value}": use tokens, runs, or duration.`);
+	throw new Error(`Invalid --metric "${value}": use tokens or runs.`);
 }
-function render(aggregate, options, metric, color) {
-	if (options.json === true) return `${JSON.stringify(aggregate, null, 2)}\n`;
-	if (options.chart === true) return formatStatsChart(aggregate, {
-		color,
-		metric
-	});
-	return formatStatsAggregate(aggregate, {
-		color,
-		metric
-	});
+function parseRules(value) {
+	if (value === void 0) return;
+	const rules = value.split(",").map((rule) => rule.trim()).filter(Boolean);
+	return rules.length > 0 ? rules : void 0;
+}
+async function resolveStore(io) {
+	const [setupConfig, config] = await Promise.all([loadMergedSetupConfig(io), loadAlintConfig(io.cwd)]);
+	return createJsonlStatsStore({ dir: statsLocation(resolveConfigRunner(config)?.stats) ?? statsLocation(setupConfig.runner?.stats) ?? getStatsDir(io.env) });
 }
 function statsLocation(stats) {
 	return typeof stats === "object" ? stats.location : void 0;
@@ -2532,11 +2799,31 @@ const commandTree = [
 		name: "stats",
 		options: [
 			{
-				description: "Group by rule, operation, model, or dir",
+				description: "Render a usage timeline instead of the table",
+				flags: "--chart"
+			},
+			{
+				description: "Group the table by rule, operation, model, or dir",
 				flags: "--by <dimension>"
 			},
 			{
-				description: "Only include runs since this time (e.g. 7d, 24h, 2025-01)",
+				description: "Chart bucket: day, week, or month (default: auto)",
+				flags: "--interval <interval>"
+			},
+			{
+				description: "Draw the chart as vertical bars instead of horizontal",
+				flags: "--vertical"
+			},
+			{
+				description: "Rank/plot by tokens or runs",
+				flags: "--metric <metric>"
+			},
+			{
+				description: "Only include these rules (comma-separated)",
+				flags: "--rule <ids>"
+			},
+			{
+				description: "Only include runs since this time (e.g. 24h, 7d, 4w, 3m, 2025-01)",
 				flags: "--since <time>"
 			},
 			{
@@ -2548,12 +2835,8 @@ const commandTree = [
 				flags: "--here"
 			},
 			{
-				description: "Render grouped rows as a bar chart",
-				flags: "--chart"
-			},
-			{
-				description: "Rank by tokens, runs, or duration (duration needs --by rule)",
-				flags: "--metric <metric>"
+				description: "Show full counts instead of compact k/M/B",
+				flags: "--exact-numbers"
 			},
 			{
 				description: "Output JSON",

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-Ct9DDkxy.mjs";
+import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-Dm3rTcjL.mjs";
 import { ignorePatternsAIAgents, ignorePatternsBuildOutputs, ignorePatternsCaches, ignorePatternsCommon, ignorePatternsEslintDefaults, ignorePatternsGenerated } from "@alint-js/config";
 import { defineConfig } from "@alint-js/core";
 export { defineConfig, executeCli, formatDiagnostics, formatJson, formatStylish, ignorePatternsAIAgents, ignorePatternsBuildOutputs, ignorePatternsCaches, ignorePatternsCommon, ignorePatternsEslintDefaults, ignorePatternsGenerated };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -27,8 +27,8 @@
     "pathe": "^2.0.3",
     "table": "^6.9.0",
     "tinyrainbow": "^3.1.0",
-    "@alint-js/core": "0.0.36",
-    "@alint-js/config": "0.0.36"
+    "@alint-js/config": "0.0.37",
+    "@alint-js/core": "0.0.37"
   },
   "devDependencies": {
     "@pnpm/find-workspace-dir": "^1000.1.5",