gentle-pi 3.7.0 → 4.1.0

package/tests/stats-collector.test.ts

@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { aggregateStats, createStatsLoader, currentSessionStats, parseSessionLines, shiftDay, STATS_RANGE, STATS_SCOPE, weekdayOf, type StatsFilter } from "../lib/stats-collector.ts";
+import { SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+
+// The /gentle:stats collector: a streaming loader over Pi's session files and
+// pure aggregation over the parsed records. Fixtures carry exact numbers so
+// every figure the panel shows is pinned here.
+
+const SESSIONS = fileURLToPath(new URL("./fixtures/stats/sessions", import.meta.url));
+// A second home (the user's regular Pi) holding an OpenAI session and copies of aaa and bbb.
+const USER_SESSIONS = fileURLToPath(new URL("./fixtures/stats/user-pi/sessions", import.meta.url));
+const NOW = Date.parse("2026-10-01T12:00:00.000Z");
+const utcDay = (ms: number) => new Date(ms).toISOString().slice(0, 10);
+const filter = (overrides: Partial<StatsFilter> = {}): StatsFilter => ({ range: STATS_RANGE.ALL, scope: STATS_SCOPE.ALL, cwd: "/work/alpha", now: NOW, dayKey: utcDay, ...overrides });
+
+test("loader reads top-level session files only and tolerates malformed lines", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS]);
+	assert.deepEqual(sessions.map((session) => session.id).sort(), ["aaa", "bbb", "ccc", "ddd"]);
+	const aaa = sessions.find((session) => session.id === "aaa")!;
+	assert.equal(aaa.cwd, "/work/alpha");
+	assert.equal(aaa.messages.length, 2);
+	assert.deepEqual(aaa.messages[0], { timestamp: Date.parse("2026-09-28T10:01:00.000Z"), provider: "claude-bridge", model: "claude-opus-5-5", input: 100, output: 50, cacheRead: 1000, cacheWrite: 200, total: 1350, cost: 0.5 });
+	// Older usage without totalTokens falls back to the sum of its parts.
+	assert.equal(sessions.find((session) => session.id === "ccc")!.messages[0].total, 1000);
+	assert.equal(sessions.some((session) => session.messages.some((message) => message.model === "nested-model")), false);
+});
+
+test("loader returns nothing for a missing or empty sessions root", async () => {
+	const loader = createStatsLoader();
+	assert.deepEqual(await loader.load([join(tmpdir(), "gentle-stats-missing-root")]), []);
+	assert.deepEqual(await loader.load([mkdtempSync(join(tmpdir(), "gentle-stats-empty-"))]), []);
+	assert.deepEqual(await loader.load([]), []);
+});
+
+test("two roots combine into one history: OpenAI usage from the second root counts, duplicate session IDs count once", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS, USER_SESSIONS]);
+	assert.deepEqual(sessions.map((session) => session.id).sort(), ["aaa", "bbb", "ccc", "ddd", "fff"]);
+	const stats = aggregateStats(sessions, filter());
+	assert.deepEqual(stats.totals, { input: 2810, output: 1840, cacheRead: 1000, cacheWrite: 200, total: 5850, cost: 3.85 });
+	assert.deepEqual(stats.models.map(({ model, tokens, messages }) => [model, tokens, messages]), [["gpt-5.3-codex", 3000, 1], ["claude-opus-5-5", 1550, 4], ["gpt-5.5", 1000, 1], ["gpt-6.1-sol", 300, 1]]);
+	assert.deepEqual(stats.days, { "2026-09-01": 1000, "2026-09-20": 3000, "2026-09-28": 1650, "2026-09-29": 30, "2026-09-30": 170 });
+	assert.equal(stats.sessions, 4);
+	const gamma = aggregateStats(sessions, filter({ scope: STATS_SCOPE.PROJECT, cwd: "/work/gamma" }));
+	assert.deepEqual(gamma.models.map((model) => model.model), ["gpt-5.3-codex"]);
+	assert.equal(gamma.totals.total, 3000);
+});
+
+test("a duplicate session keeps the copy with the most usage records, then the latest usage, whatever the root order", async () => {
+	for (const roots of [[SESSIONS, USER_SESSIONS], [USER_SESSIONS, SESSIONS]]) {
+		const sessions = await createStatsLoader().load(roots);
+		// aaa: the active copy has 2 usage records, the user copy 1 → the active copy wins.
+		assert.deepEqual(sessions.find((session) => session.id === "aaa")!.messages.map((message) => message.total), [1350, 300]);
+		// bbb: the user copy has 3 usage records, the active copy 2 → the user copy wins.
+		assert.deepEqual(sessions.find((session) => session.id === "bbb")!.messages.map((message) => message.total), [30, 70, 100]);
+		assert.equal(sessions.filter((session) => session.id === "aaa" || session.id === "bbb").length, 2);
+	}
+	const root = mkdtempSync(join(tmpdir(), "gentle-stats-tie-"));
+	const header = (id: string) => JSON.stringify({ type: "session", version: 3, id, timestamp: "2026-09-01T00:00:00.000Z", cwd: "/t" });
+	const usage = (at: string, total: number) => JSON.stringify({ type: "message", timestamp: at, message: { role: "assistant", model: "m", usage: { output: total } } });
+	const write = (dir: string, name: string, lines: string[]) => { mkdirSync(join(root, dir), { recursive: true }); writeFileSync(join(root, dir, name), `${lines.join("\n")}\n`); };
+	write("a", "1_tie.jsonl", [header("tie"), usage("2026-09-01T00:01:00.000Z", 1)]);
+	write("b", "2_tie.jsonl", [header("tie"), usage("2026-09-01T00:02:00.000Z", 2)]);
+	// Equal record counts fall back to the latest usage timestamp.
+	assert.deepEqual((await createStatsLoader().load([root])).map((session) => session.messages[0].total), [2]);
+	// Headers without an ID are never merged with each other.
+	write("a", "3_noid.jsonl", [JSON.stringify({ type: "session", version: 3, cwd: "/t" }), usage("2026-09-02T00:00:00.000Z", 5)]);
+	write("b", "4_noid.jsonl", [JSON.stringify({ type: "session", version: 3, cwd: "/t" }), usage("2026-09-03T00:00:00.000Z", 7)]);
+	assert.deepEqual((await createStatsLoader().load([root])).map((session) => session.messages[0].total).sort(), [2, 5, 7]);
+});
+
+test("alias roots (trailing slash, dot segments, symlinks) and missing roots never double count", async () => {
+	const link = join(mkdtempSync(join(tmpdir(), "gentle-stats-alias-")), "sessions-link");
+	symlinkSync(SESSIONS, link, "dir");
+	const missing = join(tmpdir(), "gentle-stats-missing-root");
+	const once = aggregateStats(await createStatsLoader().load([SESSIONS]), filter());
+	const aliased = aggregateStats(await createStatsLoader().load([SESSIONS, `${SESSIONS}/`, join(SESSIONS, "..", "sessions"), link, missing]), filter());
+	assert.deepEqual(aliased.totals, once.totals);
+	assert.equal(aliased.sessions, 3);
+});
+
+test("parseSessionLines ignores files without a session header", () => {
+	assert.equal(parseSessionLines(["garbage", "{\"type\":\"message\"}"]), undefined);
+	const parsed = parseSessionLines([
+		"{\"type\":\"session\",\"id\":\"x\",\"timestamp\":\"2026-09-01T00:00:00.000Z\",\"cwd\":\"/x\"}",
+		"{\"type\":\"message\",\"timestamp\":\"2026-09-01T00:01:00.000Z\",\"message\":{\"role\":\"assistant\",\"model\":\"m\",\"usage\":{\"input\":\"bad\",\"output\":3}}}",
+	]);
+	assert.equal(parsed?.messages[0].input, 0);
+	assert.equal(parsed?.messages[0].total, 3);
+	assert.equal(parsed?.messages[0].provider, "unknown");
+});
+
+test("all-time stats across every project match the fixture exactly", async () => {
+	const stats = aggregateStats(await createStatsLoader().load([SESSIONS]), filter());
+	assert.deepEqual(stats.totals, { input: 810, output: 740, cacheRead: 1000, cacheWrite: 200, total: 2750, cost: 2.05 });
+	assert.deepEqual(stats.models.map(({ model, tokens, messages }) => [model, tokens, messages]), [["claude-opus-5-5", 1450, 3], ["gpt-5.5", 1000, 1], ["gpt-6.1-sol", 300, 1]]);
+	assert.equal(stats.models[0].cost.toFixed(2), "0.80");
+	assert.equal(stats.models[0].share, 1450 / 2750);
+	assert.deepEqual(stats.days, { "2026-09-01": 1000, "2026-09-28": 1650, "2026-09-29": 30, "2026-09-30": 70 });
+	assert.equal(stats.sessions, 3);
+	assert.equal(stats.activeDays, 4);
+	assert.equal(stats.daysInRange, 31);
+	assert.equal(stats.firstDay, "2026-09-01");
+	assert.equal(stats.today, "2026-10-01");
+	assert.deepEqual(stats.mostActiveDay, { day: "2026-09-28", tokens: 1650 });
+	assert.deepEqual(stats.longestSession, { id: "bbb", durationMs: 2 * 60 * 60 * 1000 });
+	assert.equal(stats.longestStreak, 3);
+	assert.equal(stats.currentStreak, 3);
+});
+
+test("range filters count only messages inside the selected local days", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS]);
+	const week = aggregateStats(sessions, filter({ range: STATS_RANGE.WEEK }));
+	assert.equal(week.totals.total, 1750);
+	assert.equal(week.totals.cost.toFixed(2), "1.05");
+	assert.equal(week.sessions, 2);
+	assert.equal(week.activeDays, 3);
+	assert.equal(week.daysInRange, 7);
+	assert.equal(week.firstDay, "2026-09-25");
+	// 2026-09-01 sits one day before the 30-day window that ends today.
+	const month = aggregateStats(sessions, filter({ range: STATS_RANGE.MONTH }));
+	assert.equal(month.totals.total, 1750);
+	assert.equal(month.daysInRange, 30);
+	assert.equal(month.firstDay, "2026-09-02");
+});
+
+test("project scope keeps only sessions started in the current cwd", async () => {
+	const stats = aggregateStats(await createStatsLoader().load([SESSIONS]), filter({ scope: STATS_SCOPE.PROJECT, cwd: "/work/beta" }));
+	assert.equal(stats.totals.total, 1000);
+	assert.equal(stats.sessions, 1);
+	assert.equal(stats.longestStreak, 1);
+	assert.equal(stats.currentStreak, 0);
+	assert.deepEqual(stats.models.map((model) => model.model), ["gpt-5.5"]);
+});
+
+test("current streak survives an idle today but breaks after a missed day", () => {
+	const session = (id: string, ...days: string[]) => ({
+		id, cwd: "/x", startedAt: Date.parse(`${days[0]}T10:00:00.000Z`),
+		messages: days.map((day) => ({ timestamp: Date.parse(`${day}T10:00:00.000Z`), provider: "p", model: "m", input: 1, output: 0, cacheRead: 0, cacheWrite: 0, total: 1, cost: 0 })),
+	});
+	const active = aggregateStats([session("a", "2026-09-29", "2026-09-30", "2026-10-01")], filter());
+	assert.equal(active.currentStreak, 3);
+	const broken = aggregateStats([session("a", "2026-09-28", "2026-09-29")], filter());
+	assert.equal(broken.currentStreak, 0);
+	assert.equal(broken.longestStreak, 2);
+});
+
+test("empty input aggregates to zeroes without throwing", () => {
+	const stats = aggregateStats([], filter());
+	assert.deepEqual(stats.totals, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 });
+	assert.deepEqual(stats.models, []);
+	assert.equal(stats.sessions, 0);
+	assert.equal(stats.activeDays, 0);
+	assert.equal(stats.daysInRange, 1);
+	assert.equal(stats.mostActiveDay, undefined);
+	assert.equal(stats.longestSession, undefined);
+	assert.equal(stats.longestStreak, 0);
+	assert.equal(stats.currentStreak, 0);
+});
+
+test("day keys shift across month boundaries and report their weekday", () => {
+	assert.equal(shiftDay("2026-10-01", -1), "2026-09-30");
+	assert.equal(shiftDay("2026-12-31", 1), "2027-01-01");
+	assert.equal(weekdayOf("2026-10-01"), 4); // Thursday
+});
+
+test("loader reuses unchanged files from its cache", async () => {
+	const loader = createStatsLoader();
+	const first = await loader.load([SESSIONS]);
+	const second = await loader.load([SESSIONS]);
+	assert.equal(first.find((session) => session.id === "aaa"), second.find((session) => session.id === "aaa"));
+});
+
+test("currentSessionStats summarizes the live session including captured line changes", () => {
+	const entries = [
+		{ type: "model_change", timestamp: "2026-10-01T11:00:00.000Z", provider: "claude-bridge", modelId: "claude-opus-5-5" },
+		{ type: "message", timestamp: "2026-10-01T11:01:00.000Z", message: { role: "assistant", provider: "claude-bridge", model: "claude-opus-5-5", usage: { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, totalTokens: 135, cost: { total: 0.125 } } } },
+		{ type: "message", timestamp: "2026-10-01T11:02:00.000Z", message: { role: "user", content: "x" } },
+		{ type: "custom", customType: SESSION_CHANGE_ENTRY, timestamp: "2026-10-01T11:03:00.000Z", data: { sessionId: "live", evidence: { id: "e1", root: "/repo", path: "a.txt", before: { kind: "text", text: "a\nb\n" }, after: { kind: "text", text: "a\nc\nd\n" } } } },
+	];
+	const stats = currentSessionStats(entries, { sessionId: "live", now: Date.parse("2026-10-01T11:30:00.000Z") });
+	assert.deepEqual(stats.totals, { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, total: 135, cost: 0.125 });
+	assert.equal(stats.messages, 1);
+	assert.equal(stats.model, "claude-opus-5-5");
+	assert.equal(stats.durationMs, 30 * 60 * 1000);
+	assert.deepEqual(stats.lines, { added: 2, removed: 1 });
+	const empty = currentSessionStats([], { sessionId: "none", now: NOW });
+	assert.equal(empty.durationMs, 0);
+	assert.equal(empty.lines, undefined);
+	assert.equal(empty.model, undefined);
+});

