@gscdump/cli 3.5.0 → 3.6.0

package/dist/render/analysis.mjs

@@ -0,0 +1,98 @@
+import { renderTable, textLines } from "./layout.mjs";
+import { finite, formatMetric, metricLabel } from "./metrics.mjs";
+import { barColumn, calendarBuckets, renderBars, renderShare, renderSparklines } from "./charts.mjs";
+import { parseGscSiteUrl } from "gscdump";
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function rowLabel(row) {
+	const query = row.query ?? row.keyword;
+	const page = row.page ?? row.url;
+	return query != null && page != null ? `${query} (${page})` : String(query ?? page ?? row.country ?? row.device ?? row.month ?? row.date ?? "n/a");
+}
+function columnsFor(rows, keys) {
+	return (keys ?? [...new Set(rows.flatMap((row) => Object.keys(row)))]).filter((key) => rows.some((row) => key in row)).map((key) => ({
+		key,
+		label: metricLabel(key),
+		numeric: rows.some((row) => typeof row[key] === "number"),
+		format: (value) => {
+			if (value == null) return "n/a";
+			if (typeof value === "number") return formatMetric(key, value);
+			if (Array.isArray(value)) return `[${value.length} items]`;
+			if (typeof value === "object") return JSON.stringify(value, (_key, nested) => typeof nested === "bigint" ? nested.toString() : nested);
+			return String(value);
+		}
+	}));
+}
+function renderAnalysis(result, context, options) {
+	const rows = result.results;
+	const meta = result.meta;
+	const start = typeof meta.startDate === "string" ? meta.startDate : context.start;
+	const end = typeof meta.endDate === "string" ? meta.endDate : context.end;
+	const lines = [...textLines(`${parseGscSiteUrl(context.site).hostname} / ${context.id}`, options, "accent"), ...textLines(`${start} to ${end}`, options, "muted")];
+	if (context.previous) lines.push(...textLines(`vs ${context.previous.start} to ${context.previous.end}`, options, "muted"));
+	lines.push("");
+	if (!rows.length) {
+		lines.push(...textLines("No results for this period.", options));
+		return lines.join("\n");
+	}
+	if (context.id === "brand") {
+		const summary = asRecord(meta.summary);
+		lines.push(...textLines("Click share", options), ...renderShare([{
+			label: "Brand",
+			value: finite(summary.brandClicks)
+		}, {
+			label: "Non-brand",
+			value: finite(summary.nonBrandClicks)
+		}], "clicks", options), "");
+	}
+	if (context.id === "trends") {
+		const series = rows.map((row) => ({
+			...row,
+			label: rowLabel(row),
+			total: finite(row.totalClicks),
+			points: (Array.isArray(row.series) ? row.series : []).map((point) => {
+				const value = asRecord(point);
+				return {
+					date: String(value.week),
+					value: finite(value.clicks)
+				};
+			})
+		}));
+		lines.push(...renderSparklines(series, {
+			start,
+			end,
+			unit: "week"
+		}, "clicks", options, columnsFor(rows, ["avgPosition"])));
+	} else if (context.id === "movers") {
+		const displayed = rows.map((row) => ({
+			...row,
+			entity: rowLabel(row)
+		}));
+		lines.push(...renderTable(displayed, [
+			{
+				key: "entity",
+				label: ""
+			},
+			...columnsFor(rows, ["baselineClicks", "recentClicks"]),
+			barColumn(rows, "clicksChange", options, true)
+		], options));
+	} else if (context.id === "seasonality") {
+		const months = calendarBuckets(start, end, "month");
+		const values = new Map(rows.map((row) => [String(row.month), finite(row.value)]));
+		const partial = /* @__PURE__ */ new Set();
+		if (!start.endsWith("-01")) partial.add(start.slice(0, 7));
+		if ((/* @__PURE__ */ new Date(`${end}T00:00:00Z`)).getUTCDate() !== new Date(Date.UTC(Number(end.slice(0, 4)), Number(end.slice(5, 7)), 0)).getUTCDate()) partial.add(end.slice(0, 7));
+		lines.push(...textLines(`Monthly ${context.metric ?? "clicks"}`, options));
+		lines.push(...renderBars(months.map((month) => ({
+			label: `${month}${partial.has(month) ? "*" : ""}`,
+			value: values.get(month) ?? null
+		})), context.metric ?? "clicks", options));
+		if (meta.insufficientData === true || values.size < 12) lines.push(...textLines(`! ${values.size} of 12 months`, options, "warning"));
+		if (months.some((month) => partial.has(month))) lines.push(...textLines("* partial month", options, "muted"));
+	} else lines.push(...renderTable(rows, columnsFor(rows), options));
+	const total = finite(meta.total);
+	if (total !== null && total > rows.length) lines.push("", ...textLines(`${rows.length} of ${formatMetric("clicks", total)} rows`, options, "muted"));
+	return lines.join("\n");
+}
+export { asRecord, columnsFor, renderAnalysis, rowLabel };

