@mohndoe/pi-atlas 0.1.1 → 0.1.3

package/src/compute.ts

@@ -6,6 +6,7 @@ import type {
   LangStat,
   ModelStat,
   ProjectStat,
+  ProviderStat,
   StatsSummary,
   TimeRange,
   ToolStat,
@@ -98,6 +99,10 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
   const projectCost: Record<string, number> = {};
   const projectSessions: Record<string, Set<string>> = {};
   const toolCount: Record<string, number> = {};
+  let compactionCount = 0;
+  let compactedTokens = 0;
+  let modelChanges = 0;
+  const thinkingLevelCount: Record<string, number> = {};
 
   let modelToProvider: Map<string, string> = new Map();
 
@@ -110,10 +115,9 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     totalCacheReadTokens += day.crTok;
     totalCacheWriteTokens += day.cwTok;
 
-    modelToProvider = new Map([
-      ...(modelToProvider.size > 0 ? modelToProvider.entries() : []),
-      ...(day.modelToProvider.size > 0 ? day.modelToProvider.entries() : []),
-    ]);
+    for (const [model, provider] of day.modelToProvider) {
+      modelToProvider.set(model, provider);
+    }
 
     if (day.date === todayStr) todayCost += day.cost;
 
@@ -157,6 +161,13 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     for (const [tool, count] of Object.entries(day.toolCount)) {
       toolCount[tool] = (toolCount[tool] ?? 0) + count;
     }
+
+    compactionCount += day.compactionCount;
+    compactedTokens += day.compactedTokens;
+    modelChanges += day.modelChanges;
+    for (const [level, count] of Object.entries(day.thinkingLevelCount)) {
+      thinkingLevelCount[level] = (thinkingLevelCount[level] ?? 0) + count;
+    }
   }
 
   const daysActive = filtered.filter((d) => d.sessionIds.size > 0).length;
@@ -186,6 +197,10 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     .map(([tool, count]) => ({ name: tool, count }))
     .sort((a, b) => b.count - a.count);
 
