@mohndoe/pi-atlas 0.1.1

package/src/cache.ts

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { mergeDay, parseFile } from "./parser";
+import type { CachePayload, DayAgg, SerializedDayAgg } from "./types";
+
+// ---- Signature ----
+
+export async function computeSignature(sessionsDir: string): Promise<string> {
+  const hash = createHash("sha256");
+  const entries: Array<{ path: string; size: number; mtimeMs: number }> = [];
+
+  async function walk(dir: string): Promise<void> {
+    let dirents;
+    try {
+      dirents = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const d of dirents) {
+      const full = join(dir, d.name);
+      if (d.isDirectory()) {
+        await walk(full);
+      } else if (d.isFile() && d.name.endsWith(".jsonl")) {
+        const s = await stat(full);
+        entries.push({ path: full, size: s.size, mtimeMs: s.mtimeMs });
+      }
+    }
+  }
+
+  await walk(sessionsDir);
+
+  if (entries.length === 0) return "";
+
+  // Sort by path for deterministic hashing
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+
+  for (const e of entries) {
+    hash.update(`${e.path}\n${e.size}\n${e.mtimeMs}\n`);
+  }
+
+  return hash.digest("hex");
+}
+
+// ---- Serialization ----
+
+function serializeDay(d: DayAgg): SerializedDayAgg {
+  return {
+    ...d,
+    sessionIds: [...d.sessionIds],
+    projectSessions: Object.fromEntries(
+      Object.entries(d.projectSessions).map(([k, v]) => [k, [...v]]),
+    ),
+    modelToProvider: Object.fromEntries(d.modelToProvider),
+  };
+}
+
+function deserializeDay(s: SerializedDayAgg): DayAgg {
+  return {
+    ...s,
+    sessionIds: new Set(s.sessionIds),
+    projectSessions: Object.fromEntries(
+      Object.entries(s.projectSessions).map(([k, v]) => [k, new Set(v)]),
+    ),
+    modelToProvider: new Map(Object.entries(s.modelToProvider)),
+  };
+}
+
+// ---- Cache I/O ----
+
+export async function writeCache(
+  cachePath: string,
+  signature: string,
+  days: DayAgg[],
+): Promise<void> {
+  const payload: CachePayload = {
+    signature,
+    generatedAt: new Date().toISOString(),
+    days: days.map(serializeDay),
+  };
+  await writeFile(cachePath, JSON.stringify(payload), "utf-8");
+}
+
+export async function readCache(cachePath: string): Promise<CachePayload | null> {
+  try {
+    const raw = await readFile(cachePath, "utf-8");
+    const payload = JSON.parse(raw) as CachePayload;
+    if (!payload.signature || !Array.isArray(payload.days)) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+export async function getCacheTimestamp(cachePath: string): Promise<string | null> {
+  const payload = await readCache(cachePath);
+  return payload?.generatedAt ?? null;
+}
+
+/** Check if cache is still valid against current directory signature */
+export async function isCacheValid(cachePath: string, sessionsDir: string): Promise<boolean> {
+  const cached = await readCache(cachePath);
+  if (!cached) return false;
+  const currentSig = await computeSignature(sessionsDir);
+  return cached.signature === currentSig;
+}
+
+// ---- Aggregate loading ----
+
+async function findAllJsonlFiles(dir: string): Promise<string[]> {
+  const result: string[] = [];
+  async function walk(d: string) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(d, e.name);
+      if (e.isDirectory()) await walk(full);
+      else if (e.isFile() && e.name.endsWith(".jsonl")) result.push(full);
+    }
+  }
+  await walk(dir);
+  return result;
+}
+
+export async function loadAggregate(
+  cachePath: string,
+  sessionsDir: string,
+  force = false,
+  onProgress?: (p: number) => void,
+): Promise<DayAgg[]> {
+  // Try cache first
+  if (!force) {
+    const valid = await isCacheValid(cachePath, sessionsDir);
+    if (valid) {
+      const cached = await readCache(cachePath);
+      if (cached) return cached.days.map(deserializeDay);
+    }
+  }
+
+  // Parse all JSONL files
+  const files = await findAllJsonlFiles(sessionsDir);
+  const map = new Map<string, DayAgg>();
+  let totalCorrupt = 0;
+
+  for (let i = 0; i < files.length; i++) {
+    let lastCount = 0;
+    const fileMap = parseFile(files[i]!, (count) => {
+      lastCount = count;
+    });
+    totalCorrupt += lastCount;
+    for (const [date, day] of fileMap) {
+      const existing = map.get(date);
+      if (existing) {
+        // mergeDay is used inline in engine's loadAggregate; import it
+        mergeDay(existing, day);
+      } else {
+        map.set(date, day);
+      }
+    }
+    if (onProgress) onProgress(Math.round(((i + 1) / files.length) * 100));
+  }
+
+  if (totalCorrupt > 0) {
+    console.error(`pi-atlas: skipped ${totalCorrupt} corrupt JSONL line(s)`);
+  }
+
+  const days = [...map.values()].sort((a, b) => a.date.localeCompare(b.date));
+
+  // Write cache
+  const sig = await computeSignature(sessionsDir);
+  await writeCache(cachePath, sig, days);
+
+  return days;
+}

