@psg2/pi-costs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# pi-costs
+
+Analyze cost and token usage from [pi coding agent](https://github.com/badlogic/pi-mono) sessions.
+
+Reads the JSONL session logs stored in `~/.pi/agent/sessions/` and produces a summary of costs, token usage, and breakdowns by model, project, day, or individual session.
+
+## Usage
+
+Run directly with `bunx` (no install needed):
+
+```bash
+bunx @psg2/pi-costs
+```
+
+Or install globally:
+
+```bash
+bun install -g @psg2/pi-costs
+pi-costs
+```
+
+## Options
+
+```
+pi-costs                        All projects, last 7 days
+pi-costs --days 30              Last 30 days
+pi-costs --days 0               All time
+pi-costs --project my-app       Filter by project (substring match)
+pi-costs --sessions             Show per-session breakdown
+pi-costs --daily                Show per-day breakdown
+pi-costs --dir <path>           Custom sessions directory
+```
+
+## Example output
+
+```
+======================================================================
+  Pi Session Costs — last 7 days
+======================================================================
+
+  Total cost:       $42.5100
+  Sessions:         18
+  LLM requests:     320
+  Input tokens:     50.2K ($0.2510)
+  Output tokens:    1.2M ($30.0000)
+  Cache read:       15.0M ($9.0000)
+  Cache write:      800.0K ($3.2590)
+
+  ──────────────────────────────────────────────────────────────────
+  By Model:
+  Model                                              Cost  Requests
+  ──────────────────────────────────────────────────────────────────
+  claude-opus-4-5                                $30.1200       210
+  claude-sonnet-4-5                              $12.3900       110
+
+  ──────────────────────────────────────────────────────────────────
+  By Project:
+  Project                                            Cost  Requests
+  ──────────────────────────────────────────────────────────────────
+  my-web-app                                     $28.4500       200
+  my-api-server                                  $14.0600       120
+
+======================================================================
+```
+
+## How it works
+
+Pi stores session logs as JSONL files in `~/.pi/agent/sessions/<project>/`. Each assistant message includes a `usage` field with token counts and pre-calculated costs in USD:
+
+```json
+{
+  "type": "message",
+  "message": {
+    "role": "assistant",
+    "model": "claude-opus-4-5",
+    "usage": {
+      "input": 3183,
+      "output": 104,
+      "cacheRead": 50000,
+      "cacheWrite": 4000,
+      "cost": {
+        "input": 0.0159,
+        "output": 0.0026,
+        "cacheRead": 0.025,
+        "cacheWrite": 0.025,
+        "total": 0.0685
+      }
+    }
+  }
+}
+```
+
+See the [pi session format docs](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/session.md) for full details.
+
+## Development
+
+```bash
+bun install
+bun test          # Run tests
+bun run dev       # Run from source
+bun run build     # Build for distribution
+bun run lint      # Lint
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2, resolve } from "path";
+
+// src/format.ts
+function fmtCost(v) {
+  return `$${v.toFixed(4)}`;
+}
+function fmtTokens(v) {
+  if (v >= 1e6)
+    return `${(v / 1e6).toFixed(1)}M`;
+  if (v >= 1000)
+    return `${(v / 1000).toFixed(1)}K`;
+  return String(v);
+}
+function pad(s, width, align = "left") {
+  if (align === "right")
+    return s.padStart(width);
+  return s.padEnd(width);
+}
+var W = 70;
+var SEP = "\u2500".repeat(W - 4);
+function renderReport(opts) {
+  const lines = [];
+  const ln = (s = "") => {
+    lines.push(s);
+  };
+  const { totals, perModel, perProject, perDay, sessionRows } = opts;
+  ln();
+  ln("=".repeat(W));
+  ln(`  Pi Session Costs \u2014 ${opts.period}`);
+  if (opts.projectFilter)
+    ln(`  Filter: '${opts.projectFilter}'`);
+  ln("=".repeat(W));
+  ln();
+  ln(`  Total cost:       ${fmtCost(totals.totalCost)}`);
+  ln(`  Sessions:         ${opts.sessionCount}`);
+  ln(`  LLM requests:     ${totals.requests}`);
+  ln(`  Input tokens:     ${fmtTokens(totals.inputTokens)} ($${totals.costInput.toFixed(4)})`);
+  ln(`  Output tokens:    ${fmtTokens(totals.outputTokens)} ($${totals.costOutput.toFixed(4)})`);
+  ln(`  Cache read:       ${fmtTokens(totals.cacheReadTokens)} ($${totals.costCacheRead.toFixed(4)})`);
+  ln(`  Cache write:      ${fmtTokens(totals.cacheWriteTokens)} ($${totals.costCacheWrite.toFixed(4)})`);
+  if (perModel.size > 0) {
+    ln();
+    ln(`  ${SEP}`);
+    ln("  By Model:");
+    ln(`  ${pad("Model", 45)}${pad("Cost", 10, "right")}${pad("Requests", 10, "right")}`);
+    ln(`  ${SEP}`);
+    const sorted = [...perModel.entries()].sort((a, b) => b[1].cost - a[1].cost);
+    for (const [model, { requests, cost }] of sorted) {
+      ln(`  ${pad(model, 45)}${pad(fmtCost(cost), 10, "right")}${pad(String(requests), 10, "right")}`);
+    }
+  }
+  if (perProject.size > 1) {
+    ln();
+    ln(`  ${SEP}`);
+    ln("  By Project:");
+    ln(`  ${pad("Project", 45)}${pad("Cost", 10, "right")}${pad("Requests", 10, "right")}`);
+    ln(`  ${SEP}`);
+    const sorted = [...perProject.entries()].sort((a, b) => b[1].totalCost - a[1].totalCost);
+    for (const [proj, stats] of sorted) {
+      let short = proj.split("/").filter(Boolean).pop() ?? proj;
+      if (short.length > 43)
+        short = `\u2026${short.slice(-42)}`;
+      ln(`  ${pad(short, 45)}${pad(fmtCost(stats.totalCost), 10, "right")}${pad(String(stats.requests), 10, "right")}`);
+    }
+  }
+  if (opts.showDaily && perDay.size > 0) {
+    ln();
+    ln(`  ${SEP}`);
+    ln("  By Day:");
+    ln(`  ${pad("Date", 15)}${pad("Cost", 10, "right")}${pad("Requests", 10, "right")}${pad("Input", 10, "right")}${pad("Output", 10, "right")}`);
+    ln(`  ${SEP}`);
+    const sorted = [...perDay.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [day, stats] of sorted) {
+      const totalIn = stats.inputTokens + stats.cacheReadTokens + stats.cacheWriteTokens;
+      ln(`  ${pad(day, 15)}${pad(fmtCost(stats.totalCost), 10, "right")}${pad(String(stats.requests), 10, "right")}${pad(fmtTokens(totalIn), 10, "right")}${pad(fmtTokens(stats.outputTokens), 10, "right")}`);
+    }
+  }
+  if (opts.showSessions && sessionRows.length > 0) {
+    const SW = 90;
+    const sSep = "\u2500".repeat(SW);
+    ln();
+    ln(`  ${sSep}`);
+    ln("  Sessions:");
+    ln(`  ${pad("Time", 18)}${pad("Project", 20)}${pad("Reqs", 6, "right")}${pad("Cost", 10, "right")}${pad("In Tok", 10, "right")}${pad("Out Tok", 10, "right")}  Model`);
+    ln(`  ${sSep}`);
+    for (const row of sessionRows) {
+      let proj = row.project;
+      if (proj.length > 18)
+        proj = `\u2026${proj.slice(-17)}`;
+      ln(`  ${pad(row.time, 18)}${pad(proj, 20)}${pad(String(row.requests), 6, "right")}${pad(fmtCost(row.cost), 10, "right")}${pad(fmtTokens(row.inputTokens), 10, "right")}${pad(fmtTokens(row.outputTokens), 10, "right")}  ${row.models}`);
+    }
+  }
+  ln();
+  ln("=".repeat(W));
+  ln();
+  return lines.join(`
+`);
+}
+
+// src/parser.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+
+// src/stats.ts
+function createStats() {
+  return {
+    totalCost: 0,
+    costInput: 0,
+    costOutput: 0,
+    costCacheRead: 0,
+    costCacheWrite: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    requests: 0,
+    models: new Map
+  };
+}
+function addUsage(stats, usage, model) {
+  const cost = usage.cost ?? {};
+  const total = cost.total ?? 0;
+  stats.totalCost += total;
+  stats.costInput += cost.input ?? 0;
+  stats.costOutput += cost.output ?? 0;
+  stats.costCacheRead += cost.cacheRead ?? 0;
+  stats.costCacheWrite += cost.cacheWrite ?? 0;
+  stats.inputTokens += usage.input ?? 0;
+  stats.outputTokens += usage.output ?? 0;
+  stats.cacheReadTokens += usage.cacheRead ?? 0;
+  stats.cacheWriteTokens += usage.cacheWrite ?? 0;
+  stats.requests += 1;
+  const entry = stats.models.get(model) ?? { requests: 0, cost: 0 };
+  entry.requests += 1;
+  entry.cost += total;
+  stats.models.set(model, entry);
+}
+function mergeStats(target, source) {
+  target.totalCost += source.totalCost;
+  target.costInput += source.costInput;
+  target.costOutput += source.costOutput;
+  target.costCacheRead += source.costCacheRead;
+  target.costCacheWrite += source.costCacheWrite;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadTokens += source.cacheReadTokens;
+  target.cacheWriteTokens += source.cacheWriteTokens;
+  target.requests += source.requests;
+  for (const [model, { requests, cost }] of source.models) {
+    const entry = target.models.get(model) ?? { requests: 0, cost: 0 };
+    entry.requests += requests;
+    entry.cost += cost;
+    target.models.set(model, entry);
+  }
+}
+
+// src/parser.ts
+function parseSessionTimestamp(filename) {
+  const tsRaw = filename.split("_")[0];
+  if (!tsRaw)
+    return null;
+  const parts = tsRaw.replace("Z", "").split("T");
+  if (parts.length !== 2)
+    return null;
+  const [datePart, timeRaw] = parts;
+  const timePieces = timeRaw?.split("-");
+  if (timePieces.length < 3)
+    return null;
+  const timeStr = `${timePieces[0]}:${timePieces[1]}:${timePieces[2]}`;
+  const date = new Date(`${datePart}T${timeStr}Z`);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function decodeProjectName(dirname) {
+  return dirname.replace(/--/g, "/").replace(/^\/|\/$/g, "");
+}
+function shortProjectName(project, maxLen = 43) {
+  const segments = project.split("/").filter(Boolean);
+  let short = segments[segments.length - 1] ?? project;
+  if (short.length > maxLen) {
+    short = `\u2026${short.slice(-(maxLen - 1))}`;
+  }
+  return short;
+}
+async function discoverSessions(opts) {
+  const sessions = [];
+  const cutoff = opts.days > 0 ? new Date(Date.now() - opts.days * 86400000) : new Date(0);
+  let projectDirs;
+  try {
+    projectDirs = await readdir(opts.sessionsDir);
+  } catch {
+    return [];
+  }
+  for (const dir of projectDirs.sort()) {
+    const projectPath = join(opts.sessionsDir, dir);
+    const project = decodeProjectName(dir);
+    if (opts.projectFilter && !project.toLowerCase().includes(opts.projectFilter.toLowerCase())) {
+      continue;
+    }
+    let files;
+    try {
+      files = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+    for (const file of files.sort()) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const ts = parseSessionTimestamp(file);
+      if (!ts || ts < cutoff)
+        continue;
+      sessions.push({
+        filepath: join(projectPath, file),
+        project,
+        timestamp: ts
+      });
+    }
+  }
+  return sessions;
+}
+async function parseSession(filepath) {
+  const stats = createStats();
+  const text = await readFile(filepath, "utf-8");
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (obj.type !== "message")
+      continue;
+    const msg = obj.message;
+    if (!msg || msg.role !== "assistant")
+      continue;
+    const usage = msg.usage;
+    if (!usage)
+      continue;
+    const model = msg.model ?? "unknown";
+    addUsage(stats, usage, model);
+  }
+  return stats;
+}
+async function analyzeSessions(sessions, showSessions) {
+  const totals = createStats();
+  const perProject = new Map;
+  const perDay = new Map;
+  const sessionRows = [];
+  let sessionCount = 0;
+  for (const { filepath, project, timestamp } of sessions) {
+    const sessionStats = await parseSession(filepath);
+    if (sessionStats.requests === 0)
+      continue;
+    sessionCount++;
+    mergeStats(totals, sessionStats);
+    const projectStats = perProject.get(project) ?? createStats();
+    mergeStats(projectStats, sessionStats);
+    perProject.set(project, projectStats);
+    const dayKey = timestamp.toISOString().slice(0, 10);
+    const dayStats = perDay.get(dayKey) ?? createStats();
+    mergeStats(dayStats, sessionStats);
+    perDay.set(dayKey, dayStats);
+    if (showSessions) {
+      const short = shortProjectName(project, 18);
+      const modelsStr = [...sessionStats.models.entries()].sort((a, b) => b[1].requests - a[1].requests).map(([m]) => m).join(", ");
+      sessionRows.push({
+        time: formatTimestamp(timestamp),
+        project: short,
+        requests: sessionStats.requests,
+        cost: sessionStats.totalCost,
+        inputTokens: sessionStats.inputTokens + sessionStats.cacheReadTokens + sessionStats.cacheWriteTokens,
+        outputTokens: sessionStats.outputTokens,
+        models: modelsStr
+      });
+    }
+  }
+  return { totals, perProject, perDay, perModel: totals.models, sessionRows, sessionCount };
+}
+function formatTimestamp(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  const h = String(date.getUTCHours()).padStart(2, "0");
+  const min = String(date.getUTCMinutes()).padStart(2, "0");
+  return `${y}-${m}-${d} ${h}:${min}`;
+}
+
+// src/cli.ts
+var HELP = `pi-costs \u2014 Analyze cost and token usage from pi coding agent sessions
+
+Usage:
+  pi-costs                        All projects, last 7 days
+  pi-costs --days 30              Last 30 days
+  pi-costs --days 0               All time
+  pi-costs --project finances     Filter by project (substring match)
+  pi-costs --sessions             Show per-session breakdown
+  pi-costs --daily                Show per-day breakdown
+
+Options:
+  --days <n>        Time window in days (default: 7, use 0 for all time)
+  --project <name>  Filter projects by substring (case-insensitive)
+  --sessions        Show individual session breakdown
+  --daily           Show per-day breakdown
+  --dir <path>      Custom sessions directory (default: ~/.pi/agent/sessions)
+  -h, --help        Show this help
+  -v, --version     Show version
+`;
+function parseArgs(args) {
+  const opts = {
+    days: 7,
+    projectFilter: "",
+    showSessions: false,
+    showDaily: false,
+    sessionsDir: join2(homedir(), ".pi", "agent", "sessions")
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--days":
+        opts.days = Number.parseInt(args[++i] ?? "7", 10);
+        break;
+      case "--project":
+        opts.projectFilter = args[++i] ?? "";
+        break;
+      case "--sessions":
+        opts.showSessions = true;
+        break;
+      case "--daily":
+        opts.showDaily = true;
+        break;
+      case "--dir":
+        opts.sessionsDir = args[++i] ?? opts.sessionsDir;
+        break;
+      case "-h":
+      case "--help":
+        console.log(HELP);
+        process.exit(0);
+        break;
+      case "-v":
+      case "--version": {
+        const pkgPath = resolve(import.meta.dirname ?? ".", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        console.log(`pi-costs v${pkg.version}`);
+        process.exit(0);
+        break;
+      }
+      default:
+        console.error(`Unknown option: ${arg}
+Run 'pi-costs --help' for usage.`);
+        process.exit(1);
+    }
+  }
+  return opts;
+}
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const sessions = await discoverSessions(opts);
+  if (sessions.length === 0) {
+    const period2 = opts.days > 0 ? `last ${opts.days} days` : "all time";
+    const filter = opts.projectFilter ? ` matching '${opts.projectFilter}'` : "";
+    console.log(`No sessions found for ${period2}${filter}`);
+    console.log(`
+Searched: ${opts.sessionsDir}`);
+    process.exit(0);
+  }
+  const result = await analyzeSessions(sessions, opts.showSessions);
+  const period = opts.days > 0 ? `last ${opts.days} days` : "all time";
+  const report = renderReport({
+    period,
+    projectFilter: opts.projectFilter,
+    totals: result.totals,
+    sessionCount: result.sessionCount,
+    perModel: result.perModel,
+    perProject: result.perProject,
+    perDay: result.perDay,
+    showDaily: opts.showDaily,
+    sessionRows: result.sessionRows,
+    showSessions: opts.showSessions
+  });
+  console.log(report);
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@psg2/pi-costs",
+  "version": "1.0.0",
+  "description": "Analyze cost and token usage from pi coding agent sessions",
+  "type": "module",
+  "bin": {
+    "pi-costs": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --outdir dist --target bun",
+    "dev": "bun run src/cli.ts",
+    "lint": "bunx --bun biome check src/",
+    "lint:fix": "bunx --bun biome check --write src/",
+    "format": "bunx --bun biome format --write src/",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/psg2/pi-costs.git"
+  },
+  "homepage": "https://github.com/psg2/pi-costs#readme",
+  "bugs": {
+    "url": "https://github.com/psg2/pi-costs/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "claude",
+    "llm",
+    "cost",
+    "usage",
+    "tokens"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "^1.2.4"
+  }
+}