@mohndoe/pi-atlas 0.1.1

package/src/format.ts

@@ -0,0 +1,219 @@
+import { basename } from "node:path";
+
+// ---- Language detection ----
+
+export const EXT_TO_LANG: Record<string, string> = {
+  astro: "Astro",
+  bash: "Shell",
+  c: "C",
+  cc: "C++",
+  cjs: "JavaScript",
+  clj: "Clojure",
+  cljs: "Clojure",
+  coffee: "CoffeeScript",
+  cpp: "C++",
+  cr: "Crystal",
+  cs: "C#",
+  css: "CSS",
+  cts: "TypeScript",
+  dart: "Dart",
+  dockerfile: "Dockerfile",
+  ejs: "EJS",
+  elm: "Elm",
+  env: "Env",
+  erl: "Erlang",
+  ex: "Elixir",
+  exs: "Elixir",
+  fs: "F#",
+  fsi: "F#",
+  fsx: "F#",
+  gitignore: "Gitignore",
+  gleam: "Gleam",
+  go: "Go",
+  gql: "GraphQL",
+  graphql: "GraphQL",
+  graphqls: "GraphQL",
+  groovy: "Groovy",
+  h: "C",
+  hbs: "Handlebars",
+  hpp: "C++",
+  hs: "Haskell",
+  htm: "HTML",
+  html: "HTML",
+  "html.j2": "Jinja",
+  j2: "Jinja",
+  java: "Java",
+  jinja: "Jinja",
+  jinja2: "Jinja",
+  jl: "Julia",
+  js: "JavaScript",
+  json: "JSON",
+  jsx: "JavaScript",
+  kt: "Kotlin",
+  kts: "Kotlin",
+  less: "Less",
+  liquid: "Liquid",
+  lua: "Lua",
+  m: "Objective-C",
+  md: "Markdown",
+  mdx: "Markdown",
+  mjs: "JavaScript",
+  mm: "Objective-C",
+  mts: "TypeScript",
+  mustache: "Mustache",
+  nix: "Nix",
+  njk: "Nunjucks",
+  php: "PHP",
+  phtml: "PHP",
+  pl: "Perl",
+  pm: "Perl",
+  prisma: "Prisma",
+  proto: "Protobuf",
+  ps1: "PowerShell",
+  psd1: "PowerShell",
+  psm1: "PowerShell",
+  pug: "Pug",
+  py: "Python",
+  pyi: "Python",
+  qml: "QML",
+  r: "R",
+  raku: "Raku",
+  rb: "Ruby",
+  rs: "Rust",
+  scala: "Scala",
+  scss: "SCSS",
+  sh: "Shell",
+  sol: "Solidity",
+  sql: "SQL",
+  styl: "Stylus",
+  svelte: "Svelte",
+  swift: "Swift",
+  tf: "Terraform",
+  toml: "TOML",
+  ts: "TypeScript",
+  tsx: "TypeScript",
+  twig: "Twig",
+  vue: "Vue",
+  wasm: "WebAssembly",
+  wat: "WebAssembly",
+  xml: "XML",
+  yaml: "YAML",
+  yml: "YAML",
+  zig: "Zig",
+  zsh: "Shell",
+};
+
+export function langFromPath(path: string): string {
+  const ext = basename(path).split(".").pop()?.toLowerCase() ?? "";
+  return EXT_TO_LANG[ext] ?? "Other";
+}
+
+// ---- Project name extraction ----
+
+export function projectNameFromCwd(cwd: string): string {
+  return basename(cwd);
+}
+
+// ---- Date utilities ----
+
+export function dateFromISOString(str: string): string {
+  return str.slice(0, 10);
+}
+
+// ---- Month / day constants ----
+
+export const MONTH_NAMES = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+// ---- 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";
+  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);
+}
+
+// ---- Timestamp formatting ----
+
+function localDatePart(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function formatTime(d: Date): string {
+  const h = d.getHours();
+  const m = d.getMinutes();
+  const ampm = h >= 12 ? "PM" : "AM";
+  const h12 = h % 12 || 12;
+  return `${h12}:${m.toString().padStart(2, "0")} ${ampm}`;
+}
+
+export function formatCacheTimestamp(iso: string): string {
+  const d = new Date(iso);
+  const time = formatTime(d);
+
+  const now = new Date();
+  const today = localDatePart(now);
+  const yesterday = localDatePart(new Date(now.getTime() - 86400000));
+  const thisYear = now.getFullYear();
+
+  const dayPart = localDatePart(d);
+
+  if (dayPart === today) {
+    return time;
+  }
+
+  if (dayPart === yesterday) {
+    return `Yesterday ${time}`;
+  }
+
+  const month = MONTH_NAMES[d.getMonth()];
+  const day = d.getDate();
+
+  if (d.getFullYear() === thisYear) {
+    return `${month} ${day}, ${time}`;
+  }
+
+  return `${month} ${day}, ${d.getFullYear()}`;
+}
+
+// ---- Model name formatting ----
+
+/** Strip ANSI escape sequences and control characters that can break terminal rendering. */
+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,
+    "",
+  );
+  // Then strip control characters that can break terminal rendering
+  return clean.replace(/[\x00-\x08\x0A-\x1F\x7F\u200B-\u200F\u2028-\u2029\uFEFF]/g, "");
+}
+
+export function formatModelName(raw: string): string {
+  // Strip date suffix (YYYYMMDD or YYYY-MM-DD)
+  let name = raw.replace(/-\d{8}$/, "").replace(/-\d{4}-\d{2}-\d{2}$/, "");
+  // Replace separators with spaces, title case each word
+  return name.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}

