@mohndoe/pi-atlas 0.1.1

package/src/__tests__/compute.fixtures.ts

@@ -0,0 +1,49 @@
+import { type StatsSummary } from "../types";
+
+export const makeSummary = (): StatsSummary => ({
+  totalCost: 5.0,
+  sessionCount: 3,
+  totalMessages: 50,
+  totalInputTokens: 500,
+  totalOutputTokens: 500,
+  totalCacheReadTokens: 250,
+  totalCacheWriteTokens: 250,
+  totalTokens: 10000,
+  daysActive: 3,
+  avgCostPerDay: 1.67,
+  todayCost: 1.0,
+  languages: [
+    {
+      language: "TypeScript",
+      lines: 10000,
+      edits: 5,
+    },
+  ],
+  models: [
+    {
+      model: "deeepseek-v4",
+      cost: 0.5,
+      provider: "deepseek",
+      calls: 1000,
+    },
+  ],
+  projects: [
+    {
+      cost: 0,
+      project: "pi-atlas",
+      sessions: 12,
+    },
+  ],
+  tools: [
+    {
+      count: 10,
+      name: "bash",
+    },
+  ],
+  dailySpend: [
+    { date: "2026-06-06", cost: 1.0 },
+    { date: "2026-06-07", cost: 2.0 },
+    { date: "2026-06-08", cost: 2.0 },
+  ],
+  hourlySpend: [],
+});

package/src/__tests__/compute.test.ts