package/tests/stats-view.test.ts

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+import { createStatsLoader, type CurrentSessionStats, type SessionRecord } from "../lib/stats-collector.ts";
+import { StatsView, type StatsViewDeps } from "../lib/stats-view.ts";
+
+// The /gentle:stats panel: Overview / Models / Session tabs over the
+// collector, with range and scope toggles, q/esc close, and a clickable
+// footer. Rendered against the collector fixtures with a fixed clock.
+
+const SESSIONS = fileURLToPath(new URL("./fixtures/stats/sessions", import.meta.url));
+const NOW = Date.parse("2026-10-01T12:00:00.000Z");
+const ROWS = 40;
+const plainTheme = { fg: (_role: string, text: string) => text };
+// Zero-width role markers: one 256-color SGR per role, so widths stay honest.
+const ROLES = ["accent", "borderMuted"];
+const roleCode = (role: string) => `\x1b[38;5;${ROLES.indexOf(role) + 1}m`;
+const roleTheme = { fg: (role: string, text: string) => `${roleCode(role)}${text}\x1b[39m` };
+const CURRENT: CurrentSessionStats = {
+	totals: { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, total: 135, cost: 0.125 },
+	messages: 1,
+	model: "claude-opus-5-5",
+	durationMs: 30 * 60 * 1000,
+	lines: { added: 2, removed: 1 },
+};
+
+function makeView(overrides: Partial<StatsViewDeps> = {}) {
+	const events: string[] = [];
+	const view = new StatsView({
+		theme: plainTheme,
+		rows: ROWS,
+		cwd: "/work/alpha",
+		now: () => NOW,
+		dayKey: (ms) => new Date(ms).toISOString().slice(0, 10),
+		load: () => createStatsLoader().load(SESSIONS),
+		current: () => CURRENT,
+		onClose: () => events.push("close"),
+		requestRender: () => events.push("render"),
+		...overrides,
+	});
+	return { view, events };
+}
+
+async function ready(overrides: Partial<StatsViewDeps> = {}) {
+	const made = makeView(overrides);
+	await made.view.load();
+	return made;
+}
+
+const plain = (view: StatsView, width = 100) => view.render(width).map(stripAnsi);
+const joined = (view: StatsView, width = 100) => plain(view, width).join("\n");
+
+function assertFits(view: StatsView, width: number) {
+	const lines = view.render(width);
+	assert.equal(lines.length, ROWS);
+	for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+}
+
+function click(view: StatsView, width: number, y: number, label: string) {
+	const lines = plain(view, width);
+	const x = lines[y].indexOf(label);
+	assert.ok(x >= 0, `"${label}" not on row ${y}: ${lines[y]}`);
+	const event: TuiMouseEvent = { type: "click", button: "left", x, y, screenX: x, screenY: y, width, height: ROWS, shift: false, alt: false, ctrl: false };
+	return view.handleMouse(event);
+}
+
+test("StatsView shows a loading state, then the overview once sessions load", async () => {
+	let resolve!: (sessions: SessionRecord[]) => void;
+	const { view, events } = makeView({ load: () => new Promise((done) => { resolve = done; }) });
+	const loading = view.load();
+	assert.match(joined(view), /Loading local sessions…/);
+	resolve(await createStatsLoader().load(SESSIONS));
+	await loading;
+	assert.ok(events.includes("render"));
+	const text = joined(view);
+	assert.doesNotMatch(text, /Loading/);
+	assert.match(text, /✿ Stats/);
+	assert.match(text, /\[× Close\]/);
+	assert.match(text, /Overview/);
+	assert.match(text, /All time · All projects/);
+});
+
+test("Overview pins every headline figure from the fixtures", async () => {
+	const { view } = await ready();
+	const text = joined(view);
+	assert.match(text, /Favorite model +claude-opus-5-5/);
+	assert.match(text, /Total tokens +2\.8k/);
+	assert.match(text, /Sessions +3/);
+	assert.match(text, /Longest session +2h00m/);
+	assert.match(text, /Active days +4\/31/);
+	assert.match(text, /Longest streak +3 days/);
+	assert.match(text, /Most active day +Sep 28/);
+	assert.match(text, /Current streak +3 days/);
+	assert.match(text, /in 810 · out 740 · cache read 1\.0k · cache write 200/);
+	assert.match(text, /Cost +\$2\.05/);
+	assert.match(text, /Don Quixote/);
+	assert.match(text, /Less .* More/);
+	assert.match(text, /Mon/);
+	assert.match(text, /Local Pi sessions on this machine · subagent runs not included/);
+	assertFits(view, 100);
+});
+
+test("the heatmap shades days with theme roles and leaves future days blank", async () => {
+	const { view } = await ready({ theme: roleTheme });
+	const text = view.render(100).join("\n");
+	const heat = text.split("\n").slice(4, 11).join("\n");
+	assert.ok(heat.includes(`${roleCode("accent")}█`), "the busiest day takes the strongest shade");
+	assert.ok(heat.includes(`${roleCode("accent")}░`), "a light day takes the faintest shade");
+	assert.ok(heat.includes(`${roleCode("borderMuted")}·`), "idle days stay visible as dots");
+	// 96 content cells hold 46 two-cell weeks after the 4-cell weekday label.
+	const x = 2 + 4 + (Math.floor((96 - 4) / 2) - 1) * 2;
+	const thisWeek = stripAnsi(text).split("\n").slice(4, 11).map((line) => line[x]);
+	assert.deepEqual(thisWeek, ["█", "░", "░", "·", " ", " ", " "], "Mon–Thu of this week are drawn, Fri–Sun are still blank");
+	assert.doesNotMatch(text, /#[0-9a-f]{6}|\x1b\[38;2/i, "no hardcoded colors");
+});
+
+test("range and scope toggles re-aggregate and relabel the panel", async () => {
+	const { view, events } = await ready();
+	view.handleInput("r");
+	assert.match(joined(view), /Last 7 days · All projects/);
+	assert.match(joined(view), /Total tokens +1\.8k/);
+	assert.match(joined(view), /Active days +3\/7/);
+	view.handleInput("r");
+	assert.match(joined(view), /Last 30 days/);
+	view.handleInput("r");
+	assert.match(joined(view), /All time/);
+	view.handleInput("s");
+	assert.match(joined(view), /All time · This project/);
+	assert.match(joined(view), /Sessions +2/);
+	assert.ok(events.filter((event) => event === "render").length >= 4);
+});
+
+test("tabs switch with Tab, shift+Tab, arrows, and digits", async () => {
+	const { view } = await ready();
+	view.handleInput("\t");
+	let text = joined(view);
+	assert.match(text, /claude-opus-5-5 .*53% .*1\.4k .*\$0\.800 .*3/);
+	assert.match(text, /gpt-5\.5 .*36%/);
+	assert.match(text, /gpt-6\.1-sol .*11%/);
+	view.handleInput("\x1b[C");
+	text = joined(view);
+	assert.match(text, /Model +claude-opus-5-5/);
+	assert.match(text, /Cost +\$0\.125/);
+	assert.match(text, /Duration +30m00s/);
+	assert.match(text, /Lines +\+2 −1/);
+	assert.match(text, /135 total · in 10 · out 5 · cache read 100 · cache write 20/);
+	view.handleInput("\x1b[Z");
+	assert.match(joined(view), /Share/);
+	view.handleInput("1");
+	assert.match(joined(view), /Favorite model/);
+	view.handleInput("\x1b[D");
+	assert.match(joined(view), /Duration/);
+	view.handleInput("2");
+	assert.match(joined(view), /Share/);
+});
+
+test("q and esc close exactly once", async () => {
+	const { view, events } = await ready();
+	view.handleInput("q");
+	view.handleInput("q");
+	view.handleInput("\x1b");
+	assert.equal(events.filter((event) => event === "close").length, 1);
+	const escaped = await ready();
+	escaped.view.handleInput("\x1b");
+	assert.equal(escaped.events.filter((event) => event === "close").length, 1);
+});
+
+test("empty and failing loads render a calm state without throwing", async () => {
+	const empty = await ready({ load: async () => [] });
+	assert.match(joined(empty.view), /No usage recorded yet/);
+	empty.view.handleInput("2");
+	assert.match(joined(empty.view), /No usage recorded yet/);
+	assertFits(empty.view, 100);
+	const failed = await ready({ load: async () => { throw new Error("disk on fire"); } });
+	assert.match(joined(failed.view), /Could not read local sessions: disk on fire/);
+	assertFits(failed.view, 100);
+});
+
+test("narrow terminals keep every line inside the frame", async () => {
+	const { view } = await ready();
+	for (const tab of ["1", "2", "3"]) {
+		view.handleInput(tab);
+		assertFits(view, 48);
+		assertFits(view, 120);
+	}
+});
+
+test("clickable header and footer controls switch tabs, toggle filters, and close", async () => {
+	const { view, events } = await ready();
+	const width = 100;
+	assert.deepEqual(click(view, width, 1, "Models"), { handled: true, render: true });
+	assert.match(joined(view), /Share/);
+	const footer = ROWS - 2;
+	click(view, width, footer, "r range");
+	assert.match(joined(view), /Last 7 days/);
+	click(view, width, footer, "s scope");
+	assert.match(joined(view), /This project/);
+	click(view, width, 0, "[× Close]");
+	assert.equal(events.filter((event) => event === "close").length, 1);
+});