package/dist/render/charts.mjs

@@ -0,0 +1,170 @@
+import { contentWidth, fitLabel, pad, paint, renderTable, textLines } from "./layout.mjs";
+import { finite, formatChange, formatMetric, metricLabel, signed } from "./metrics.mjs";
+function barColumn(rows, key, options, diverging = false) {
+	const max = rows.reduce((largest, row) => Math.max(largest, Math.abs(finite(row[key]) ?? 0)), 0);
+	const width = options.columns >= 110 ? 12 : options.columns >= 70 ? 8 : 4;
+	const numberWidth = rows.reduce((largest, row) => {
+		const value = finite(row[key]);
+		return Math.max(largest, (value === null ? "n/a" : diverging ? signed(value) : formatMetric(key, value)).length);
+	}, 0);
+	return {
+		key,
+		label: diverging ? "Change" : metricLabel(key),
+		numeric: true,
+		format: (value) => {
+			const n = finite(value);
+			if (n === null || !diverging && n < 0) return "n/a";
+			const size = max === 0 ? 0 : Math.round(Math.abs(n) / max * width);
+			const fill = (options.unicode ? "█" : "#").repeat(size);
+			return `${diverging ? `${(n < 0 ? fill : "").padStart(width)}${options.unicode ? "│" : "|"}${(n > 0 ? fill : "").padEnd(width)}` : fill.padEnd(width)} ${pad(diverging ? signed(n) : formatMetric(key, n), numberWidth, true)}`;
+		},
+		tone: (value) => diverging ? (finite(value) ?? 0) < 0 ? "bad" : (finite(value) ?? 0) > 0 ? "good" : "neutral" : "accent"
+	};
+}
+function renderBars(rows, metric, options, diverging = false) {
+	if (!rows.length) return textLines("No results for this period.", options);
+	const width = contentWidth(options);
+	const max = rows.reduce((largest, row) => Math.max(largest, Math.abs(finite(row.value) ?? 0)), 0);
+	const barWidth = Math.max(1, Math.min(28, width - 16));
+	const half = Math.max(1, Math.floor(barWidth / 2));
+	const fill = options.unicode ? "█" : "#";
+	const axis = options.unicode ? "│" : "|";
+	const lines = [];
+	for (const row of rows) {
+		const value = finite(row.value);
+		const label = fitLabel(row.label, width >= 64 ? 24 : width, options);
+		const valid = value !== null && (diverging || value >= 0);
+		const number = valid ? diverging ? signed(value) : formatMetric(metric, value) : "n/a";
+		if (width < 30) {
+			lines.push(...textLines(`${row.label}: ${number}`, options));
+			continue;
+		}
+		const size = !valid || max === 0 ? 0 : Math.round(Math.abs(value) / max * (diverging ? half : barWidth));
+		const mark = diverging ? `${paint(value !== null && value < 0 ? fill.repeat(size).padStart(half) : " ".repeat(half), "bad", options)}${axis}${paint(value !== null && value > 0 ? fill.repeat(size).padEnd(half) : " ".repeat(half), "good", options)}` : paint(fill.repeat(size).padEnd(barWidth), "accent", options);
+		if (width >= 76 && number.length <= 16) lines.push(`  ${pad(label, 24)}  ${mark}  ${pad(number, 16, true)}`);
+		else lines.push(...textLines(`${label}  ${number}`, options), `  ${mark}`);
+	}
+	return lines;
+}
+function renderShare(rows, metric, options) {
+	if (rows.some((row) => finite(row.value) === null || row.value < 0)) return textLines("Share unavailable: incomplete values.", options, "warning");
+	const total = rows.reduce((sum, row) => sum + row.value, 0);
+	if (total === 0) return textLines(`No ${metric} in returned rows.`, options);
+	if (!Number.isFinite(total)) return textLines("Share unavailable: total exceeds display range.", options, "warning");
+	const width = Math.min(40, contentWidth(options));
+	const glyphs = options.unicode ? [
+		"█",
+		"░",
+		"▒",
+		"▓"
+	] : [
+		"#",
+		".",
+		":",
+		"+"
+	];
+	let cumulative = 0;
+	let used = 0;
+	return [
+		`  ${rows.map((row, i) => {
+			cumulative += row.value;
+			const endpoint = Math.round(cumulative / total * width);
+			const mark = glyphs[i % glyphs.length].repeat(endpoint - used);
+			used = endpoint;
+			return paint(mark, i === 0 ? "accent" : "muted", options);
+		}).join("")}`,
+		"",
+		...rows.flatMap((row, i) => textLines(`${glyphs[i % glyphs.length]} ${row.label}  ${formatMetric("share", row.value / total)}  ${formatMetric(metric, row.value)}`, options)),
+		"",
+		...textLines(`${formatMetric(metric, total)} ${metric} in returned rows`, options, "muted")
+	];
+}
+function renderMetrics(values, options) {
+	return values.flatMap((value) => {
+		const display = `${value.label}: ${formatMetric(value.key, value.current)}`;
+		if (value.previous === void 0) return textLines(display, options);
+		const change = formatChange(value.key, value.current ?? NaN, value.previous);
+		return textLines(`${display}  ${change.text}`, options, change.direction);
+	});
+}
+function bucketDate(value, unit) {
+	const input = unit === "month" ? `${value.slice(0, 7)}-01` : value;
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(input)) return null;
+	const date = /* @__PURE__ */ new Date(`${input}T00:00:00Z`);
+	if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== input) return null;
+	if (unit === "week") date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 6) % 7);
+	return date;
+}
+function calendarBuckets(start, end, unit) {
+	const first = bucketDate(start, unit);
+	const last = bucketDate(end, unit);
+	if (!first || !last || first > last) return [];
+	const buckets = [];
+	const cursor = new Date(first);
+	while (cursor.getTime() <= last.getTime()) {
+		if (buckets.length === 1e4) return [];
+		buckets.push(cursor.toISOString().slice(0, unit === "month" ? 7 : 10));
+		if (unit === "month") cursor.setUTCMonth(cursor.getUTCMonth() + 1);
+		else cursor.setUTCDate(cursor.getUTCDate() + (unit === "week" ? 7 : 1));
+	}
+	return buckets;
+}
+function renderSparklines(rows, range, metric, options, extraColumns = []) {
+	const buckets = calendarBuckets(range.start, range.end, range.unit);
+	if (!buckets.length) return textLines("Series unavailable for this date range.", options, "warning");
+	const width = contentWidth(options);
+	const chartWidth = Math.max(1, width >= 64 ? Math.min(extraColumns.length ? 12 : 28, width - 40) : width);
+	const group = Math.ceil(buckets.length / chartWidth);
+	const gap = options.unicode ? "·" : "?";
+	const glyphs = options.unicode ? "▁▂▃▄▅▆▇█" : "12345678";
+	const plotted = [];
+	let missing = false;
+	for (const row of rows) {
+		const map = new Map(row.points.map((point) => [point.date, finite(point.value)]));
+		const values = [];
+		for (let i = 0; i < buckets.length; i += group) {
+			const cell = buckets.slice(i, i + group).map((date) => map.get(date) ?? null);
+			values.push(cell.includes(null) ? null : cell.reduce((sum, value) => sum + value, 0));
+		}
+		const known = values.filter((value) => value !== null && Number.isFinite(value));
+		const min = known.reduce((n, value) => Math.min(n, value), Infinity);
+		const max = known.reduce((n, value) => Math.max(n, value), -Infinity);
+		const spark = values.map((value) => value === null || !Number.isFinite(value) ? gap : glyphs[max === min ? max === 0 ? 0 : 3 : Math.round((value - min) / (max - min) * 7)]).join("");
+		missing ||= spark.includes(gap);
+		plotted.push({
+			...row,
+			spark
+		});
+	}
+	const lines = renderTable(plotted, [
+		{
+			key: "label",
+			label: ""
+		},
+		{
+			key: "total",
+			label: metricLabel(metric),
+			numeric: true,
+			format: (value) => formatMetric(metric, value)
+		},
+		{
+			key: "spark",
+			label: {
+				day: "Daily",
+				week: "Weekly",
+				month: "Monthly"
+			}[range.unit],
+			numeric: true,
+			tone: "accent"
+		},
+		...extraColumns
+	], options);
+	const notes = [];
+	if (rows.length > 1) notes.push("row scales");
+	if (missing) notes.push(`${gap} missing`);
+	if (group > 1) notes.push(`sum / ${group} ${range.unit}s`);
+	if (!options.unicode) notes.push("1 low, 8 high");
+	if (notes.length) lines.push(...textLines(notes.join(" | "), options, "muted"));
+	return lines;
+}
+export { barColumn, calendarBuckets, renderBars, renderMetrics, renderShare, renderSparklines };