package/src/colorPalette.ts

@@ -0,0 +1,119 @@
+import chalk, { type ChalkInstance } from "chalk";
+
+export class ColorPalette {
+  constructor(private mapping: Record<string, ChalkInstance>) {}
+
+  getColor(name: string): ChalkInstance {
+    return this.mapping[name] ?? chalk.white;
+  }
+}
+
+export const langPalette = new ColorPalette({
+  Astro: chalk.hex("#FF5A03"),
+  C: chalk.hex("#555555"),
+  "C#": chalk.hex("#178600"),
+  "C++": chalk.hex("#F34B7D"),
+  Clojure: chalk.hex("#DB5855"),
+  CoffeeScript: chalk.hex("#244776"),
+  Crystal: chalk.hex("#000100"),
+  CSS: chalk.hex("#663399"),
+  Dart: chalk.hex("#00B4AB"),
+  Dockerfile: chalk.hex("#384D54"),
+  EJS: chalk.hex("#A91E50"),
+  Elixir: chalk.hex("#6E4A7E"),
+  Elm: chalk.hex("#60B5CC"),
+  Env: chalk.hex("#E5D559"),
+  Erlang: chalk.hex("#B83998"),
+  "F#": chalk.hex("#B845FC"),
+  Gitignore: chalk.hex("#F44D27"),
+  Gleam: chalk.hex("#FFAFF3"),
+  Go: chalk.hex("#00ADD8"),
+  GraphQL: chalk.hex("#E10098"),
+  Groovy: chalk.hex("#4298B8"),
+  HTML: chalk.hex("#E34C26"),
+  Handlebars: chalk.hex("#F7931E"),
+  Haskell: chalk.hex("#5E5086"),
+  Java: chalk.hex("#B07219"),
+  JavaScript: chalk.hex("#F1E05A"),
+  Jinja: chalk.hex("#A52A22"),
+  JSON: chalk.hex("#292929"),
+  Julia: chalk.hex("#A270BA"),
+  Kotlin: chalk.hex("#A97BFF"),
+  Less: chalk.hex("#1D365D"),
+  Liquid: chalk.hex("#67B8DE"),
+  Lua: chalk.hex("#000080"),
+  Markdown: chalk.hex("#083FA1"),
+  Mustache: chalk.hex("#724B3B"),
+  Nix: chalk.hex("#7E7EFF"),
+  Nunjucks: chalk.hex("#3D8137"),
+  "Objective-C": chalk.hex("#438EFF"),
+  PHP: chalk.hex("#4F5D95"),
+  Perl: chalk.hex("#0298C3"),
+  PowerShell: chalk.hex("#012456"),
+  Prisma: chalk.hex("#0C344B"),
+  Protobuf: chalk.hex("#652D90"),
+  Pug: chalk.hex("#A86454"),
+  Python: chalk.hex("#3572A5"),
+  QML: chalk.hex("#44A51C"),
+  R: chalk.hex("#198CE7"),
+  Raku: chalk.hex("#0000FB"),
+  Ruby: chalk.hex("#701516"),
+  Rust: chalk.hex("#DEA584"),
+  SCSS: chalk.hex("#C6538C"),
+  SQL: chalk.hex("#E38C00"),
+  Scala: chalk.hex("#C22D40"),
+  Shell: chalk.hex("#89E051"),
+  Solidity: chalk.hex("#AA6746"),
+  Svelte: chalk.hex("#FF3E00"),
+  Stylus: chalk.hex("#FF6347"),
+  Swift: chalk.hex("#F05138"),
+  TOML: chalk.hex("#9C4221"),
+  Terraform: chalk.hex("#844FBA"),
+  TypeScript: chalk.hex("#3178C6"),
+  Twig: chalk.hex("#C1D026"),
+  Vue: chalk.hex("#41B883"),
+  "Visual Basic .NET": chalk.hex("#945DB7"),
+  WebAssembly: chalk.hex("#04133B"),
+  XML: chalk.hex("#0060AC"),
+  YAML: chalk.hex("#CB171E"),
+  Zig: chalk.hex("#EC915C"),
+});
+
+// based on https://pi.dev/models
+export const modelPalette = new ColorPalette({
+  "amazon-bedrock": chalk.hex("#FF9900"),
+  "ant-ling": chalk.hex("#0d66fd"),
+  anthropic: chalk.hex("#d66545"),
+  "azure-openai-responses": chalk.hex("#0078D4"),
+  cerebras: chalk.hex("#7CFF00"),
+  "cloudflare-ai-gateway": chalk.hex("#F38020"),
+  "cloudflare-workers-ai": chalk.hex("#F38020"),
+  deepseek: chalk.hex("#4D6BFE"),
+  fireworks: chalk.hex("#FD6F3E"),
+  "github-copilot": chalk.hex("#93f5eb"),
+  google: chalk.hex("#4285F4"),
+  "google-vertex": chalk.hex("#4285F4"),
+  groq: chalk.hex("#F55036"),
+  huggingface: chalk.hex("#FFD21E"),
+  "kimi-coding": chalk.hex("#1F6BFF"),
+  minimax: chalk.hex("#5B6CFF"),
+  "minimax-cn": chalk.hex("#5B6CFF"),
+  mistral: chalk.hex("#FA520F"),
+  moonshotai: chalk.hex("#4F46E5"),
+  "moonshotai-cn": chalk.hex("#4F46E5"),
+  nvidia: chalk.hex("#76B900"),
+  openai: chalk.hex("#0f9f7c"),
+  "openai-codex": chalk.hex("#009aa2"),
+  opencode: chalk.hex("#d0cfce"),
+  "opencode-go": chalk.hex("#d0cfce"),
+  openrouter: chalk.hex("#7C3AED"),
+  together: chalk.hex("#0F6FFF"),
+  "vercel-ai-gateway": chalk.hex("#d1caf3"),
+  xai: chalk.hex("#ffffff"),
+  xiaomi: chalk.hex("#FF6900"),
+  "xiaomi-token-plan-cn": chalk.hex("#FF6900"),
+  "xiaomi-token-plan-ams": chalk.hex("#FF6900"),
+  "xiaomi-token-plan-sgp": chalk.hex("#FF6900"),
+  zai: chalk.hex("#2563EB"),
+  "zai-coding-cn": chalk.hex("#2563EB"),
+});