package/src/index.ts

@@ -0,0 +1,88 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getCacheTimestamp, loadAggregate } from "./cache";
+import { Dashboard } from "./components/Dashboard";
+import { LoadingView } from "./components/LoadingView";
+import { summarize } from "./compute";
+import { formatCacheTimestamp } from "./format";
+import type { TimeRange } from "./types";
+import { RangeSelector, type RangeOption } from "./components/RangeSelector";
+
+const SESSIONS_DIR = join(homedir(), ".pi", "agent", "sessions");
+const CACHE_PATH = join(homedir(), ".pi", "pi-atlas-cache.json");
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("atlas", {
+    description: "Show Pi Atlas usage dashboard",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Stats dashboard requires interactive mode", "error");
+        return;
+      }
+
+      const overlayOpts = {
+        overlay: true as const,
+        overlayOptions: {
+          minWidth: 100,
+          width: "50%" as const,
+          maxHeight: "80%" as const,
+          anchor: "center" as const,
+          margin: 2,
+        },
+      };
+
+      // Read last update timestamp before loading (cache may be rewritten)
+      const lastUpdate = await getCacheTimestamp(CACHE_PATH);
+      const updateLabel = lastUpdate ? `Last update : ${formatCacheTimestamp(lastUpdate)}` : null;
+
+      // Phase 1: Show loading, parse session logs
+      let days: Awaited<ReturnType<typeof loadAggregate>>;
+      try {
+        days = await ctx.ui.custom<Awaited<ReturnType<typeof loadAggregate>>>(
+          (tui, _theme, _kb, done) => {
+            const loadingView = new LoadingView("Parsing session logs...", tui);
+
+            loadAggregate(CACHE_PATH, SESSIONS_DIR, false, (p) => {
+              loadingView.setProgress(p);
+              tui.requestRender();
+            })
+              .then((result) => done(result))
+              .catch(() => done([]));
+
+            return loadingView;
+          },
+          overlayOpts,
+        );
+      } catch {
+        ctx.ui.notify("Failed to parse session logs", "error");
+        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));
+
+      await ctx.ui.custom((tui, theme, _kb, done) => {
+        const rangeOptions: RangeOption[] = [
+          { label: "Today", value: "1d" },
+          { label: "Last 7 days", value: "7d" },
+          { label: "Last 30 days", value: "30d" },
+          { label: "All time", value: "All" },
+        ];
+        const rangeSelector = new RangeSelector(theme, rangeOptions, rangeOptions.length - 1);
+        const dashboard = new Dashboard(summaries, theme, tui, updateLabel, rangeSelector, () =>
+          done(undefined),
+        );
+        return {
+          render: (w: number) => dashboard.render(w),
+          handleInput: (d: string) => {
+            dashboard.handleInput(d);
+            tui.requestRender();
+          },
+          invalidate: () => dashboard.invalidate(),
+        };
+      }, overlayOpts);
+    },
+  });
+}