@@ -0,0 +1,336 @@
+import { describe, expect, it } from "bun:test";
+import { summarize } from "../compute";
+import { dateFromISOString } from "../format";
+import { emptyDay, mergeDay } from "../parser";
+
+describe("summarize", () => {
+  it("returns zeros for empty day list", () => {
+    const s = summarize([], "All");
+    expect(s.totalCost).toBe(0);
+    expect(s.sessionCount).toBe(0);
+    expect(s.totalMessages).toBe(0);
+    expect(s.totalOutputTokens).toBe(0);
+    expect(s.totalInputTokens).toBe(0);
+    expect(s.totalCacheWriteTokens).toBe(0);
+    expect(s.totalCacheReadTokens).toBe(0);
+    expect(s.totalTokens).toBe(0);
+    expect(s.daysActive).toBe(0);
+    expect(s.avgCostPerDay).toBe(0);
+    expect(s.dailySpend).toEqual([]);
+    expect(s.languages).toEqual([]);
+    expect(s.models).toEqual([]);
+    expect(s.projects).toEqual([]);
+    expect(s.tools).toEqual([]);
+  });
+
+  it("computes KPIs from a single day", () => {
+    const today = dateFromISOString(new Date().toISOString());
+    const d = emptyDay(today);
+    mergeDay(d, {
+      ...emptyDay(today),
+      cost: 1.5,
+      sessionIds: new Set(["s1", "s2"]),
+      userMsgs: 3,
+      asstMsgs: 5,
+      toolResults: 4,
+      inTok: 1000,
+      outTok: 500,
+      crTok: 100,
+      cwTok: 50,
+      modelCost: { sonnet: 1.0, haiku: 0.5 },
+      modelCount: { sonnet: 2, haiku: 3 },
+      toolCount: { bash: 2, read: 2 },
+      langLines: { typescript: 100 },
+      langEdits: { typescript: 5 },
+    });
+    const days = [d];
+
+    const s = summarize(days, "1d");
+    expect(s.totalCost).toBe(1.5);
+    expect(s.sessionCount).toBe(2);
+    expect(s.totalMessages).toBe(12); // 3+5+4
+    expect(s.totalInputTokens).toBe(1000);
+    expect(s.totalOutputTokens).toBe(500);
+    expect(s.totalCacheReadTokens).toBe(100);
+    expect(s.totalCacheWriteTokens).toBe(50);
+    expect(s.totalTokens).toBe(1650); // 1000+500+100+50
+    expect(s.daysActive).toBe(1);
+    expect(s.avgCostPerDay).toBe(1.5);
+
+    expect(s.models).toHaveLength(2);
+    expect(s.models[0]).toEqual({ model: "sonnet", cost: 1.0, calls: 2 });
+    expect(s.models[1]).toEqual({ model: "haiku", cost: 0.5, calls: 3 });
+
+    expect(s.tools).toHaveLength(2);
+    expect(s.tools).toContainEqual({ name: "bash", count: 2 });
+    expect(s.tools).toContainEqual({ name: "read", count: 2 });
+
+    expect(s.languages).toEqual([{ language: "typescript", lines: 100, edits: 5 }]);
+  });
+
+  it("filters by time range", () => {
+    const today = new Date().toISOString().slice(0, 10);
+    const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
+    const eightDaysAgo = new Date(Date.now() - 8 * 86400000).toISOString().slice(0, 10);
+
+    const d1 = emptyDay(today);
+    d1.cost = 1;
+    d1.sessionIds = new Set(["a"]);
+    const d2 = emptyDay(yesterday);
+    d2.cost = 2;
+    d2.sessionIds = new Set(["b"]);
+    const d3 = emptyDay(eightDaysAgo);
+    d3.cost = 3;
+    d3.sessionIds = new Set(["c"]);
+    const days = [d1, d2, d3];
+
+    // "1d" - only today
+    expect(summarize(days, "1d").totalCost).toBe(1);
+
+    // "7d" - today + yesterday
+    const s7 = summarize(days, "7d");
+    expect(s7.totalCost).toBe(3);
+    expect(s7.daysActive).toBe(2);
+
+    // "30d" - all three (since 8 days is within 30)
+    const s30 = summarize(days, "30d");
+    expect(s30.totalCost).toBe(6);
+    expect(s30.daysActive).toBe(3);
+
+    // "All"
+    const sAll = summarize(days, "All");
+    expect(sAll.totalCost).toBe(6);
+    expect(sAll.daysActive).toBe(3);
+  });
+
+  it("computes daily spend with zero-fill for gaps", () => {
+    const today = new Date();
+    // day0 = 6 days ago, day3 = 3 days ago (both within 7d range)
+    const d0 = new Date(today);
+    d0.setUTCDate(d0.getUTCDate() - 6);
+    const day0 = dateFromISOString(d0.toISOString());
+    const d3 = new Date(today);
+    d3.setUTCDate(d3.getUTCDate() - 3);
+    const day3 = dateFromISOString(d3.toISOString());
+
+    const d1 = emptyDay(day0);
+    d1.cost = 1;
+    const d2 = emptyDay(day3);
+    d2.cost = 2;
+    const days = [d1, d2];
+
+    const s = summarize(days, "7d");
+    expect(s.dailySpend.length).toBeGreaterThanOrEqual(4);
+    // Should include all dates from earliest to latest, with zeros for gaps
+    const dates = s.dailySpend.map((d) => d.date);
+    expect(dates).toContain(day0);
+    expect(dates).toContain(day3);
+
+    // Check gaps are zero-filled (dates between day0 and day3)
+    const spendByDate: Record<string, number> = {};
+    for (const ds of s.dailySpend) spendByDate[ds.date] = ds.cost;
+    expect(spendByDate[day0]).toBe(1);
+    expect(spendByDate[day3]).toBe(2);
+
+    // Verify zeros in between
+    const dMid = new Date(d0);
+    dMid.setUTCDate(dMid.getUTCDate() + 1);
+    const midStr = dateFromISOString(dMid.toISOString());
+    expect(spendByDate[midStr]).toBe(0);
+  });
+
+  it("sorts models by cost descending (then calls descending), tools by count descending", () => {
+    const d = emptyDay("2026-06-08");
+    mergeDay(d, {
+      ...emptyDay(""),
+      modelCost: {
+        free: 0,
+        secondFree: 0,
+        cheap: 0.1,
+        duplicatedCheap: 0.1,
+        expensive: 5.0,
+        mid: 1.0,
+      },
+      modelCount: { free: 12, secondFree: 15, cheap: 10, duplicatedCheap: 8, expensive: 2, mid: 5 },
+      toolCount: { bash: 1, read: 10, edit: 5 },
+    });
+    const days = [d];
+
+    const s = summarize(days, "All");
+    expect(s.models.map((m) => m.model)).toEqual([
+      "expensive",
+      "mid",
+      "cheap",
+      "duplicatedCheap",
+      "secondFree",
+      "free",
+    ]);
+    expect(s.tools.map((t) => t.name)).toEqual(["read", "edit", "bash"]);
+  });
+
+  it("reports todayCost separately", () => {
+    const today = new Date().toISOString().slice(0, 10);
+    const d1 = emptyDay("2026-01-01");
+    d1.cost = 100;
+    const todayAgg = emptyDay(today);
+    todayAgg.cost = 5;
+    const days = [d1, todayAgg];
+
+    const s = summarize(days, "All");
+    expect(s.todayCost).toBe(5);
+  });
+
+  it("returns todayCost 0 when today is not in filtered range", () => {
+    const d1 = emptyDay("2026-06-01");
+    d1.cost = 10;
+    d1.sessionIds = new Set(["s1"]);
+    const days = [d1];
+
+    // 1d range filters to today only, which has no data
+    const s = summarize(days, "1d");
+    expect(s.todayCost).toBe(0);
+    expect(s.totalCost).toBe(0);
+  });
+
+  it("dailySpend for All range is sorted dates without zero-fill", () => {
+    const d1 = emptyDay("2026-06-01");
+    d1.cost = 1;
+    d1.sessionIds = new Set(["a"]);
+    const d2 = emptyDay("2026-06-05");
+    d2.cost = 5;
+    d2.sessionIds = new Set(["b"]);
+    const d3 = emptyDay("2026-06-10");
+    d3.cost = 10;
+    d3.sessionIds = new Set(["c"]);
+    const days = [d3, d1, d2]; // unsorted input
+
+    const s = summarize(days, "All");
+    // All range does NOT zero-fill gaps — returns only days with data
+    expect(s.dailySpend).toHaveLength(3);
+    expect(s.dailySpend[0]).toEqual({ date: "2026-06-01", cost: 1 });
+    expect(s.dailySpend[1]).toEqual({ date: "2026-06-05", cost: 5 });
+    expect(s.dailySpend[2]).toEqual({ date: "2026-06-10", cost: 10 });
+  });
+
+  it("computes all KPIs for multiple-day 7d range", () => {
+    const today = new Date();
+    const day2ago = new Date(today);
+    day2ago.setUTCDate(day2ago.getUTCDate() - 1);
+    const day1ago = new Date(today);
+    day1ago.setUTCDate(day1ago.getUTCDate() - 0);
+
+    const d1date = dateFromISOString(day2ago.toISOString());
+    const d2date = dateFromISOString(day1ago.toISOString());
+
+    const d1 = emptyDay(d1date);
+    mergeDay(d1, {
+      ...emptyDay(""),
+      cost: 2.5,
+      sessionIds: new Set(["s1"]),
+      userMsgs: 5,
+      asstMsgs: 8,
+      toolResults: 3,
+      inTok: 500,
+      outTok: 200,
+      crTok: 10,
+      cwTok: 5,
+      modelCost: { sonnet: 2.0, haiku: 0.5 },
+      modelCount: { sonnet: 4, haiku: 2 },
+      toolCount: { bash: 3, read: 2 },
+      langLines: { TypeScript: 100, Python: 50 },
+      langEdits: { TypeScript: 3, Python: 1 },
+    });
+    const d2 = emptyDay(d2date);
+    mergeDay(d2, {
+      ...emptyDay(""),
+      cost: 1.5,
+      sessionIds: new Set(["s2"]),
+      userMsgs: 3,
+      asstMsgs: 4,
+      toolResults: 1,
+      inTok: 300,
+      outTok: 100,
+      crTok: 0,
+      cwTok: 0,
+      modelCost: { sonnet: 1.5 },
+      modelCount: { sonnet: 3 },
+      toolCount: { edit: 1, write: 1 },
+      langLines: { Python: 200 },
+      langEdits: { Python: 2 },
+    });
+    const days = [d1, d2];
+
+    const s = summarize(days, "7d");
+    expect(s.totalCost).toBe(4.0);
+    expect(s.sessionCount).toBe(2);
+    expect(s.totalMessages).toBe(24); // 5+8+3 + 3+4+1
+    expect(s.totalInputTokens).toBe(800); // 500 + 300
+    expect(s.totalOutputTokens).toBe(300); // 200 + 100
+    expect(s.totalCacheReadTokens).toBe(10); // 10 + 0
+    expect(s.totalCacheWriteTokens).toBe(5); // 5 + 0
+    expect(s.totalTokens).toBe(1115); // 500+200+10+5 + 300+100
+    expect(s.daysActive).toBe(2);
+    expect(s.avgCostPerDay).toBeCloseTo(2.0);
+
+    // Languages sorted by lines descending
+    expect(s.languages).toEqual([
+      { language: "Python", lines: 250, edits: 3 },
+      { language: "TypeScript", lines: 100, edits: 3 },
+    ]);
+
+    // Models sorted by cost
+    expect(s.models).toEqual([
+      { model: "sonnet", cost: 3.5, calls: 7 },
+      { model: "haiku", cost: 0.5, calls: 2 },
+    ]);
+  });
+
+  it("hourlySpend for 1d range has 24 zero-filled entries when no hourly cost", () => {
+    const today = dateFromISOString(new Date().toISOString());
+    const d = emptyDay(today);
+    d.cost = 5;
+    d.sessionIds = new Set(["s1"]);
+    const days = [d];
+
+    const s = summarize(days, "1d");
+    expect(s.hourlySpend).toHaveLength(24);
+    for (const h of s.hourlySpend) {
+      expect(h.cost).toBe(0);
+    }
+    // Zero-cost days still produce 24 entries
+    const d2 = emptyDay(dateFromISOString(new Date().toISOString()));
+    d2.cost = 0;
+    d2.sessionIds = new Set(["s2"]);
+    const s2 = summarize([d2], "1d");
+    expect(s2.hourlySpend).toHaveLength(24);
+  });
+
+  it("hourlySpend for 1d maps cost to correct hours", () => {
+    const today = dateFromISOString(new Date().toISOString());
+    const d = emptyDay(today);
+    mergeDay(d, {
+      ...emptyDay(""),
+      cost: 3.5,
+      hourCost: { 10: 1.5, 14: 2.0 },
+    });
+    const days = [d];
+
+    const s = summarize(days, "1d");
+    expect(s.hourlySpend).toHaveLength(24);
+    expect(s.hourlySpend[10]!.cost).toBe(1.5);
+    expect(s.hourlySpend[14]!.cost).toBe(2.0);
+    expect(s.hourlySpend[0]!.cost).toBe(0);
+    expect(s.hourlySpend[23]!.cost).toBe(0);
+  });
+
+  it("hourlySpend is empty for 7d, 30d, All ranges", () => {
+    const d = emptyDay("2026-06-01");
+    d.cost = 5;
+    d.sessionIds = new Set(["s1"]);
+    const days = [d];
+
+    expect(summarize(days, "7d").hourlySpend).toEqual([]);
+    expect(summarize(days, "30d").hourlySpend).toEqual([]);
+    expect(summarize(days, "All").hourlySpend).toEqual([]);
+  });
+});

