slopmeter 0.5.0 → 0.5.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { dirname, extname, resolve as resolve5 } from "path";
+import { dirname, extname, resolve as resolve6 } from "path";
 import { parseArgs } from "util";
 import ora from "ora";
 import ow from "ow";
@@ -5773,8 +5773,37 @@ var heatmapThemes = {
       ]
     }
   },
+  pi: {
+    title: "Pi Coding Agent",
+    colors: {
+      light: [
+        "#ecfdf5",
+        // emerald-50
+        "#a7f3d0",
+        // emerald-200
+        "#6ee7b7",
+        // emerald-300
+        "#10b981",
+        // emerald-500
+        "#047857"
+        // emerald-700
+      ],
+      dark: [
+        "#022c22",
+        // emerald-950
+        "#065f46",
+        // emerald-800
+        "#059669",
+        // emerald-600
+        "#34d399",
+        // emerald-400
+        "#a7f3d0"
+        // emerald-200
+      ]
+    }
+  },
   all: {
-    title: "Codex / Claude Code / Cursor / Open Code",
+    title: "Codex / Claude Code / Cursor / Open Code / Pi Coding Agent",
     titleCaption: "Total usage from",
     colors: {
       light: [
@@ -6000,7 +6029,6 @@ function drawHeatmapSection(svg, {
     totalTokens += row.total;
   }
   const topMetricGap = 120;
-  const headerLast30DaysX = rightEdge - topMetricGap * 3;
   const headerInputX = rightEdge - topMetricGap * 2;
   const headerOutputX = rightEdge - topMetricGap;
   const totalTokensLabel = formatTokenTotal(totalTokens);
@@ -6514,6 +6542,9 @@ function getClaudeHistoryFiles() {
   }
   return files;
 }
+function isClaudeAvailable() {
+  return getClaudeProjectDirs().length > 0 || getClaudeStatsCacheFiles().length > 0 || getClaudeHistoryFiles().length > 0;
+}
 async function loadClaudeStatsCacheRows(startDate, endDate, coveredDates, totals, modelTotals, recentModelTotals, recentStart) {
   const statsCacheFiles = getClaudeStatsCacheFiles();
   for (const file of statsCacheFiles) {
@@ -6647,6 +6678,7 @@ async function loadClaudeRows(startDate, endDate) {
 }
 
 // src/lib/codex.ts
+import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3, resolve as resolve2 } from "path";
 var CLASSIFICATION_PREFIX_BYTES = 32 * 1024;
@@ -6667,6 +6699,15 @@ function normalizeCodexUsage(value) {
     total_tokens: total > 0 ? total : input + output
   };
 }
+function addCodexUsage(base, delta) {
+  return {
+    input_tokens: (base?.input_tokens ?? 0) + delta.input_tokens,
+    cached_input_tokens: (base?.cached_input_tokens ?? 0) + delta.cached_input_tokens,
+    output_tokens: (base?.output_tokens ?? 0) + delta.output_tokens,
+    reasoning_output_tokens: (base?.reasoning_output_tokens ?? 0) + delta.reasoning_output_tokens,
+    total_tokens: (base?.total_tokens ?? 0) + delta.total_tokens
+  };
+}
 function subtractCodexUsage(current, previous) {
   return {
     input_tokens: Math.max(
@@ -6691,6 +6732,12 @@ function subtractCodexUsage(current, previous) {
     )
   };
 }
+function didCodexTotalsRollback(current, previous) {
+  if (!previous) {
+    return false;
+  }
+  return current.input_tokens < previous.input_tokens || current.cached_input_tokens < previous.cached_input_tokens || current.output_tokens < previous.output_tokens || current.reasoning_output_tokens < previous.reasoning_output_tokens || current.total_tokens < previous.total_tokens;
+}
 function asNonEmptyString(value) {
   const trimmed = value?.trim();
   return trimmed === "" ? void 0 : trimmed;
@@ -6717,10 +6764,16 @@ function extractCodexModel(payload) {
   }
   return void 0;
 }
+function getCodexHome() {
+  return process.env.CODEX_HOME?.trim() ? resolve2(process.env.CODEX_HOME) : join3(homedir2(), ".codex");
+}
 async function getCodexFiles() {
-  const codexHome = process.env.CODEX_HOME?.trim() ? resolve2(process.env.CODEX_HOME) : join3(homedir2(), ".codex");
+  const codexHome = getCodexHome();
   return listFilesRecursive(join3(codexHome, "sessions"), ".jsonl");
 }
+function isCodexAvailable() {
+  return existsSync2(join3(getCodexHome(), "sessions"));
+}
 function readJsonString(source, start) {
   if (source[start] !== '"') {
     return null;
@@ -6959,12 +7012,15 @@ async function processCodexFile(filePath, start, end, maxRecordBytes) {
     const info = entry.payload?.info;
     const lastUsage = normalizeCodexUsage(info?.last_token_usage);
     const totalUsage = normalizeCodexUsage(info?.total_token_usage);
-    let rawUsage = lastUsage;
-    if (!rawUsage && totalUsage) {
-      rawUsage = subtractCodexUsage(totalUsage, previousTotals);
-    }
+    let rawUsage = null;
     if (totalUsage) {
+      rawUsage = didCodexTotalsRollback(totalUsage, previousTotals) ? lastUsage ?? totalUsage : subtractCodexUsage(totalUsage, previousTotals);
       previousTotals = totalUsage;
+    } else {
+      rawUsage = lastUsage;
+      if (rawUsage) {
+        previousTotals = addCodexUsage(previousTotals, rawUsage);
+      }
     }
     if (!rawUsage) {
       continue;
@@ -7033,11 +7089,17 @@ async function loadCodexRows(start, end, warnings = []) {
       `Skipped ${skippedOversizedIrrelevantRecords} oversized irrelevant Codex record(s) across ${skippedFiles} file(s); usage totals exclude those records. Relevant oversized records fail the file. Override ${MAX_JSONL_RECORD_BYTES_ENV} to raise the cap.`
     );
   }
-  return createUsageSummary("codex", totals, modelTotals, recentModelTotals, end);
+  return createUsageSummary(
+    "codex",
+    totals,
+    modelTotals,
+    recentModelTotals,
+    end
+  );
 }
 
 // src/lib/cursor.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { copyFile, mkdtemp, rm } from "fs/promises";
 import { homedir as homedir3, tmpdir } from "os";
 import { join as join4, resolve as resolve3 } from "path";
@@ -7085,7 +7147,7 @@ function getCursorStateDbCandidates() {
 function getCursorStateDbPath() {
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of getCursorStateDbCandidates()) {
-    if (!seen.has(candidate) && existsSync2(candidate)) {
+    if (!seen.has(candidate) && existsSync3(candidate)) {
       return candidate;
     }
     seen.add(candidate);
@@ -7131,7 +7193,7 @@ async function withCursorStateSnapshot(databasePath, callback) {
   await copyFile(databasePath, snapshotPath);
   for (const suffix of ["-shm", "-wal"]) {
     const companionPath = `${databasePath}${suffix}`;
-    if (!existsSync2(companionPath)) {
+    if (!existsSync3(companionPath)) {
       continue;
     }
     await copyFile(companionPath, `${snapshotPath}${suffix}`);
@@ -7155,6 +7217,14 @@ async function readCursorAuthState(databasePath) {
     );
   }
 }
+async function isCursorAvailable() {
+  const databasePath = getCursorStateDbPath();
+  if (!databasePath) {
+    return false;
+  }
+  const authState = await readCursorAuthState(databasePath);
+  return Boolean(authState.accessToken);
+}
 function decodeJwtPayload(token) {
   const encodedPayload = token.split(".")[1];
   if (!encodedPayload) {
@@ -7303,61 +7373,60 @@ async function processCursorUsageCsvStream(response, onRow) {
     return;
   }
   let headers = null;
-  let currentField = "";
-  let currentRow = [];
-  let inQuotes = false;
-  let pendingQuote = false;
-  let sawCarriageReturn = false;
+  const state = {
+    currentField: "",
+    currentRow: [],
+    inQuotes: false,
+    pendingQuote: false,
+    sawCarriageReturn: false
+  };
   const decoder = new TextDecoder();
   const emitField = () => {
-    currentRow.push(currentField);
-    currentField = "";
+    state.currentRow.push(state.currentField);
+    state.currentField = "";
   };
   const emitRow = () => {
     emitField();
-    if (currentRow.every((value) => value.trim() === "")) {
-      currentRow = [];
+    if (state.currentRow.every((value) => value.trim() === "")) {
+      state.currentRow = [];
       return;
     }
     if (!headers) {
-      headers = currentRow;
-      currentRow = [];
+      headers = state.currentRow;
+      state.currentRow = [];
       return;
     }
-    onRow(createCursorCsvRow(headers, currentRow));
-    currentRow = [];
+    onRow(createCursorCsvRow(headers, state.currentRow));
+    state.currentRow = [];
   };
   const processChunk = (chunk) => {
     for (const char of chunk) {
-      let shouldReprocess = true;
-      while (shouldReprocess) {
-        shouldReprocess = false;
-        if (sawCarriageReturn) {
-          sawCarriageReturn = false;
+      for (; ; ) {
+        if (state.sawCarriageReturn) {
+          state.sawCarriageReturn = false;
           if (char === "\n") {
             break;
           }
         }
-        if (pendingQuote) {
-          pendingQuote = false;
+        if (state.pendingQuote) {
+          state.pendingQuote = false;
           if (char === '"') {
-            currentField += '"';
+            state.currentField += '"';
             break;
           }
-          inQuotes = false;
-          shouldReprocess = true;
+          state.inQuotes = false;
           continue;
         }
-        if (inQuotes) {
+        if (state.inQuotes) {
           if (char === '"') {
-            pendingQuote = true;
+            state.pendingQuote = true;
           } else {
-            currentField += char;
+            state.currentField += char;
           }
           break;
         }
         if (char === '"') {
-          inQuotes = true;
+          state.inQuotes = true;
           break;
         }
         if (char === ",") {
@@ -7370,10 +7439,10 @@ async function processCursorUsageCsvStream(response, onRow) {
         }
         if (char === "\r") {
           emitRow();
-          sawCarriageReturn = true;
+          state.sawCarriageReturn = true;
           break;
         }
-        currentField += char;
+        state.currentField += char;
         break;
       }
     }
@@ -7391,11 +7460,10 @@ async function processCursorUsageCsvStream(response, onRow) {
     reader.releaseLock();
   }
   processChunk(decoder.decode());
-  if (pendingQuote) {
-    pendingQuote = false;
-    inQuotes = false;
+  if (state.pendingQuote) {
+    state.inQuotes = false;
   }
-  if (currentField !== "" || currentRow.length > 0) {
+  if (state.currentField !== "" || state.currentRow.length > 0) {
     emitRow();
   }
 }
@@ -7456,11 +7524,23 @@ async function loadCursorRows(start, end) {
   const modelTotals = /* @__PURE__ */ new Map();
   const recentModelTotals = /* @__PURE__ */ new Map();
   if (!databasePath) {
-    return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+    return createUsageSummary(
+      "cursor",
+      totals,
+      modelTotals,
+      recentModelTotals,
+      end
+    );
   }
   const authState = await readCursorAuthState(databasePath);
   if (!authState.accessToken) {
-    return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+    return createUsageSummary(
+      "cursor",
+      totals,
+      modelTotals,
+      recentModelTotals,
+      end
+    );
   }
   const recentStart = getRecentWindowStart(end, 30);
   const response = await fetchCursorUsageCsv(authState.accessToken);
@@ -7481,20 +7561,34 @@ async function summarizeCursorUsageCsv(response, start, end, recentStart = getRe
       recentModelTotals
     );
   });
-  return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+  return createUsageSummary(
+    "cursor",
+    totals,
+    modelTotals,
+    recentModelTotals,
+    end
+  );
 }
 
 // src/lib/interfaces.ts
-var providerIds = ["claude", "codex", "cursor", "opencode"];
+var providerIds = [
+  "claude",
+  "codex",
+  "cursor",
+  "opencode",
+  "pi"
+];
+var defaultProviderIds = ["claude", "codex", "cursor"];
 var providerStatusLabel = {
   claude: "Claude code",
   codex: "Codex",
   cursor: "Cursor",
-  opencode: "Open Code"
+  opencode: "Open Code",
+  pi: "Pi Coding Agent"
 };
 
 // src/lib/open-code.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { copyFile as copyFile2, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
 import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
 import { join as join5, resolve as resolve4 } from "path";
@@ -7520,12 +7614,16 @@ function getOpenCodeBaseDir() {
 async function getOpenCodeSource() {
   const baseDir = getOpenCodeBaseDir();
   const databasePath = join5(baseDir, "opencode.db");
-  if (existsSync3(databasePath)) {
+  if (existsSync4(databasePath)) {
     return { kind: "database", path: databasePath };
   }
   const messagesDir = join5(baseDir, "storage", "message");
   return { kind: "legacy", files: await listFilesRecursive(messagesDir, ".json") };
 }
+function isOpenCodeAvailable() {
+  const baseDir = getOpenCodeBaseDir();
+  return existsSync4(join5(baseDir, "opencode.db")) || existsSync4(join5(baseDir, "storage", "message"));
+}
 async function loadSqliteModule() {
   try {
     const moduleName = "node:sqlite";
@@ -7571,7 +7669,7 @@ async function withDatabaseSnapshot(databasePath, callback) {
   await copyFile2(databasePath, snapshotPath);
   for (const suffix of ["-shm", "-wal"]) {
     const companionPath = `${databasePath}${suffix}`;
-    if (!existsSync3(companionPath)) {
+    if (!existsSync4(companionPath)) {
       continue;
     }
     await copyFile2(companionPath, `${snapshotPath}${suffix}`);
@@ -7680,7 +7778,152 @@ async function loadOpenCodeRows(start, end) {
   );
 }
 
+// src/lib/pi.ts
+import { existsSync as existsSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6, resolve as resolve5 } from "path";
+var PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+var CLASSIFICATION_PREFIX_BYTES2 = 16 * 1024;
+function getPiAgentDir() {
+  const configuredAgentDir = process.env[PI_AGENT_DIR_ENV]?.trim();
+  return configuredAgentDir ? resolve5(configuredAgentDir) : join6(homedir5(), ".pi", "agent");
+}
+async function getPiSessionFiles() {
+  return listFilesRecursive(join6(getPiAgentDir(), "sessions"), ".jsonl");
+}
+function isPiAvailable() {
+  return existsSync5(join6(getPiAgentDir(), "sessions"));
+}
+function classifyPiRecord(prefix) {
+  if (prefix.includes('"type":"message"') && prefix.includes('"role":"assistant"')) {
+    return { kind: "keep", classification: void 0 };
+  }
+  return { kind: "skip" };
+}
+function asNonEmptyString2(value) {
+  const trimmed = value?.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function createPiTokenTotals(usage) {
+  const cacheRead = usage.cacheRead ?? 0;
+  const cacheWrite = usage.cacheWrite ?? 0;
+  const input = (usage.input ?? 0) + cacheRead;
+  const output = (usage.output ?? 0) + cacheWrite;
+  const total = usage.totalTokens ?? input + output;
+  return {
+    input,
+    output,
+    cache: { input: cacheRead, output: cacheWrite },
+    total
+  };
+}
+function getPiTimestamp(entry) {
+  const rawTimestamp = entry.timestamp ?? entry.message?.timestamp;
+  if (typeof rawTimestamp === "string" || typeof rawTimestamp === "number") {
+    return new Date(rawTimestamp);
+  }
+  return null;
+}
+async function loadPiRows(start, end) {
+  const files = await getPiSessionFiles();
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  const recentStart = getRecentWindowStart(end, 30);
+  const maxRecordBytes = getPositiveIntegerEnv(
+    MAX_JSONL_RECORD_BYTES_ENV,
+    DEFAULT_MAX_JSONL_RECORD_BYTES
+  );
+  for (const file of files) {
+    for await (const record of readJsonlRecords(file, {
+      classificationPrefixBytes: CLASSIFICATION_PREFIX_BYTES2,
+      classify: classifyPiRecord,
+      maxRecordBytes,
+      oversizedErrorMessage: ({
+        filePath,
+        lineNumber,
+        maxRecordBytes: maxRecordBytes2,
+        envVarName
+      }) => `Relevant Pi Coding Agent record exceeds ${maxRecordBytes2} bytes in ${filePath}:${lineNumber}. Increase ${envVarName} to process this file.`
+    })) {
+      let entry;
+      try {
+        entry = JSON.parse(record.rawLine);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "message" || entry.message?.role !== "assistant") {
+        continue;
+      }
+      const usage = entry.message.usage;
+      if (!usage) {
+        continue;
+      }
+      const timestamp = getPiTimestamp(entry);
+      if (!timestamp || Number.isNaN(timestamp.getTime())) {
+        continue;
+      }
+      if (timestamp < start || timestamp > end) {
+        continue;
+      }
+      const tokenTotals = createPiTokenTotals(usage);
+      if (tokenTotals.total <= 0) {
+        continue;
+      }
+      const modelName = asNonEmptyString2(entry.message.model);
+      const normalizedModelName = modelName ? normalizeModelName(modelName) : void 0;
+      addDailyTokenTotals(totals, timestamp, tokenTotals, normalizedModelName);
+      if (!normalizedModelName) {
+        continue;
+      }
+      addModelTokenTotals(modelTotals, normalizedModelName, tokenTotals);
+      if (timestamp >= recentStart) {
+        addModelTokenTotals(
+          recentModelTotals,
+          normalizedModelName,
+          tokenTotals
+        );
+      }
+    }
+  }
+  return createUsageSummary("pi", totals, modelTotals, recentModelTotals, end);
+}
+
 // src/providers.ts
+function createEmptyProviderAvailability() {
+  return {
+    claude: false,
+    codex: false,
+    cursor: false,
+    opencode: false,
+    pi: false
+  };
+}
+async function isProviderAvailable(provider) {
+  switch (provider) {
+    case "claude":
+      return isClaudeAvailable();
+    case "codex":
+      return isCodexAvailable();
+    case "cursor":
+      return isCursorAvailable();
+    case "opencode":
+      return isOpenCodeAvailable();
+    case "pi":
+      return isPiAvailable();
+    default: {
+      const exhaustiveCheck = provider;
+      throw new Error(`Unhandled provider: ${String(exhaustiveCheck)}`);
+    }
+  }
+}
+async function getProviderAvailability(providers = providerIds) {
+  const availability = createEmptyProviderAvailability();
+  for (const provider of providers) {
+    availability[provider] = await isProviderAvailable(provider);
+  }
+  return availability;
+}
 function mergeProviderUsage(rowsByProvider, end) {
   const summaries = providerIds.map((provider) => rowsByProvider[provider]).filter((summary) => summary !== null);
   if (summaries.length === 0) {
@@ -7698,11 +7941,33 @@ async function aggregateUsage({
     claude: null,
     codex: null,
     cursor: null,
-    opencode: null
+    opencode: null,
+    pi: null
   };
   const warnings = [];
   for (const provider of providersToLoad) {
-    const summary = provider === "claude" ? await loadClaudeRows(start, end) : provider === "codex" ? await loadCodexRows(start, end, warnings) : provider === "cursor" ? await loadCursorRows(start, end) : await loadOpenCodeRows(start, end);
+    let summary;
+    switch (provider) {
+      case "claude":
+        summary = await loadClaudeRows(start, end);
+        break;
+      case "codex":
+        summary = await loadCodexRows(start, end, warnings);
+        break;
+      case "cursor":
+        summary = await loadCursorRows(start, end);
+        break;
+      case "opencode":
+        summary = await loadOpenCodeRows(start, end);
+        break;
+      case "pi":
+        summary = await loadPiRows(start, end);
+        break;
+      default: {
+        const exhaustiveCheck = provider;
+        throw new Error(`Unhandled provider: ${String(exhaustiveCheck)}`);
+      }
+    }
     rowsByProvider[provider] = hasUsage(summary) ? summary : null;
   }
   return { rowsByProvider, warnings };
@@ -7718,7 +7983,7 @@ var HELP_TEXT = `slopmeter
 Generate rolling 1-year usage heatmap image(s) (today is the latest day).
 
 Usage:
-  slopmeter [--all] [--claude] [--codex] [--cursor] [--opencode] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
+  slopmeter [--all] [--claude] [--codex] [--cursor] [--opencode] [--pi] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
 
 Options:
   --all                       Render one merged graph for all providers
@@ -7726,6 +7991,7 @@ Options:
   --codex                     Render Codex graph
   --cursor                    Render Cursor graph
   --opencode                  Render Open Code graph
+  --pi                        Render Pi Coding Agent graph
   --dark                      Render with the dark theme
   -f, --format                Output format: png, svg, or json (default: png)
   -o, --output                Output file path (default: ./heatmap-last-year.png)
@@ -7746,7 +8012,8 @@ function validateArgs(values) {
       claude: ow.boolean,
       codex: ow.boolean,
       cursor: ow.boolean,
-      opencode: ow.boolean
+      opencode: ow.boolean,
+      pi: ow.boolean
     })
   );
 }
@@ -7801,33 +8068,52 @@ function getDateWindow() {
   end.setHours(23, 59, 59, 999);
   return { start, end };
 }
-function printProviderAvailability(rowsByProvider, providers) {
+function printProviderAvailability(availabilityByProvider, providers) {
   for (const provider of providers) {
-    const found = rowsByProvider[provider] ? "found" : "not found";
-    process.stdout.write(`${providerStatusLabel[provider]} ${found}
+    const status = availabilityByProvider[provider] ? "available" : "not available";
+    process.stdout.write(`${providerStatusLabel[provider]} ${status}
 `);
   }
 }
 function getRequestedProviders(values) {
   return providerIds.filter((id) => values[id]);
 }
-function getOutputProviders(values, rowsByProvider, end) {
+function getOutputProviders(values, availabilityByProvider, rowsByProvider, end) {
   if (!values.all) {
-    return selectProvidersToRender(rowsByProvider, getRequestedProviders(values));
+    return selectProvidersToRender(
+      availabilityByProvider,
+      rowsByProvider,
+      getRequestedProviders(values)
+    );
   }
   const merged = mergeProviderUsage(rowsByProvider, end);
   if (!merged) {
-    throw new Error(
-      "No usage data found for Claude code, Codex, Cursor, or Open code."
-    );
+    throw new Error("No usage data found for any provider.");
   }
   return [merged];
 }
+function getDefaultOutputProviderIds(rowsByProvider) {
+  const selected = [];
+  const fallbackProviders = providerIds.filter(
+    (provider) => !defaultProviderIds.includes(provider)
+  );
+  for (const provider of [...defaultProviderIds, ...fallbackProviders]) {
+    if (!rowsByProvider[provider] || selected.includes(provider)) {
+      continue;
+    }
+    selected.push(provider);
+    if (selected.length === 3) {
+      return selected;
+    }
+  }
+  return selected;
+}
 function getMergedProviderTitle(rowsByProvider) {
   return providerIds.filter((provider) => rowsByProvider[provider] !== null).map((provider) => heatmapThemes[provider].title).join(" / ");
 }
-function selectProvidersToRender(rowsByProvider, requested) {
-  const providersToRender = requested.length > 0 ? requested.filter((provider) => rowsByProvider[provider]) : providerIds.filter((provider) => rowsByProvider[provider]);
+function selectProvidersToRender(availabilityByProvider, rowsByProvider, requested) {
+  const defaultProviders = getDefaultOutputProviderIds(rowsByProvider);
+  const providersToRender = requested.length > 0 ? requested.filter((provider) => rowsByProvider[provider]) : defaultProviders.filter((provider) => rowsByProvider[provider]);
   if (requested.length > 0 && providersToRender.length < requested.length) {
     const missing = requested.filter((provider) => !rowsByProvider[provider]);
     throw new Error(
@@ -7835,8 +8121,18 @@ function selectProvidersToRender(rowsByProvider, requested) {
     );
   }
   if (providersToRender.length === 0) {
+    const availableProviders = providerIds.filter(
+      (provider) => availabilityByProvider[provider]
+    );
+    if (availableProviders.length > 0) {
+      const availableLabels = availableProviders.map((provider) => providerStatusLabel[provider]).join(", ");
+      const defaultLabels = defaultProviderIds.map((provider) => providerStatusLabel[provider]).join(", ");
+      throw new Error(
+        `No usage data found for available providers (${availableLabels}). Preferred order is ${defaultLabels}. Use --all or specify providers explicitly.`
+      );
+    }
     throw new Error(
-      "No usage data found for Claude code, Codex, Cursor, or Open code."
+      "No usage data found for any provider."
     );
   }
   return providersToRender.map((provider) => rowsByProvider[provider]);
@@ -7870,7 +8166,8 @@ async function main() {
       claude: { type: "boolean", default: false },
       codex: { type: "boolean", default: false },
       cursor: { type: "boolean", default: false },
-      opencode: { type: "boolean", default: false }
+      opencode: { type: "boolean", default: false },
+      pi: { type: "boolean", default: false }
     },
     allowPositionals: false
   });
@@ -7890,6 +8187,7 @@ async function main() {
     const format = inferFormat(values.format, values.output);
     const requestedProviders = values.all ? providerIds : getRequestedProviders(values);
     const inspectedProviders = requestedProviders.length > 0 ? requestedProviders : providerIds;
+    const availabilityByProvider = await getProviderAvailability(inspectedProviders);
     const { rowsByProvider, warnings } = await aggregateUsage({
       start,
       end,
@@ -7900,13 +8198,14 @@ async function main() {
       process.stderr.write(`${warning}
 `);
     }
-    printProviderAvailability(rowsByProvider, inspectedProviders);
+    printProviderAvailability(availabilityByProvider, inspectedProviders);
     const exportProviders = getOutputProviders(
       values,
+      availabilityByProvider,
       rowsByProvider,
       end
     );
-    const outputPath = resolve5(
+    const outputPath = resolve6(
       values.output ?? `./heatmap-last-year.${format}`
     );
     mkdirSync(dirname(outputPath), { recursive: true });