+  const providers: ProviderStat[] = Object.entries(providerCost)
+    .map(([provider, cost]) => ({ provider, cost, calls: providerCount[provider] ?? 0 }))
+    .sort((a, b) => b.cost - a.cost || b.calls - a.calls);
+
   const hourlySpend = buildHourlySpend(filtered, range);
 
   return {
@@ -204,6 +219,11 @@ export function summarize(days: DayAgg[], range: TimeRange): StatsSummary {
     models,
     projects,
     tools,
+    providers,
+    compactionCount,
+    compactedTokens,
+    modelChanges,
+    thinkingLevelCount,
     dailySpend: fillDailySpend(filtered, range),
     hourlySpend,
   };

package/src/{__tests__/format.test.ts → format.test.ts}

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import {
+  EXT_TO_LANG,
   MONTH_NAMES,
   dateFromISOString,
   formatCacheTimestamp,
@@ -8,7 +9,8 @@ import {
   formatNumber,
   langFromPath,
   projectNameFromCwd,
-} from "../format";
+  stripAnsi,
+} from "./format";
 
 describe("formatModelName", () => {
   it("handles standard model names", () => {
@@ -25,6 +27,18 @@ describe("formatModelName", () => {
   it("strips YYYY-MM-DD date suffix", () => {
     expect(formatModelName("some-model-2025-05-14")).toBe("Some Model");
   });
+
+  it("handles underscore separators", () => {
+    expect(formatModelName("deepseek_v4_pro")).toBe("Deepseek V4 Pro");
+  });
+
+  it("handles mixed separators", () => {
+    expect(formatModelName("claude-opus_4")).toBe("Claude Opus 4");
+  });
+
+  it("handles empty string", () => {
+    expect(formatModelName("")).toBe("");
+  });
 });
 
 describe("langFromPath", () => {
@@ -68,6 +82,28 @@ describe("langFromPath", () => {
     expect(langFromPath("/src/Foo.TS")).toBe("TypeScript");
     expect(langFromPath("/src/Foo.PY")).toBe("Python");
   });
+
+  it("handles multi-dot filenames", () => {
+    expect(langFromPath("/src/foo.min.js")).toBe("JavaScript");
+  });
+
+  it("handles hidden files (dotfiles) as extensions", () => {
+    expect(langFromPath("/src/.gitignore")).toBe("Gitignore");
+  });
+
+  it("handles Jinja compound extensions", () => {
+    expect(langFromPath("/templates/page.html.j2")).toBe("Jinja");
+  });
+
+  it("handles file named only .extension", () => {
+    expect(langFromPath("/src/.ts")).toBe("TypeScript");
+  });
+
+  it("maps all EXT_TO_LANG entries correctly", () => {
+    for (const [ext, expected] of Object.entries(EXT_TO_LANG)) {
+      expect(langFromPath(`/file.${ext}`)).toBe(expected);
+    }
+  });
 });
 
 describe("projectNameFromCwd", () => {
@@ -82,6 +118,19 @@ describe("projectNameFromCwd", () => {
   it("strips trailing slash like basename", () => {
     expect(projectNameFromCwd("/home/doe/proj/")).toBe("proj");
   });
+
+  it("handles root path", () => {
+    expect(projectNameFromCwd("/")).toBe("");
+  });
+
+  it("handles empty string", () => {
+    expect(projectNameFromCwd("")).toBe("");
+  });
+
+  it("handles relative path components", () => {
+    expect(projectNameFromCwd(".")).toBe(".");
+    expect(projectNameFromCwd("..")).toBe("..");
+  });
 });
 
 describe("dateFromISOString", () => {
@@ -92,6 +141,14 @@ describe("dateFromISOString", () => {
   it("works on date-only", () => {
     expect(dateFromISOString("2026-12-31")).toBe("2026-12-31");
   });
+
+  it("handles empty string", () => {
+    expect(dateFromISOString("")).toBe("");
+  });
+
+  it("handles short string", () => {
+    expect(dateFromISOString("2026")).toBe("2026");
+  });
 });
 
 describe("formatNumber", () => {
@@ -102,38 +159,111 @@ describe("formatNumber", () => {
   });
 
   it("formats thousands with k", () => {
-    expect(formatNumber(1000)).toBe("1.0k");
+    expect(formatNumber(1000)).toBe("1k");
     expect(formatNumber(1500)).toBe("1.5k");
-    expect(formatNumber(999999)).toBe("1000.0k");
+    expect(formatNumber(1510)).toBe("1.51k");
+    expect(formatNumber(1517)).toBe("1.52k");
+    expect(formatNumber(999999)).toBe("1,000k");
   });
 
   it("formats millions with M", () => {
-    expect(formatNumber(1_000_000)).toBe("1.00M");
-    expect(formatNumber(2_500_000)).toBe("2.50M");
+    expect(formatNumber(1_000_000)).toBe("1M");
+    expect(formatNumber(2_500_000)).toBe("2.5M");
   });
 
   it("formats billions with B", () => {
-    expect(formatNumber(1_000_000_000)).toBe("1.00B");
-    expect(formatNumber(2_500_000_000)).toBe("2.50B");
+    expect(formatNumber(1_000_000_000)).toBe("1B");
+    expect(formatNumber(2_500_000_000)).toBe("2.5B");
+    expect(formatNumber(12_530_000_000)).toBe("12.53B");
+    expect(formatNumber(12_533_000_000)).toBe("12.53B");
+    expect(formatNumber(12_538_000_000)).toBe("12.54B");
+  });
+
+  it("handles negative numbers (no suffix — current behavior)", () => {
+    // Negative numbers fall through all n >= threshold checks
+    expect(formatNumber(-500)).toBe("-500");
+    expect(formatNumber(-1500)).toBe("-1500");
+    expect(formatNumber(-2_500_000)).toBe("-2500000");
+  });
+
+  it("handles boundary values", () => {
+    expect(formatNumber(999)).toBe("999");
+    expect(formatNumber(1000)).toBe("1k");
+    expect(formatNumber(999_999)).toBe("1,000k");
+    expect(formatNumber(1_000_000)).toBe("1M");
+    expect(formatNumber(999_999_999)).toBe("1,000M");
+    expect(formatNumber(1_000_000_000)).toBe("1B");
+  });
+
+  it("handles large numbers beyond billions", () => {
+    expect(formatNumber(1_000_000_000_000)).toBe("1,000B");
   });
 });
 
 describe("formatCost", () => {
-  it("formats small costs with $ and two decimals", () => {
-    expect(formatCost(0)).toBe("$0.00");
-    expect(formatCost(1.5)).toBe("$1.50");
+  it("formats small costs with $ and least decimals possible", () => {
+    expect(formatCost(0)).toBe("$0");
+    expect(formatCost(1.5)).toBe("$1.5");
     expect(formatCost(999.99)).toBe("$999.99");
   });
 
   it("formats thousands with k", () => {
-    expect(formatCost(1000)).toBe("$1.0k");
+    expect(formatCost(1000)).toBe("$1k");
     expect(formatCost(1500)).toBe("$1.5k");
   });
 
   it("formats millions with M", () => {
-    expect(formatCost(1_000_000)).toBe("$1.0M");
+    expect(formatCost(1_000_000)).toBe("$1M");
     expect(formatCost(2_500_000)).toBe("$2.5M");
   });
+
+  it("handles boundary values", () => {
+    expect(formatCost(999.99)).toBe("$999.99");
+    expect(formatCost(1000)).toBe("$1k");
+    expect(formatCost(999_999)).toBe("$1,000k");
+    expect(formatCost(1_000_000)).toBe("$1M");
+  });
+
+  it("handles costs above billions", () => {
+    expect(formatCost(1_000_000_000)).toBe("$1,000M");
+  });
+});
+
+describe("stripAnsi", () => {
+  it("passes through plain text unchanged", () => {
+    expect(stripAnsi("hello world")).toBe("hello world");
+  });
+
+  it("strips ANSI color codes", () => {
+    expect(stripAnsi("\x1b[32mgreen\x1b[0m")).toBe("green");
+  });
+
+  it("strips ANSI cursor and erase sequences", () => {
+    expect(stripAnsi("\x1b[2J\x1b[Hclear")).toBe("clear");
+  });
+
+  it("strips ANSI underline codes", () => {
+    expect(stripAnsi("\x1b[4munderlined\x1b[24m")).toBe("underlined");
+  });
+
+  it("strips control characters", () => {
+    expect(stripAnsi("line1\x00line2")).toBe("line1line2");
+    expect(stripAnsi("a\x08b")).toBe("ab");
+  });
+
+  it("strips zero-width and formatting characters", () => {
+    expect(stripAnsi("a\u200Bb")).toBe("ab");
+    expect(stripAnsi("a\uFEFFb")).toBe("ab");
+  });
+
+  it("strips OSC sequences (\x1b]...\x07)", () => {
+    const osc = "\x1b]0;My Title\x07content";
+    expect(stripAnsi(osc)).toBe("content");
+  });
+
+  it("handles empty string", () => {
+    expect(stripAnsi("")).toBe("");
+  });
 });
 
 describe("formatCacheTimestamp", () => {
@@ -155,60 +285,72 @@ describe("formatCacheTimestamp", () => {
   });
 
   it("shows date for older dates this year", () => {
-    const old = new Date("2026-01-15T14:30:00Z");
+    const year = new Date().getFullYear();
+    const old = new Date(year, 0, 15, 14, 30, 0);
     const iso = old.toISOString();
     const result = formatCacheTimestamp(iso);
-    expect(result).toMatch(/^Jan 15,/);
+    const monthName = MONTH_NAMES[old.getMonth()];
+    const day = old.getDate();
+    expect(result).toMatch(new RegExp(`^${monthName} ${day},`));
+    expect(result).not.toContain(String(year));
   });
 
   it("shows date with year for previous year", () => {
-    const old = new Date("2025-06-10T09:15:00Z");
+    const year = new Date().getFullYear() - 1;
+    const old = new Date(year, 5, 10, 9, 15, 0);
     const iso = old.toISOString();
     const result = formatCacheTimestamp(iso);
-    expect(result).toMatch(/2025/);
+    expect(result).toMatch(new RegExp(String(year)));
   });
 
   // ---- Timezone-awareness tests ----
 
-  it("formats time in local timezone (not UTC)", () => {
+  it("formats time in local timezone", () => {
     const d = new Date("2026-06-15T07:30:00Z");
     const iso = d.toISOString();
     const result = formatCacheTimestamp(iso);
 
+    // Compute expected local time using the same algorithm as the source
     const localHr = d.getHours();
     const localMin = d.getMinutes();
-    const utcHr = d.getUTCHours();
-
     const h12 = localHr % 12 || 12;
     const ampm = localHr >= 12 ? "PM" : "AM";
     const expectedLocal = `${h12}:${String(localMin).padStart(2, "0")} ${ampm}`;
 
+    // Always asserts local time format is shown
     expect(result).toContain(expectedLocal);
 
-    // When local time differs from UTC, verify UTC time is NOT shown
-    if (localHr !== utcHr) {
+    // When the machine is not in UTC, also verify the UTC time is absent.
+    // In UTC (offset=0) this guard is skipped because local===UTC,
+    // so timezone correctness can only be fully validated on non-UTC CI.
+    if (d.getTimezoneOffset() !== 0) {
+      const utcHr = d.getUTCHours();
       const utcH12 = utcHr % 12 || 12;
       const utcAmpm = utcHr >= 12 ? "PM" : "AM";
       expect(result).not.toContain(`${utcH12}:${String(localMin).padStart(2, "0")} ${utcAmpm}`);
     }
   });
 
-  it("uses local month/day (not UTC) for older date display", () => {
+  it("uses local month/day for older date display", () => {
     const d = new Date("2026-01-15T12:00:00Z");
     const iso = d.toISOString();
     const result = formatCacheTimestamp(iso);
 
+    // Compute expected local date using the same algorithm as the source
     const localMonth = d.getMonth();
     const localDay = d.getDate();
-    const utcMonth = d.getUTCMonth();
-    const utcDay = d.getUTCDate();
-
-    // Output should contain local month/day
-    expect(result).toMatch(new RegExp(`${MONTH_NAMES[localMonth]} ${localDay},`));
-
-    // If local date differs from UTC date, verify UTC date is NOT shown
-    if (localMonth !== utcMonth || localDay !== utcDay) {
-      expect(result).not.toMatch(new RegExp(`${MONTH_NAMES[utcMonth]} ${utcDay},`));
+    const localStr = `${MONTH_NAMES[localMonth]} ${localDay},`;
+
+    expect(result).toMatch(new RegExp(localStr));
+
+    // When the machine is not in UTC, also verify UTC date is absent.
+    if (d.getTimezoneOffset() !== 0) {
+      const utcMonth = d.getUTCMonth();
+      const utcDay = d.getUTCDate();
+      const utcStr = `${MONTH_NAMES[utcMonth]} ${utcDay},`;
+      if (localStr !== utcStr) {
+        expect(result).not.toMatch(new RegExp(utcStr));
+      }
     }
   });
 

package/src/format.ts

@@ -137,19 +137,32 @@ export const MONTH_NAMES = [
   "Dec",
 ];
 
+const numberFormatter = new Intl.NumberFormat("en-US", {
+  style: "decimal",
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2,
+});
+
+const usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2,
+});
+
 // ---- Number formatting ----
 
 export function formatNumber(n: number): string {
-  if (n >= 1_000_000_000) return (n / 1_000_000_000).toFixed(2) + "B";
-  if (n >= 1_000_000) return (n / 1_000_000).toFixed(2) + "M";
-  if (n >= 1_000) return (n / 1_000).toFixed(1) + "k";
+  if (n >= 1_000_000_000) return numberFormatter.format(n / 1_000_000_000) + "B";
+  if (n >= 1_000_000) return numberFormatter.format(n / 1_000_000) + "M";
+  if (n >= 1_000) return numberFormatter.format(n / 1_000) + "k";
   return String(n);
 }
 
 export function formatCost(n: number): string {
-  if (n >= 1_000_000) return "$" + (n / 1_000_000).toFixed(1) + "M";
-  if (n >= 1_000) return "$" + (n / 1_000).toFixed(1) + "k";
-  return "$" + n.toFixed(2);
+  if (n >= 1_000_000) return usdFormatter.format(n / 1_000_000) + "M";
+  if (n >= 1_000) return usdFormatter.format(n / 1_000) + "k";
+  return usdFormatter.format(n);
 }
 
 // ---- Timestamp formatting ----
@@ -204,7 +217,7 @@ export function formatCacheTimestamp(iso: string): string {
 export function stripAnsi(text: string): string {
   // First strip ANSI sequences
   let clean = text.replace(
-    /[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]|(?:\u001B\][\s\S]*?(?:\u0007|\u001B\\|\u009C))/g,
+    /(?:\u001B\][\s\S]*?(?:\u0007|\u001B\\|\u009C))|[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]/g,
     "",
   );
   // Then strip control characters that can break terminal rendering

package/src/index.ts

@@ -8,6 +8,7 @@ import { summarize } from "./compute";
 import { formatCacheTimestamp } from "./format";
 import type { TimeRange } from "./types";
 import { RangeSelector, type RangeOption } from "./components/RangeSelector";
+import type { OverlayOptions } from "@earendil-works/pi-tui";
 
 const SESSIONS_DIR = join(homedir(), ".pi", "agent", "sessions");
 const CACHE_PATH = join(homedir(), ".pi", "pi-atlas-cache.json");
@@ -22,14 +23,14 @@ export default function (pi: ExtensionAPI) {
       }
 
       const overlayOpts = {
-        overlay: true as const,
+        overlay: true,
         overlayOptions: {
           minWidth: 100,
-          width: "50%" as const,
-          maxHeight: "80%" as const,
-          anchor: "center" as const,
+          width: "50%",
+          maxHeight: "80%",
+          anchor: "top-center",
           margin: 2,
-        },
+        } as OverlayOptions,
       };
 
       // Read last update timestamp before loading (cache may be rewritten)
@@ -37,28 +38,30 @@ export default function (pi: ExtensionAPI) {
       const updateLabel = lastUpdate ? `Last update : ${formatCacheTimestamp(lastUpdate)}` : null;
 
       // Phase 1: Show loading, parse session logs
-      let days: Awaited<ReturnType<typeof loadAggregate>>;
+      let days: Awaited<ReturnType<typeof loadAggregate> | undefined>;
       try {
-        days = await ctx.ui.custom<Awaited<ReturnType<typeof loadAggregate>>>(
-          (tui, _theme, _kb, done) => {
-            const loadingView = new LoadingView("Parsing session logs...", tui);
+        days = await ctx.ui.custom<typeof days>((tui, theme, _kb, done) => {
+          const loadingView = new LoadingView("Parsing session logs...", theme, () =>
+            done(undefined),
+          );
 
-            loadAggregate(CACHE_PATH, SESSIONS_DIR, false, (p) => {
-              loadingView.setProgress(p);
-              tui.requestRender();
-            })
-              .then((result) => done(result))
-              .catch(() => done([]));
+          loadAggregate(CACHE_PATH, SESSIONS_DIR, false, (p) => {
+            loadingView.setProgress(p);
+            tui.requestRender();
+          })
+            .then((result) => done(result))
+            .catch(() => done([]));
 
-            return loadingView;
-          },
-          overlayOpts,
-        );
-      } catch {
+          return loadingView;
+        }, overlayOpts);
+      } catch (e) {
         ctx.ui.notify("Failed to parse session logs", "error");
+        ctx.ui.notify(e as string, "error");
         return;
       }
 
+      if (days === undefined) return;
+
       // Phase 2: Show dashboard (handles empty state internally)
       const rangesToSummarize: TimeRange[] = ["1d", "7d", "30d", "All"];
       const summaries = new Map(rangesToSummarize.map((r) => [r, summarize(days, r)] as const));