package/dist/render/layout.mjs

@@ -0,0 +1,87 @@
+import { stripVTControlCharacters } from "node:util";
+import stringWidth from "string-width";
+function cleanText(value) {
+	return stripVTControlCharacters(String(value)).replace(/[\x00-\x1F\x7F-\x9F\u2028\u2029]/g, " ");
+}
+function contentWidth(options) {
+	return Math.max(1, (Number.isFinite(options.columns) ? Math.floor(options.columns) : 80) - 2);
+}
+function paint(text, tone, options) {
+	const code = {
+		accent: 36,
+		muted: 90,
+		good: 32,
+		bad: 31,
+		warning: 33,
+		neutral: 0
+	}[tone];
+	return options.color && tone !== "neutral" ? `\x1B[${code}m${text}\x1B[0m` : text;
+}
+function fitLabel(value, width, options) {
+	const text = cleanText(value);
+	if (stringWidth(text) <= width) return text;
+	const marker = options.unicode ? "…" : "~";
+	let result = "";
+	for (const { segment } of new Intl.Segmenter("en", { granularity: "grapheme" }).segment(text)) {
+		if (stringWidth(result + segment + marker) > width) break;
+		result += segment;
+	}
+	return width > 0 ? result + marker : "";
+}
+function pad(value, width, right = false) {
+	const spaces = " ".repeat(Math.max(0, width - stringWidth(value)));
+	return right ? spaces + value : value + spaces;
+}
+function textLines(value, options, tone = "neutral") {
+	const text = cleanText(value);
+	const width = contentWidth(options);
+	const lines = [];
+	let row = "";
+	const flush = () => {
+		if (row.trim()) lines.push(`  ${paint(row.trimEnd(), tone, options)}`);
+		row = "";
+	};
+	const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+	for (const word of text.split(/(\s+)/)) {
+		if (!word) continue;
+		if (stringWidth(word) <= width) {
+			if (stringWidth(row + word) > width) flush();
+			if (row || word.trim()) row += word;
+			continue;
+		}
+		flush();
+		for (const { segment } of segmenter.segment(word)) {
+			if (row && stringWidth(row + segment) > width) flush();
+			row += segment;
+		}
+	}
+	lines.push(`  ${paint(row.trimEnd(), tone, options)}`);
+	return lines;
+}
+function renderTable(rows, columns, options) {
+	if (rows.length === 0) return textLines("No results for this period.", options);
+	const labels = columns.map((col) => cleanText(col.label));
+	const cells = rows.map((row) => columns.map((col) => cleanText(col.format ? col.format(row[col.key]) : row[col.key] ?? "n/a")));
+	if (columns.length === 0) return [];
+	const widths = columns.map((_, i) => cells.reduce((width, row) => Math.max(width, stringWidth(row[i])), stringWidth(labels[i])));
+	let totalWidth = widths.reduce((sum, width) => sum + width, 0) + (columns.length - 1) * 2;
+	if (contentWidth(options) >= 60) for (const [i, column] of columns.entries()) {
+		if (column.numeric || totalWidth <= contentWidth(options)) continue;
+		const reduction = Math.min(widths[i] - Math.max(8, stringWidth(labels[i])), totalWidth - contentWidth(options));
+		if (reduction > 0) {
+			widths[i] -= reduction;
+			totalWidth -= reduction;
+		}
+	}
+	if (totalWidth > contentWidth(options)) return cells.flatMap((row, rowIndex) => [...columns.flatMap((col, i) => textLines(labels[i] ? `${labels[i]}: ${row[i]}` : row[i], options, typeof col.tone === "function" ? col.tone(rows[rowIndex][col.key]) : col.tone)), ""]);
+	const line = (values, row) => `  ${values.map((value, i) => {
+		const col = columns[i];
+		return paint(pad(row && !col.numeric ? fitLabel(value, widths[i], options) : value, widths[i], col.numeric), row && (typeof col.tone === "function" ? col.tone(row[col.key]) : col.tone) || "neutral", options);
+	}).join("  ")}`;
+	return [
+		line(labels),
+		`  ${paint(widths.map((width) => (options.unicode ? "─" : "-").repeat(width)).join("  "), "muted", options)}`,
+		...cells.map((row, i) => line(row, rows[i]))
+	];
+}
+export { cleanText, contentWidth, fitLabel, pad, paint, renderTable, textLines };

