@alint-js/cli 0.0.35 → 0.0.37

package/dist/bin/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as executeCli } from "../cli-CZbrV2gX.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-CZbrV2gX.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.35";
+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",
@@ -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)
 	};
 }
@@ -1433,6 +1462,45 @@ function accumulate(rows, key, inTok, outTok, totalTok, countRun) {
 	row.totalTok += totalTok;
 	if (countRun) row.runs += 1;
 	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";
@@ -1441,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);
@@ -1459,6 +1534,7 @@ 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;
@@ -1466,18 +1542,19 @@ async function query(dir, filter, now) {
 	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;
+		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);
@@ -1492,6 +1569,55 @@ async function query(dir, filter, now) {
 		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,
+		totalTok
+	};
+}
 async function readRuns(dir) {
 	const files = await statsFiles(dir);
 	const runs = [];
@@ -1519,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`;
@@ -1539,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) {
@@ -2332,10 +2486,17 @@ const DIMENSION_LABEL = {
 	operation: "operation",
 	rule: "rule"
 };
+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 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)}`, ""];
+	const metric = options.metric ?? "tokens";
+	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`;
@@ -2347,12 +2508,12 @@ function formatStatsAggregate(aggregate, options = {}) {
 		"output",
 		"total"
 	];
-	const rows = aggregate.rows.map((row) => [
+	const rows = sortRows(aggregate.rows, metric).map((row) => [
 		row.key,
 		String(row.runs),
-		formatTokens(row.inTok),
-		formatTokens(row.outTok),
-		formatTokens(row.totalTok)
+		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) => {
@@ -2362,14 +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) {
+	return metric === "runs" ? row.runs : row.totalTok;
+}
+function sortRows(rows, metric) {
+	return [...rows].sort((left, right) => metricValue(right, metric) - metricValue(left, metric));
+}
+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 = [
 	"",
 	"▏",
 	"▎",
@@ -2379,32 +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 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) {
+	const metric = options.metric ?? "tokens";
+	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 maxTok = Math.max(...aggregate.rows.map((row) => row.totalTok));
-	const label = DIMENSION_LABEL[aggregate.dimension];
-	const keyWidth = Math.max(label.length, ...aggregate.rows.map((row) => row.key.length));
-	const values = aggregate.rows.map((row) => formatTokens(row.totalTok));
-	const valueWidth = Math.max(5, ...values.map((value) => value.length));
-	lines.push(paint(`${label.padEnd(keyWidth)}  ${" ".repeat(BAR_WIDTH)}  ${"total".padStart(valueWidth)}  share`, colors.bold));
-	aggregate.rows.forEach((row, index) => {
-		const bar = renderBar(maxTok === 0 ? 0 : row.totalTok / maxTok);
-		const share = aggregate.totalTok === 0 ? 0 : row.totalTok / aggregate.totalTok * 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
@@ -2414,16 +2711,48 @@ const DIMENSIONS = /* @__PURE__ */ new Set([
 	"operation",
 	"rule"
 ]);
+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 [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 metric = parseMetric(options.metric);
+		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, 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`);
@@ -2435,10 +2764,24 @@ function parseDimension(value) {
 	if (DIMENSIONS.has(value)) return value;
 	throw new Error(`Invalid --by "${value}": use rule, operation, model, or dir.`);
 }
-function render(aggregate, options, color) {
-	if (options.json === true) return `${JSON.stringify(aggregate, null, 2)}\n`;
-	if (options.chart === true) return formatStatsChart(aggregate, { color });
-	return formatStatsAggregate(aggregate, { color });
+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 or runs.`);
+}
+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;
@@ -2456,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>"
 			},
 			{
@@ -2472,8 +2835,8 @@ const commandTree = [
 				flags: "--here"
 			},
 			{
-				description: "Render grouped rows as a bar chart",
-				flags: "--chart"
+				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-CZbrV2gX.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.35",
+  "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.35",
-    "@alint-js/config": "0.0.35"
+    "@alint-js/config": "0.0.37",
+    "@alint-js/core": "0.0.37"
   },
   "devDependencies": {
     "@pnpm/find-workspace-dir": "^1000.1.5",