package/src/parser.ts

@@ -0,0 +1,363 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { AssistantMessage, ToolResultMessage } from "@earendil-works/pi-ai";
+import type {
+  CompactionEntry,
+  FileEntry,
+  ModelChangeEntry,
+  SessionHeader,
+  SessionMessageEntry,
+  ThinkingLevelChangeEntry,
+} from "@earendil-works/pi-coding-agent";
+import { readFileSync } from "node:fs";
+
+import { dateFromISOString, langFromPath, projectNameFromCwd } from "./format";
+import type { DayAgg } from "./types";
+
+/** Strip control characters (\n, \r, \t, etc.) from a tool name. */
+function sanitizeToolName(name: string): string {
+  // Remove any character below 0x20 (control chars) except 0x09 (\t) which
+  // we also strip, plus 0x7F (DEL) and Unicode general category Cc/Cf.
+  return name.replace(/[\x00-\x08\x0A-\x1F\x7F\u200B-\u200F\u2028-\u2029\uFEFF]/g, "");
+}
+
+// Tracks session ID → project name for cost attribution
+const sessionProjectMap = new Map<string, string>();
+
+export { sessionProjectMap };
+
+export function emptyDay(date: string): DayAgg {
+  return {
+    date,
+    cost: 0,
+    hourCost: {},
+    inTok: 0,
+    outTok: 0,
+    crTok: 0,
+    cwTok: 0,
+    userMsgs: 0,
+    asstMsgs: 0,
+    toolResults: 0,
+    sessionIds: new Set(),
+    langLines: {},
+    langEdits: {},
+    modelCost: {},
+    modelCount: {},
+    providerCost: {},
+    providerCount: {},
+    modelToProvider: new Map(),
+    projectCost: {},
+    projectSessions: {},
+    toolCount: {},
+    compactionCount: 0,
+    compactedTokens: 0,
+    modelChanges: 0,
+    thinkingLevelCount: {},
+  };
+}
+
+export function mergeDay(base: DayAgg, update: DayAgg): void {
+  base.cost += update.cost;
+  base.inTok += update.inTok;
+  base.outTok += update.outTok;
+  base.crTok += update.crTok;
+  base.cwTok += update.cwTok;
+  base.userMsgs += update.userMsgs;
+  base.asstMsgs += update.asstMsgs;
+  base.toolResults += update.toolResults;
+
+  for (const id of update.sessionIds) base.sessionIds.add(id);
+
+  for (const [h, c] of Object.entries(update.hourCost)) {
+    base.hourCost[Number(h)] = (base.hourCost[Number(h)] ?? 0) + c;
+  }
+
+  for (const [k, v] of Object.entries(update.langLines)) {
+    base.langLines[k] = (base.langLines[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.langEdits)) {
+    base.langEdits[k] = (base.langEdits[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.modelCost)) {
+    base.modelCost[k] = (base.modelCost[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.modelCount)) {
+    base.modelCount[k] = (base.modelCount[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.providerCost)) {
+    base.providerCost[k] = (base.providerCost[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.providerCount)) {
+    base.providerCount[k] = (base.providerCount[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.projectCost)) {
+    base.projectCost[k] = (base.projectCost[k] ?? 0) + v;
+  }
+  for (const [k, v] of Object.entries(update.projectSessions)) {
+    if (!base.projectSessions[k]) base.projectSessions[k] = new Set();
+    for (const id of v) base.projectSessions[k].add(id);
+  }
+  for (const [k, v] of Object.entries(update.toolCount)) {
+    base.toolCount[k] = (base.toolCount[k] ?? 0) + v;
+  }
+
+  // New fields
+  base.compactionCount += update.compactionCount;
+  base.compactedTokens += update.compactedTokens;
+  base.modelChanges += update.modelChanges;
+  for (const [k, v] of Object.entries(update.thinkingLevelCount)) {
+    base.thinkingLevelCount[k] = (base.thinkingLevelCount[k] ?? 0) + v;
+  }
+
+  base.modelToProvider = new Map([
+    ...(base.modelToProvider.size > 0 ? base.modelToProvider.entries() : []),
+    ...(update.modelToProvider.size > 0 ? update.modelToProvider.entries() : []),
+  ]);
+}
+
+// ---- Session header ----
+
+export function parseSessionHeader(entry: SessionHeader): DayAgg {
+  const day = emptyDay(dateFromISOString(entry.timestamp));
+  day.sessionIds.add(entry.id);
+
+  if (entry.cwd) {
+    const proj = projectNameFromCwd(entry.cwd);
+    sessionProjectMap.set(entry.id, proj);
+    day.projectCost[proj] = 0;
+    day.projectSessions[proj] = new Set([entry.id]);
+  }
+
+  return day;
+}
+
+// ---- Message parsing ----
+
+export function parseUserMessage(): DayAgg {
+  const day = emptyDay("");
+  day.userMsgs = 1;
+  return day;
+}
+
+export function parseToolResultMessage(msg: ToolResultMessage): DayAgg {
+  const day = emptyDay("");
+  day.toolResults = 1;
+  if (msg.toolName) {
+    day.toolCount[sanitizeToolName(msg.toolName)] = 1;
+  }
+  return day;
+}
+
+export function parseAssistantMessage(msg: AssistantMessage): DayAgg {
+  const day = emptyDay("");
+  day.asstMsgs = 1;
+
+  if (msg.usage) {
+    day.inTok = msg.usage.input;
+    day.outTok = msg.usage.output;
+    day.crTok = msg.usage.cacheRead;
+    day.cwTok = msg.usage.cacheWrite;
+
+    if (msg.usage.cost) {
+      day.cost = msg.usage.cost.total;
+
+      const activeProjects = new Set(sessionProjectMap.values());
+      for (const proj of activeProjects) {
+        day.projectCost[proj] = (day.projectCost[proj] ?? 0) + msg.usage.cost.total;
+      }
+    }
+  }
+
+  if (msg.model) {
+    day.modelCost[msg.model] = msg.usage?.cost?.total || 0;
+    day.modelCount[msg.model] = 1;
+    if (msg.provider) {
+      day.modelToProvider.set(msg.model, msg.provider);
+      day.providerCost[msg.provider] = msg.usage?.cost?.total || 0;
+      day.providerCount[msg.provider] = 1;
+    }
+  }
+
+  if (msg.content) {
+    for (const block of msg.content) {
+      if (block.type === "toolCall") {
+        const parsedArgs =
+          block.arguments !== undefined
+            ? typeof block.arguments === "string"
+              ? JSON.parse(block.arguments)
+              : block.arguments
+            : undefined;
+        const sanitized = sanitizeToolName(block.name);
+        day.toolCount[sanitized] = (day.toolCount[sanitized] ?? 0) + 1;
+
+        if (block.name === "edit" || block.name === "write") {
+          mergeDay(
+            day,
+            parseLanguageUsage(block.name, parsedArgs as Record<string, unknown> | undefined),
+          );
+        }
+      }
+    }
+  }
+
+  return day;
+}
+
+function countNewLines(s: string): number {
+  return (s.match(/\n/g) ?? []).length;
+}
+
+export function parseLanguageUsage(
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+): DayAgg {
+  const day = emptyDay("");
+  const path = args?.path as string | undefined;
+  if (!path) return day;
+
+  const lang = langFromPath(path);
+
+  if (toolName === "edit") {
+    const edits = args?.edits as Array<{ newText?: string; oldText?: string }> | undefined;
+    if (Array.isArray(edits)) {
+      let totalNewLines = 0;
+      for (const edit of edits) {
+        totalNewLines += countNewLines(edit.newText ?? "") + countNewLines(edit.oldText ?? "") + 1;
+        day.langEdits[lang] = (day.langEdits[lang] ?? 0) + 1;
+      }
+      day.langLines[lang] = (day.langLines[lang] ?? 0) + totalNewLines;
+    } else {
+      day.langLines[lang] = (day.langLines[lang] ?? 0) + 1;
+      day.langEdits[lang] = (day.langEdits[lang] ?? 0) + 1;
+    }
+  } else {
+    const contentStr = args?.content as string | undefined;
+    if (contentStr) {
+      // +1 because no new line is still a line
+      day.langLines[lang] = (day.langLines[lang] ?? 0) + countNewLines(contentStr);
+    }
+    day.langLines[lang] = (day.langLines[lang] ?? 0) + 1;
+  }
+
+  return day;
+}
+
+function parseAgentMessage(msg: AgentMessage): DayAgg {
+  switch (msg.role) {
+    case "user":
+      return parseUserMessage();
+    case "toolResult":
+      return parseToolResultMessage(msg as ToolResultMessage);
+    case "assistant":
+      return parseAssistantMessage(msg as AssistantMessage);
+    // skip non-cost-relevant message types
+    case "bashExecution":
+    case "custom":
+    case "branchSummary":
+    case "compactionSummary":
+    default:
+      return emptyDay("");
+  }
+}
+
+// ---- New entry types ----
+
+export function parseModelChangeEntry(entry: ModelChangeEntry): DayAgg {
+  const day = emptyDay(dateFromISOString(entry.timestamp));
+  day.modelChanges = 1;
+  return day;
+}
+
+export function parseThinkingLevelChangeEntry(entry: ThinkingLevelChangeEntry): DayAgg {
+  const day = emptyDay(dateFromISOString(entry.timestamp));
+  day.thinkingLevelCount[entry.thinkingLevel] = 1;
+  return day;
+}
+
+export function parseCompactionEntry(entry: CompactionEntry): DayAgg {
+  const day = emptyDay(dateFromISOString(entry.timestamp));
+  day.compactionCount = 1;
+  day.compactedTokens = entry.tokensBefore;
+  return day;
+}
+
+// ---- Top-level dispatch ----
+
+export function parseSessionLogEntry(entry: FileEntry): DayAgg | null {
+  // Runtime resilience: JSONL files may contain corrupt data despite typing
+  if (!entry || typeof entry !== "object") return null;
+
+  switch (entry.type) {
+    case "session":
+      return parseSessionHeader(entry as SessionHeader);
+    case "message": {
+      const msgEntry = entry as SessionMessageEntry;
+      const hour = new Date(msgEntry.timestamp).getHours();
+      const day = emptyDay(dateFromISOString(msgEntry.timestamp));
+      mergeDay(day, parseAgentMessage(msgEntry.message));
+      if (day.cost > 0) {
+        day.hourCost[hour] = (day.hourCost[hour] ?? 0) + day.cost;
+      }
+      return day;
+    }
+    case "model_change":
+      return parseModelChangeEntry(entry as ModelChangeEntry);
+    case "thinking_level_change":
+      return parseThinkingLevelChangeEntry(entry as ThinkingLevelChangeEntry);
+    case "compaction":
+      return parseCompactionEntry(entry as CompactionEntry);
+    // Silently skip entry types with no cost-relevant data
+    case "branch_summary":
+    case "custom":
+    case "custom_message":
+    case "label":
+    case "session_info":
+    default:
+      return null;
+  }
+}
+
+// ---- Parse a full JSONL file ----
+
+export function parseFile(
+  filePath: string,
+  onWarning?: (count: number) => void,
+): Map<string, DayAgg> {
+  // Each JSONL file represents one session; reset global session→project
+  // tracking so costs from previous files don't leak across projects.
+  sessionProjectMap.clear();
+
+  const map = new Map<string, DayAgg>();
+
+  let content: string;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return map;
+  }
+
+  const lines = content.split("\n");
+  let corruptCount = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    try {
+      const entry = JSON.parse(trimmed) as FileEntry;
+      const result = parseSessionLogEntry(entry);
+      if (result) {
+        const existing = map.get(result.date);
+        if (existing) {
+          mergeDay(existing, result);
+        } else {
+          map.set(result.date, result);
+        }
+      }
+    } catch {
+      corruptCount++;
+      if (onWarning) onWarning(corruptCount);
+    }
+  }
+
+  return map;
+}