package/src/__tests__/e2e.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { allRanges } from "../components/__tests__/Dashboard.test";
+import { Dashboard } from "../components/Dashboard";
+import { summarize } from "../compute";
+import { parseFile } from "../parser";
+import { type DayAgg } from "../types";
+import { makeMockTUI, makeRangeSelector, makeTheme } from "./components.fixtures";
+
+const mockTui = makeMockTUI();
+
+describe("JSONL → Dashboard", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = join(tmpdir(), `pi-atlas-integration-${Date.now()}`);
+    await mkdir(tmpDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  function daysFromMap(map: Map<string, DayAgg>): DayAgg[] {
+    return [...map.values()].sort((a, b) => a.date.localeCompare(b.date));
+  }
+
+  it("end-to-end: JSONL with session and messages → Dashboard Overview shows KPIs", async () => {
+    const filePath = join(tmpDir, "session.jsonl");
+    const jsonlLines = [
+      JSON.stringify({
+        type: "session",
+        version: 3,
+        id: "s1",
+        timestamp: "2026-06-08T10:00:00.000Z",
+        cwd: "/home/doe/proj",
+      }),
+      JSON.stringify({
+        type: "message",
+        id: "m1",
+        parentId: "p",
+        timestamp: "2026-06-08T10:01:00.000Z",
+        message: { role: "user", content: [{ type: "text", text: "hello" }] },
+      }),
+      JSON.stringify({
+        type: "message",
+        id: "m2",
+        parentId: "m1",
+        timestamp: "2026-06-08T10:02:00.000Z",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: "hi there" },
+            {
+              type: "toolCall",
+              id: "t1",
+              name: "read",
+              arguments: { path: "/src/foo.ts" },
+            },
+          ],
+          model: "claude-sonnet-4-20250514",
+          usage: {
+            input: 200,
+            output: 100,
+            cacheRead: 10,
+            cacheWrite: 0,
+            totalTokens: 310,
+            cost: {
+              input: 0.001,
+              output: 0.0005,
+              cacheRead: 0.00001,
+              cacheWrite: 0,
+              total: 0.00151,
+            },
+          },
+        },
+      }),
+    ];
+    await writeFile(filePath, jsonlLines.join("\n"));
+
+    // Parse
+    const map = parseFile(filePath);
+    const days = daysFromMap(map);
+    expect(days.length).toBeGreaterThan(0);
+
+    // Summarize for all ranges
+    const ranges = allRanges;
+    const summaries = new Map(ranges.map((r) => [r, summarize(days, r)] as const));
+
+    // Render dashboard
+    const dash = new Dashboard(
+      summaries,
+      makeTheme(),
+      mockTui,
+      null,
+      makeRangeSelector(makeTheme()),
+    );
+    const rendered = dash.render(80);
+    const text = rendered.join("\n");
+
+    // Should contain dashboard chrome
+    expect(text).toContain("Overview");
+    expect(text).toContain("Languages");
+    expect(text).toContain("Models");
+    expect(text).toContain("Projects");
+    expect(text).toContain("Usage");
+
+    // Range selector
+    expect(rendered[0]).toContain("Pi Atlas");
+    expect(rendered[0]).toContain("All time [r]");
+  });
+
+  it("end-to-end: Navigate to Languages tab shows ranked table from parsed data", async () => {
+    const filePath = join(tmpDir, "lang-session.jsonl");
+    const jsonlLines = [
+      JSON.stringify({
+        type: "session",
+        version: 3,
+        id: "s1",
+        timestamp: "2026-06-08T10:00:00.000Z",
+        cwd: "/home/doe/proj",
+      }),
+      JSON.stringify({
+        type: "message",
+        id: "m1",
+        parentId: "p",
+        timestamp: "2026-06-08T10:01:00.000Z",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "t1",
+              name: "edit",
+              arguments: { path: "/src/main.ts", edits: [{ newText: "console.log('hi')" }] },
+            },
+            {
+              type: "toolCall",
+              id: "t2",
+              name: "write",
+              arguments: { path: "/src/lib.rs", content: "fn main() {}" },
+            },
+          ],
+          model: "sonnet",
+          usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+          },
+        },
+      }),
+    ];
+    await writeFile(filePath, jsonlLines.join("\n"));
+
+    const map = parseFile(filePath);
+    const days = daysFromMap(map);
+    const ranges = allRanges;
+    const summaries = new Map(ranges.map((r) => [r, summarize(days, r)] as const));
+
+    const dash = new Dashboard(
+      summaries,
+      makeTheme(),
+      mockTui,
+      null,
+      makeRangeSelector(makeTheme()),
+    );
+    // Navigate to Languages tab (index 1)
+    dash.handleInput("\x1b[C"); // right arrow
+
+    const rendered = dash.render(80);
+    const text = rendered.join("\n");
+
+    // Should show language data from parsed file
+    expect(text).toContain("TypeScript");
+    expect(text).toContain("Rust");
+  });
+});