package/dist/render/metrics.mjs

@@ -0,0 +1,163 @@
+const METRICS = {
+	clicks: {
+		label: "Clicks",
+		unit: "count"
+	},
+	impressions: {
+		label: "Impressions",
+		unit: "count"
+	},
+	totalClicks: {
+		label: "Clicks",
+		unit: "count"
+	},
+	totalImpressions: {
+		label: "Impressions",
+		unit: "count"
+	},
+	recentClicks: {
+		label: "Clicks",
+		unit: "count"
+	},
+	baselineClicks: {
+		label: "Previous",
+		unit: "count"
+	},
+	prevClicks: {
+		label: "Previous",
+		unit: "count"
+	},
+	ctr: {
+		label: "CTR",
+		unit: "ratio"
+	},
+	avgCtr: {
+		label: "CTR",
+		unit: "ratio"
+	},
+	position: {
+		label: "Avg position",
+		unit: "position"
+	},
+	avgPosition: {
+		label: "Avg position",
+		unit: "position"
+	},
+	recentPosition: {
+		label: "Average position",
+		unit: "position"
+	},
+	prevPosition: {
+		label: "Previous position",
+		unit: "position"
+	},
+	growthRatio: {
+		label: "Growth",
+		unit: "factor"
+	},
+	vsAverage: {
+		label: "Vs average",
+		unit: "factor"
+	},
+	brandShare: {
+		label: "Brand share",
+		unit: "share"
+	},
+	share: {
+		label: "Share",
+		unit: "share"
+	},
+	topNConcentration: {
+		label: "Top share",
+		unit: "share"
+	},
+	declinePercent: {
+		label: "Decline",
+		unit: "share"
+	},
+	clicksChangePercent: {
+		label: "Click change",
+		unit: "percentage"
+	},
+	impressionsChangePercent: {
+		label: "Impression change",
+		unit: "percentage"
+	},
+	bytes: {
+		label: "Bytes",
+		unit: "bytes"
+	},
+	liveBytes: {
+		label: "Live bytes",
+		unit: "bytes"
+	},
+	liveRows: {
+		label: "Rows",
+		unit: "count"
+	},
+	liveFiles: {
+		label: "Files",
+		unit: "count"
+	}
+};
+function metricLabel(key) {
+	return METRICS[key]?.label ?? (key === "keyword" ? "query" : key);
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function formatMetric(key, value) {
+	const n = finite(value);
+	if (n === null) return "n/a";
+	const unit = METRICS[key]?.unit;
+	if ((unit === "ratio" || unit === "share") && (n < 0 || n > 1)) return "n/a";
+	if (unit === "factor" && !Number.isFinite((n - 1) * 100)) return "n/a";
+	switch (unit) {
+		case "count": return n.toLocaleString("en-US", { maximumFractionDigits: 0 });
+		case "ratio": return `${(n * 100).toFixed(2)}%`;
+		case "share": return `${(n * 100).toFixed(1)}%`;
+		case "percentage": return `${signed(n, 1)}%`;
+		case "factor": return `${signed((n - 1) * 100, 1)}%`;
+		case "position": return n.toFixed(1);
+		case "bytes": {
+			const scale = n >= 1024 ** 3 ? 3 : n >= 1024 ** 2 ? 2 : n >= 1024 ? 1 : 0;
+			return `${(n / 1024 ** scale).toFixed(scale === 0 ? 0 : 2)} ${[
+				"B",
+				"KiB",
+				"MiB",
+				"GiB"
+			][scale]}`;
+		}
+		default: return String(n);
+	}
+}
+function signed(n, decimals = 0) {
+	if (!Number.isFinite(n)) return "n/a";
+	const rounded = Number(n.toFixed(decimals));
+	return `${rounded > 0 ? "+" : ""}${rounded.toLocaleString("en-US", {
+		minimumFractionDigits: decimals,
+		maximumFractionDigits: decimals
+	})}`;
+}
+function formatChange(key, current, previous) {
+	if (previous === null || !Number.isFinite(current) || !Number.isFinite(previous)) return {
+		text: "No baseline.",
+		direction: "neutral"
+	};
+	const difference = current - previous;
+	const unit = METRICS[key]?.unit;
+	const direction = difference === 0 || unit === "share" ? "neutral" : (unit === "position" ? difference < 0 : difference > 0) ? "good" : "bad";
+	if (unit === "position") return {
+		text: difference === 0 ? "unchanged" : `${difference < 0 ? "improved" : "worsened"} ${Math.abs(difference).toFixed(1)}`,
+		direction
+	};
+	if (unit === "ratio" || unit === "share") return {
+		text: `${signed(difference * 100, 2)} pp`,
+		direction
+	};
+	return {
+		text: previous === 0 ? `${signed(difference)} (previous: 0)` : `${signed(difference)} (${signed(difference / Math.abs(previous) * 100, 1)}%)`,
+		direction
+	};
+}
+export { finite, formatChange, formatMetric, metricLabel, signed };

package/dist/render/query.mjs

@@ -0,0 +1,30 @@
+import { renderTable, textLines } from "./layout.mjs";
+import { barColumn } from "./charts.mjs";
+import { columnsFor } from "./analysis.mjs";
+import { parseGscSiteUrl } from "gscdump";
+function renderQuery(input, options) {
+	const columns = columnsFor(input.rows, [
+		...input.dimensions,
+		"clicks",
+		"impressions",
+		"ctr",
+		"position"
+	]);
+	if (input.dimensions.length === 1 && [
+		"page",
+		"query",
+		"country",
+		"device",
+		"date"
+	].includes(input.dimensions[0])) {
+		const clicks = columns.findIndex((column) => column.key === "clicks");
+		if (clicks !== -1) columns[clicks] = barColumn(input.rows, "clicks", options);
+	}
+	return [
+		...textLines(`${parseGscSiteUrl(input.site).hostname} / query`, options, "accent"),
+		...textLines(`${input.start} to ${input.end}`, options, "muted"),
+		"",
+		...renderTable(input.rows, columns, options)
+	].join("\n");
+}
+export { renderQuery };

package/dist/render/report.mjs

@@ -0,0 +1,69 @@
+import { renderTable, textLines } from "./layout.mjs";
+import { barColumn, renderMetrics } from "./charts.mjs";
+import { columnsFor } from "./analysis.mjs";
+import { parseGscSiteUrl } from "gscdump";
+function renderCliReport(report, options) {
+	const lines = [...textLines(`${parseGscSiteUrl(report.site).hostname} / ${report.id}`, options, "accent"), ...textLines(`${report.window.start} to ${report.window.end}`, options, "muted")];
+	if (report.window.comparison) lines.push(...textLines(`vs ${report.window.comparison.start} to ${report.window.comparison.end}`, options, "muted"));
+	if (report.meta.degraded) lines.push(...textLines(`! Unavailable: ${report.meta.steps.filter((step) => step.status === "error").map((step) => step.key).join(", ")}`, options, "warning"));
+	const sections = report.sections.filter((section) => section.findings.length || section.coverage === "partial");
+	for (const section of sections) {
+		const status = section.coverage === "partial" ? " (partial)" : ["info", "low"].includes(section.severity) ? "" : ` [${section.severity}]`;
+		lines.push("", ...textLines(`${section.title}${status}`, options, section.coverage === "partial" ? "warning" : "accent"));
+		if (!section.findings.length) continue;
+		const changes = section.findings.filter((finding) => finding.delta?.metric === "clicks");
+		if (changes.length) {
+			const rows = changes.map((finding) => ({
+				...finding.metrics,
+				entity: finding.why ? `${finding.entity.value} (${finding.why})` : finding.entity.value,
+				prevClicks: finding.delta.prior,
+				clicks: finding.delta.current,
+				clicksChange: finding.delta.current - finding.delta.prior,
+				clicksChangePercent: finding.delta.prior === 0 ? null : (finding.delta.current - finding.delta.prior) / Math.abs(finding.delta.prior) * 100
+			}));
+			const extra = [...new Set(changes.flatMap((finding) => Object.keys(finding.metrics)))].filter((key) => ![
+				"clicks",
+				"clicksChange",
+				"clicksChangePercent",
+				"prevClicks",
+				"lostClicks",
+				"declinePercent"
+			].includes(key));
+			lines.push(...renderTable(rows, [
+				{
+					key: "entity",
+					label: ""
+				},
+				...columnsFor(rows, ["prevClicks", "clicks"]),
+				barColumn(rows, "clicksChange", options, true),
+				...columnsFor(rows, ["clicksChangePercent"]).map((column) => ({
+					...column,
+					label: "%"
+				})),
+				...columnsFor(rows, extra)
+			], options));
+		}
+		for (const finding of section.findings.filter((finding) => finding.delta?.metric !== "clicks")) {
+			lines.push(...textLines(finding.entity.value, options));
+			const delta = finding.delta;
+			if (delta) lines.push(...renderMetrics([{
+				key: delta.metric,
+				label: delta.metric,
+				current: delta.current,
+				previous: delta.prior
+			}], options));
+			const metrics = Object.fromEntries(Object.entries(finding.metrics).filter(([key]) => !delta || ![
+				delta.metric,
+				`${delta.metric}Change`,
+				`${delta.metric}ChangePercent`
+			].includes(key)));
+			const fields = columnsFor([metrics]).map((column) => `${column.label} ${column.format(metrics[column.key])}`);
+			if (fields.length) lines.push(...textLines(fields.join("  "), options));
+			if (finding.why) lines.push(...textLines(finding.why, options, "muted"));
+		}
+		if (section.truncated && section.truncated.total > section.truncated.kept) lines.push(...textLines(`${section.truncated.kept} of ${section.truncated.total} rows`, options, "muted"));
+	}
+	if (!sections.length) lines.push("", ...textLines(report.meta.degraded ? "Data unavailable." : "No findings.", options));
+	return lines.join("\n");
+}
+export { renderCliReport };

package/dist/render/terminal.mjs

@@ -0,0 +1,25 @@
+import { useCliRuntime } from "../runtime.mjs";
+import process from "node:process";
+function resolveOutputOptions(input) {
+	const env = input.environment;
+	const dumb = env.TERM === "dumb";
+	return {
+		columns: input.columns && input.columns > 0 ? Math.floor(input.columns) : 80,
+		color: !dumb && !input.noColor && !env.NO_COLOR && env.FORCE_COLOR !== "0" && (Boolean(input.isTTY) || Boolean(env.FORCE_COLOR)),
+		unicode: !dumb
+	};
+}
+function terminalOutputOptions(toFile = false) {
+	const runtime = useCliRuntime();
+	const options = resolveOutputOptions({
+		columns: toFile ? 80 : process.stdout.columns,
+		isTTY: !toFile && process.stdout.isTTY,
+		environment: runtime.environment,
+		noColor: !runtime.colorEnabled || runtime.rawArgs.includes("--no-color")
+	});
+	return toFile ? {
+		...options,
+		color: false
+	} : options;
+}
+export { resolveOutputOptions, terminalOutputOptions };

package/dist/runtime.d.mts

@@ -1,6 +1,7 @@
 import { ConsolaInstance } from "consola";
-type CliEnvironmentSource = Record<string, string | undefined>;
-interface CliRuntime {
+export type CliEnvironmentSource = Record<string, string | undefined>;
+export interface CliRuntime {
+  authModeOverride?: 'cloud' | 'local';
   activeProfileOverride: string | null;
   colorEnabled: boolean;
   configDir: string;
@@ -10,11 +11,10 @@ interface CliRuntime {
   quiet: boolean;
   rawArgs: string[];
 }
-interface CreateCliRuntimeOptions {
+export interface CreateCliRuntimeOptions {
   configDir?: string;
   environment?: CliEnvironmentSource;
   rawArgs?: readonly string[];
   stderr?: NodeJS.WriteStream;
 }
-declare function createCliRuntime(opts?: CreateCliRuntimeOptions): CliRuntime;
-export { CliEnvironmentSource, CliRuntime, CreateCliRuntimeOptions, createCliRuntime };
+export declare function createCliRuntime(opts?: CreateCliRuntimeOptions): CliRuntime;

package/dist/runtime.mjs

@@ -1,7 +1,7 @@
 import process from "node:process";
-import os from "node:os";
 import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
+import os from "node:os";
 import { createConsola } from "consola";
 let runtimeStorage;
 let fallbackRuntime;