package/src/components/BarChart.ts

@@ -0,0 +1,288 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, visibleWidth } from "@earendil-works/pi-tui";
+import { MONTH_NAMES, formatCost } from "../format";
+import type { DaySpend, HourSpend, TimeRange } from "../types";
+
+/** Number of hours displayed in a full day. */
+const HOURS_PER_DAY = 24;
+
+const DAY_NAMES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+
+/** Minimum bar area height (rows) — prevents degenerate chart at tiny maxHeight. */
+const MIN_BAR_AREA = 3;
+/** Padding rows subtracted from maxHeight: 1 for x-axis labels + 1 for top padding. */
+const CHART_VERTICAL_PADDING = 2;
+/** Minimum column width per bar — prevents invisible bars on narrow terminals. */
+const MIN_COL_WIDTH = 2;
+/** Floor cost to avoid divide-by-zero when computing bar proportions. */
+const COST_FLOOR = 0.01;
+/** Threshold for half-block character: barH extension beyond integer row. */
+const HALF_BLOCK_THRESHOLD = 0.5;
+/** Y-axis separator string " │ " — space, box-drawing line, space. */
+const Y_AXIS_SEPARATOR = " │ ";
+
+/** Space between bar columns in characters. */
+const BAR_GAP = 1;
+
+/** Auto-density: every row when barAreaH ≤ this. */
+const DENSE_MAX_HEIGHT = 6;
+/** Auto-density: every other row when barAreaH ≤ this. Otherwise every 3rd. */
+const SPREAD_MAX_HEIGHT = 14;
+
+/** Minimum number of bars — prevents degenerate chart at tiny widths. */
+const MIN_BARS = 2;
+
+/**
+ * Aggregate data into at most `target` buckets by grouping consecutive items.
+ * Costs are summed per bucket; the first item's other fields are preserved.
+ */
+function aggregate<T extends { cost: number }>(data: T[], target: number): T[] {
+  if (data.length <= target) return data;
+  const n = data.length;
+  const q = Math.floor(n / target);
+  const r = n % target;
+  const result: T[] = [];
+  let idx = 0;
+  for (let i = 0; i < target; i++) {
+    const size = i < r ? q + 1 : q;
+    let cost = 0;
+    for (let j = 0; j < size; j++) {
+      cost += data[idx + j]!.cost;
+    }
+    result.push({ ...data[idx]!, cost });
+    idx += size;
+  }
+  return result;
+}
+
+export class BarChart implements Component {
+  private data: DaySpend[];
+  private range: TimeRange;
+  private maxHeight: number;
+  private theme: Theme;
+  private yAxisSpacing: number | undefined;
+  private hourlyData: HourSpend[];
+  private cachedLines: string[] | null = null;
+  private cachedWidth = -1;
+
+  constructor(
+    data: DaySpend[],
+    range: TimeRange,
+    maxHeight: number,
+    theme: Theme,
+    yAxisSpacing?: number,
+    hourlyData?: HourSpend[],
+  ) {
+    this.data = data;
+    this.range = range;
+    this.maxHeight = maxHeight;
+    this.theme = theme;
+    this.yAxisSpacing = yAxisSpacing;
+    this.hourlyData = hourlyData ?? [];
+  }
+
+  render(width: number): string[] {
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+
+    if (this.data.length === 0 && this.hourlyData.length === 0) {
+      this.cachedLines = [this.theme.fg("muted", "No data")];
+      this.cachedWidth = width;
+      return this.cachedLines;
+    }
+
+    let lines: string[] = [];
+    if (this.range === "1d" && this.hourlyData.length === HOURS_PER_DAY) {
+      lines = this.renderHourly(width);
+    } else {
+      lines = this.renderDaily(width);
+    }
+
+    this.cachedLines = lines;
+    this.cachedWidth = width;
+    return lines;
+  }
+
+  private renderDaily(width: number): string[] {
+    return this.renderBars(
+      this.data,
+      (plotData, _cellW) =>
+        plotData.map((d, i) => formatDateLabel(d.date, i, plotData as DaySpend[], this.range)),
+      (plotData, n) =>
+        plotData.length === n ? "Daily" : "~" + (n / plotData.length).toFixed(1) + "d avg",
+      width,
+    );
+  }
+
+  /** Render per-hour bars for 1d range. */
+  private renderHourly(width: number): string[] {
+    return this.renderBars(
+      this.hourlyData,
+      (plotData, cellW) => {
+        const interval = computeHourLabelInterval(plotData.length, cellW);
+        return plotData.map((h, i) =>
+          formatHourLabel(h.hour, i, plotData as HourSpend[], interval),
+        );
+      },
+      (plotData, n) =>
+        plotData.length === n ? "Hourly" : `~${(HOURS_PER_DAY / plotData.length).toFixed(1)}h avg`,
+      width,
+    );
+  }
+
+  /**
+   * Shared bar-rendering engine. Handles layout, y-axis, bar drawing,
+   * x-axis label line, and granularity footer.
+   *
+   * @param sourceData — raw data before potential downsampling
+   * @param getLabels — computes x-axis labels from the (possibly downsampled) plotData and cell width
+   * @param getGranularity — returns the granularity label string from (plotData, sourceLength)
+   */
+  private renderBars<T extends { cost: number }>(
+    sourceData: T[],
+    getLabels: (plotData: T[], cellWidth: number) => string[],
+    getGranularity: (plotData: T[], sourceLength: number) => string,
+    width: number,
+  ): string[] {
+    const barAreaH = Math.max(MIN_BAR_AREA, this.maxHeight - CHART_VERTICAL_PADDING);
+    const maxCost = Math.max(...sourceData.map((d) => d.cost), COST_FLOOR);
+
+    const step = this.yAxisSpacing != null ? Math.max(1, this.yAxisSpacing) : densityStep(barAreaH);
+    const yLabelPad = computeLabelWidth(maxCost, barAreaH, step);
+    const yAxisW = yLabelPad + Y_AXIS_SEPARATOR.length;
+
+    const availW = width - yAxisW;
+    const maxBars = Math.max(MIN_BARS, Math.floor(availW / (MIN_COL_WIDTH + BAR_GAP)));
+    const plotData = sourceData.length > maxBars ? aggregate(sourceData, maxBars) : sourceData;
+
+    const totalGaps = plotData.length * BAR_GAP;
+    const colW = Math.max(MIN_COL_WIDTH, Math.floor((availW - totalGaps) / plotData.length));
+    const cellW = colW + BAR_GAP;
+
+    // Pre-compute bar heights once (not per-row)
+    const barHeights = plotData.map((d) => (d.cost / maxCost) * barAreaH);
+    const labels = getLabels(plotData, cellW);
+    const granularityLabel = getGranularity(plotData, sourceData.length);
+
+    const lines: string[] = [];
+
+    for (let row = barAreaH - 1; row >= 0; row--) {
+      let line = "";
+
+      const isLabelRow = row === 0 || row % step === 0;
+      if (isLabelRow) {
+        const val = (row / (barAreaH - 1)) * maxCost;
+        line += formatCost(val).padStart(yLabelPad) + Y_AXIS_SEPARATOR;
+      } else {
+        line += " ".repeat(yLabelPad) + Y_AXIS_SEPARATOR;
+      }
+
+      for (let bi = 0; bi < plotData.length; bi++) {
+        const barH = barHeights[bi]!;
+        if (barH > row + HALF_BLOCK_THRESHOLD) {
+          line += "█".repeat(colW);
+        } else if (barH > row) {
+          line += "▄".repeat(colW);
+        } else {
+          line += " ".repeat(colW);
+        }
+        line += " ".repeat(BAR_GAP);
+      }
+      lines.push(line);
+    }
+
+    // X-axis labels with y-axis bottom corner
+    let labelLine = " ".repeat(yLabelPad + 1) + "└─";
+    for (let i = 0; i < plotData.length; i++) {
+      const lbl = labels[i]!;
+      const cellW = colW + BAR_GAP;
+      if (lbl.length > 0) {
+        if (lbl.length <= cellW) {
+          const pad = cellW - lbl.length;
+          const padLeft = Math.floor(pad / 2);
+          const padRight = pad - padLeft;
+          labelLine += "─".repeat(padLeft) + lbl + "─".repeat(padRight);
+        } else {
+          labelLine += lbl + "─".repeat(Math.max(0, cellW - lbl.length));
+        }
+      } else {
+        labelLine += "─".repeat(cellW);
+      }
+    }
+    lines.push(labelLine);
+
+    // Granularity footer (right-aligned)
+    const granularityText = this.theme.italic(granularityLabel);
+    lines.push(
+      this.theme.fg("dim", " ".repeat(width - visibleWidth(granularityText)) + granularityText),
+    );
+
+    return lines;
+  }
+
+  invalidate(): void {
+    this.cachedLines = null;
+    this.cachedWidth = -1;
+  }
+}
+
+function densityStep(barAreaH: number): number {
+  if (barAreaH <= DENSE_MAX_HEIGHT) return 1;
+  if (barAreaH <= SPREAD_MAX_HEIGHT) return 2;
+  return 3;
+}
+
+function computeLabelWidth(maxCost: number, barAreaH: number, step: number): number {
+  let maxW = 0;
+  for (let row = 0; row < barAreaH; row += step) {
+    const val = (row / (barAreaH - 1)) * maxCost;
+    maxW = Math.max(maxW, formatCost(val).length);
+  }
+  // Baseline $0.00 is always shown but already covered by row=0
+  return maxW;
+}
+
+function formatDateLabel(
+  dateStr: string,
+  index: number,
+  data: DaySpend[],
+  range: TimeRange,
+): string {
+  const d = new Date(dateStr + "T00:00:00Z");
+  if (range === "1d" || range === "7d") {
+    return DAY_NAMES[d.getUTCDay()] || "NaN";
+  }
+  if (range === "30d") {
+    const day = d.getUTCDate();
+    if (day === 1 || day % 5 === 0 || index === 0 || index === data.length - 1) {
+      return String(day);
+    }
+    return "";
+  }
+  // All — show month when it changes or first entry
+  const month = MONTH_NAMES[d.getUTCMonth()];
+  if (index === 0) return month || "NaN";
+  const prevD = new Date(data[index - 1]!.date + "T00:00:00Z");
+  if (prevD.getUTCMonth() !== d.getUTCMonth()) return month || "NaN";
+  return "";
+}
+
+function computeHourLabelInterval(count: number, cellWidth: number): number {
+  // Try intervals — pick the smallest that fits labels in cells
+  const candidates = [4, 6, 12];
+  for (const interval of candidates) {
+    const labelsOnRow = Math.ceil(count / interval);
+    // Rough estimate: each label needs cellWidth minus a gap for a space on each side
+    const neededPerLabel = cellWidth;
+    if (labelsOnRow * neededPerLabel <= count * cellWidth) {
+      return interval;
+    }
+  }
+  return candidates[candidates.length - 1]!;
+}
+
+function formatHourLabel(hour: number, index: number, data: HourSpend[], interval: number): string {
+  if (index === 0 || index === data.length - 1 || hour % interval === 0) {
+    return `${hour}h`;
+  }
+  return "";
+}