slopmeter 0.4.1 → 0.5.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { dirname, extname, resolve as resolve4 } from "path";
+import { dirname, extname, resolve as resolve6 } from "path";
 import { parseArgs } from "util";
 import ora from "ora";
 import ow from "ow";
@@ -5715,6 +5715,35 @@ var heatmapThemes = {
       ]
     }
   },
+  cursor: {
+    title: "Cursor",
+    colors: {
+      light: [
+        "#fff7ed",
+        // orange-50
+        "#fed7aa",
+        // orange-200
+        "#fdba74",
+        // orange-300
+        "#f97316",
+        // orange-500
+        "#9a3412"
+        // orange-800
+      ],
+      dark: [
+        "#431407",
+        // orange-950
+        "#9a3412",
+        // orange-800
+        "#c2410c",
+        // orange-700
+        "#f97316",
+        // orange-500
+        "#fdba74"
+        // orange-300
+      ]
+    }
+  },
   opencode: {
     title: "Open Code",
     colors: {
@@ -5744,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 / Open Code",
+    title: "Codex / Claude Code / Cursor / Open Code / Pi Coding Agent",
     titleCaption: "Total usage from",
     colors: {
       light: [
@@ -5971,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);
@@ -6485,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) {
@@ -6618,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;
@@ -6638,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(
@@ -6662,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;
@@ -6688,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;
@@ -6930,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;
@@ -7004,22 +7089,509 @@ 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 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";
+import Database from "better-sqlite3";
+var CURSOR_CONFIG_DIR_ENV = "CURSOR_CONFIG_DIR";
+var CURSOR_STATE_DB_PATH_ENV = "CURSOR_STATE_DB_PATH";
+var CURSOR_WEB_BASE_URL_ENV = "CURSOR_WEB_BASE_URL";
+var CURSOR_STATE_DB_RELATIVE_PATH = join4(
+  "User",
+  "globalStorage",
+  "state.vscdb"
+);
+var CURSOR_SESSION_COOKIE_NAME = "WorkosCursorSessionToken";
+function getCursorDefaultStateDbPath() {
+  if (process.platform === "darwin") {
+    return join4(
+      homedir3(),
+      "Library",
+      "Application Support",
+      "Cursor",
+      CURSOR_STATE_DB_RELATIVE_PATH
+    );
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA?.trim() || join4(homedir3(), "AppData", "Roaming");
+    return join4(appData, "Cursor", CURSOR_STATE_DB_RELATIVE_PATH);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join4(homedir3(), ".config");
+  return join4(xdgConfigHome, "Cursor", CURSOR_STATE_DB_RELATIVE_PATH);
+}
+function getCursorStateDbCandidates() {
+  const explicitDbPath = process.env[CURSOR_STATE_DB_PATH_ENV]?.trim();
+  if (explicitDbPath) {
+    return [resolve3(explicitDbPath)];
+  }
+  const configuredDirs = process.env[CURSOR_CONFIG_DIR_ENV]?.trim();
+  if (!configuredDirs) {
+    return [getCursorDefaultStateDbPath()];
+  }
+  return configuredDirs.split(",").map((value) => value.trim()).filter((value) => value !== "").map((value) => {
+    const resolved = resolve3(value);
+    return resolved.endsWith(".vscdb") ? resolved : join4(resolved, CURSOR_STATE_DB_RELATIVE_PATH);
+  });
+}
+function getCursorStateDbPath() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of getCursorStateDbCandidates()) {
+    if (!seen.has(candidate) && existsSync3(candidate)) {
+      return candidate;
+    }
+    seen.add(candidate);
+  }
+  return null;
+}
+function normalizeCursorDbValue(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed === "" ? void 0 : trimmed;
+  }
+  if (Buffer.isBuffer(value)) {
+    const trimmed = value.toString("utf8").trim();
+    return trimmed === "" ? void 0 : trimmed;
+  }
+  return void 0;
+}
+function readCursorAuthStateFromDatabase(databasePath) {
+  const database = new Database(databasePath, {
+    readonly: true,
+    fileMustExist: true
+  });
+  try {
+    const query = database.prepare(
+      "SELECT value FROM ItemTable WHERE key = ? LIMIT 1"
+    );
+    const accessRow = query.get("cursorAuth/accessToken");
+    const refreshRow = query.get("cursorAuth/refreshToken");
+    return {
+      accessToken: normalizeCursorDbValue(accessRow?.value),
+      refreshToken: normalizeCursorDbValue(refreshRow?.value)
+    };
+  } finally {
+    database.close();
+  }
+}
+function isSqliteLockedError(error) {
+  return error instanceof Error && /database is locked/i.test(error.message);
+}
+async function withCursorStateSnapshot(databasePath, callback) {
+  const snapshotDir = await mkdtemp(join4(tmpdir(), "slopmeter-cursor-"));
+  const snapshotPath = join4(snapshotDir, "state.vscdb");
+  await copyFile(databasePath, snapshotPath);
+  for (const suffix of ["-shm", "-wal"]) {
+    const companionPath = `${databasePath}${suffix}`;
+    if (!existsSync3(companionPath)) {
+      continue;
+    }
+    await copyFile(companionPath, `${snapshotPath}${suffix}`);
+  }
+  try {
+    return await callback(snapshotPath);
+  } finally {
+    await rm(snapshotDir, { recursive: true, force: true });
+  }
+}
+async function readCursorAuthState(databasePath) {
+  try {
+    return readCursorAuthStateFromDatabase(databasePath);
+  } catch (error) {
+    if (!isSqliteLockedError(error)) {
+      throw error;
+    }
+    return withCursorStateSnapshot(
+      databasePath,
+      async (snapshotPath) => readCursorAuthStateFromDatabase(snapshotPath)
+    );
+  }
+}
+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) {
+    return null;
+  }
+  const base64 = encodedPayload.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  try {
+    return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function getCursorWebBaseUrl() {
+  return (process.env[CURSOR_WEB_BASE_URL_ENV]?.trim() || "https://cursor.com").replace(/\/+$/, "");
+}
+function buildCookieHeaderValue(cookieValue) {
+  return `${CURSOR_SESSION_COOKIE_NAME}=${cookieValue}`;
+}
+function getCursorFetchAttempts(accessToken) {
+  const attempts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const subject = decodeJwtPayload(accessToken)?.sub?.trim();
+  const cookieValues = [accessToken];
+  if (subject) {
+    cookieValues.push(`${subject}::${accessToken}`);
+  }
+  const pushAttempt = (label, headers) => {
+    const signature = JSON.stringify({
+      label,
+      headers: Object.entries(headers).sort(
+        ([left], [right]) => left.localeCompare(right)
+      )
+    });
+    if (seen.has(signature)) {
+      return;
+    }
+    seen.add(signature);
+    attempts.push({ label, headers });
+  };
+  pushAttempt("bearer", {
+    Authorization: `Bearer ${accessToken}`
+  });
+  for (const cookieValue of cookieValues) {
+    pushAttempt("cookie", {
+      Cookie: buildCookieHeaderValue(cookieValue)
+    });
+    pushAttempt("cookie-encoded", {
+      Cookie: buildCookieHeaderValue(encodeURIComponent(cookieValue))
+    });
+    pushAttempt("bearer+cookie", {
+      Authorization: `Bearer ${accessToken}`,
+      Cookie: buildCookieHeaderValue(cookieValue)
+    });
+    pushAttempt("bearer+cookie-encoded", {
+      Authorization: `Bearer ${accessToken}`,
+      Cookie: buildCookieHeaderValue(encodeURIComponent(cookieValue))
+    });
+  }
+  return attempts;
+}
+async function fetchCursorUsageCsv(accessToken) {
+  const url = new URL(
+    "/api/dashboard/export-usage-events-csv?strategy=tokens",
+    getCursorWebBaseUrl()
+  );
+  const failures = [];
+  for (const attempt of getCursorFetchAttempts(accessToken)) {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "text/csv,text/plain;q=0.9,*/*;q=0.8",
+        ...attempt.headers
+      }
+    });
+    if (response.ok) {
+      return response;
+    }
+    failures.push({
+      label: attempt.label,
+      status: response.status,
+      statusText: response.statusText,
+      body: (await response.text()).trim().slice(0, 200)
+    });
+  }
+  const summary = failures.map((failure) => {
+    const statusLine = `${failure.label}: ${failure.status} ${failure.statusText}`.trim();
+    return failure.body ? `${statusLine} (${failure.body})` : statusLine;
+  }).join("; ");
+  throw new Error(
+    `Failed to authenticate Cursor usage export with local auth state from ${url.origin}. ${summary}`
+  );
+}
+function parseCsvLine(line) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === '"') {
+      if (inQuotes && line[index + 1] === '"') {
+        current += '"';
+        index += 1;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values;
+}
+function createCursorCsvRow(headers, values) {
+  const row = {};
+  headers.forEach((header, index) => {
+    row[header] = values[index];
+  });
+  return row;
+}
+function processCursorCsvLines(lines, onRow) {
+  let headers = null;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line === "") {
+      continue;
+    }
+    const values = parseCsvLine(line);
+    if (!headers) {
+      headers = values;
+      continue;
+    }
+    onRow(createCursorCsvRow(headers, values));
+  }
+}
+function processCursorUsageCsvText(content, onRow) {
+  processCursorCsvLines(content.split(/\r?\n/), onRow);
+}
+async function processCursorUsageCsvStream(response, onRow) {
+  if (!response.body) {
+    processCursorUsageCsvText(await response.text(), onRow);
+    return;
+  }
+  let headers = null;
+  const state = {
+    currentField: "",
+    currentRow: [],
+    inQuotes: false,
+    pendingQuote: false,
+    sawCarriageReturn: false
+  };
+  const decoder = new TextDecoder();
+  const emitField = () => {
+    state.currentRow.push(state.currentField);
+    state.currentField = "";
+  };
+  const emitRow = () => {
+    emitField();
+    if (state.currentRow.every((value) => value.trim() === "")) {
+      state.currentRow = [];
+      return;
+    }
+    if (!headers) {
+      headers = state.currentRow;
+      state.currentRow = [];
+      return;
+    }
+    onRow(createCursorCsvRow(headers, state.currentRow));
+    state.currentRow = [];
+  };
+  const processChunk = (chunk) => {
+    for (const char of chunk) {
+      for (; ; ) {
+        if (state.sawCarriageReturn) {
+          state.sawCarriageReturn = false;
+          if (char === "\n") {
+            break;
+          }
+        }
+        if (state.pendingQuote) {
+          state.pendingQuote = false;
+          if (char === '"') {
+            state.currentField += '"';
+            break;
+          }
+          state.inQuotes = false;
+          continue;
+        }
+        if (state.inQuotes) {
+          if (char === '"') {
+            state.pendingQuote = true;
+          } else {
+            state.currentField += char;
+          }
+          break;
+        }
+        if (char === '"') {
+          state.inQuotes = true;
+          break;
+        }
+        if (char === ",") {
+          emitField();
+          break;
+        }
+        if (char === "\n") {
+          emitRow();
+          break;
+        }
+        if (char === "\r") {
+          emitRow();
+          state.sawCarriageReturn = true;
+          break;
+        }
+        state.currentField += char;
+        break;
+      }
+    }
+  };
+  const reader = response.body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      processChunk(decoder.decode(value, { stream: true }));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  processChunk(decoder.decode());
+  if (state.pendingQuote) {
+    state.inQuotes = false;
+  }
+  if (state.currentField !== "" || state.currentRow.length > 0) {
+    emitRow();
+  }
+}
+function addCursorUsageRow(row, start, end, recentStart, totals, modelTotals, recentModelTotals) {
+  const date = parseCursorDate(row.Date);
+  const rawModel = row.Model?.trim();
+  const tokenTotals = createCursorTokenTotals(row);
+  if (!date || !rawModel || !tokenTotals) {
+    return;
+  }
+  if (date < start || date > end) {
+    return;
+  }
+  const modelName = normalizeModelName(rawModel);
+  addDailyTokenTotals(totals, date, tokenTotals, modelName);
+  addModelTokenTotals(modelTotals, modelName, tokenTotals);
+  if (date >= recentStart) {
+    addModelTokenTotals(recentModelTotals, modelName, tokenTotals);
+  }
+}
+function parseCursorDate(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    return /* @__PURE__ */ new Date(`${trimmed}T00:00:00`);
+  }
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseCursorNumber(value) {
+  const numeric = Number(value?.replaceAll(",", "").trim() ?? "");
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return null;
+  }
+  return Math.round(numeric);
+}
+function createCursorTokenTotals(row) {
+  const total = parseCursorNumber(row["Total Tokens"]) ?? parseCursorNumber(row.Tokens);
+  if (!total) {
+    return null;
+  }
+  const inputWithCacheWrite = parseCursorNumber(row["Input (w/ Cache Write)"]) ?? 0;
+  const inputWithoutCacheWrite = parseCursorNumber(row["Input (w/o Cache Write)"]) ?? 0;
+  const cacheInput = parseCursorNumber(row["Cache Read"]) ?? 0;
+  const outputTokens = parseCursorNumber(row["Output Tokens"]) ?? 0;
+  return {
+    input: inputWithCacheWrite + inputWithoutCacheWrite + cacheInput,
+    output: outputTokens,
+    cache: { input: cacheInput, output: inputWithCacheWrite },
+    total
+  };
+}
+async function loadCursorRows(start, end) {
+  const databasePath = getCursorStateDbPath();
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  if (!databasePath) {
+    return createUsageSummary(
+      "cursor",
+      totals,
+      modelTotals,
+      recentModelTotals,
+      end
+    );
+  }
+  const authState = await readCursorAuthState(databasePath);
+  if (!authState.accessToken) {
+    return createUsageSummary(
+      "cursor",
+      totals,
+      modelTotals,
+      recentModelTotals,
+      end
+    );
+  }
+  const recentStart = getRecentWindowStart(end, 30);
+  const response = await fetchCursorUsageCsv(authState.accessToken);
+  return summarizeCursorUsageCsv(response, start, end, recentStart);
+}
+async function summarizeCursorUsageCsv(response, start, end, recentStart = getRecentWindowStart(end, 30)) {
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  await processCursorUsageCsvStream(response, (row) => {
+    addCursorUsageRow(
+      row,
+      start,
+      end,
+      recentStart,
+      totals,
+      modelTotals,
+      recentModelTotals
+    );
+  });
+  return createUsageSummary(
+    "cursor",
+    totals,
+    modelTotals,
+    recentModelTotals,
+    end
+  );
 }
 
 // src/lib/interfaces.ts
-var providerIds = ["claude", "codex", "opencode"];
+var providerIds = [
+  "claude",
+  "codex",
+  "cursor",
+  "opencode",
+  "pi"
+];
+var defaultProviderIds = ["claude", "codex", "cursor"];
 var providerStatusLabel = {
   claude: "Claude code",
   codex: "Codex",
-  opencode: "Open Code"
+  cursor: "Cursor",
+  opencode: "Open Code",
+  pi: "Pi Coding Agent"
 };
 
 // src/lib/open-code.ts
-import { existsSync as existsSync2 } 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";
+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";
 function sumOpenCodeTokens(tokens) {
   const cacheInput = tokens?.cache?.read ?? 0;
   const cacheOutput = tokens?.cache?.write ?? 0;
@@ -7036,18 +7608,22 @@ async function parseOpenCodeFile(filePath) {
   return readJsonDocument(filePath);
 }
 function getOpenCodeBaseDir() {
-  const baseDir = process.env.OPENCODE_DATA_DIR?.trim() ? resolve3(process.env.OPENCODE_DATA_DIR) : join4(homedir3(), ".local", "share", "opencode");
+  const baseDir = process.env.OPENCODE_DATA_DIR?.trim() ? resolve4(process.env.OPENCODE_DATA_DIR) : join5(homedir4(), ".local", "share", "opencode");
   return baseDir;
 }
 async function getOpenCodeSource() {
   const baseDir = getOpenCodeBaseDir();
-  const databasePath = join4(baseDir, "opencode.db");
-  if (existsSync2(databasePath)) {
+  const databasePath = join5(baseDir, "opencode.db");
+  if (existsSync4(databasePath)) {
     return { kind: "database", path: databasePath };
   }
-  const messagesDir = join4(baseDir, "storage", "message");
+  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";
@@ -7084,24 +7660,24 @@ function parseOpenCodeMessageData(rowId, sourceLabel, content) {
     id: message.id || rowId
   };
 }
-function isSqliteLockedError(error) {
+function isSqliteLockedError2(error) {
   return error instanceof Error && /database is locked/i.test(error.message);
 }
 async function withDatabaseSnapshot(databasePath, callback) {
-  const snapshotDir = await mkdtemp(join4(tmpdir(), "slopmeter-opencode-"));
-  const snapshotPath = join4(snapshotDir, "opencode.db");
-  await copyFile(databasePath, snapshotPath);
+  const snapshotDir = await mkdtemp2(join5(tmpdir2(), "slopmeter-opencode-"));
+  const snapshotPath = join5(snapshotDir, "opencode.db");
+  await copyFile2(databasePath, snapshotPath);
   for (const suffix of ["-shm", "-wal"]) {
     const companionPath = `${databasePath}${suffix}`;
-    if (!existsSync2(companionPath)) {
+    if (!existsSync4(companionPath)) {
       continue;
     }
-    await copyFile(companionPath, `${snapshotPath}${suffix}`);
+    await copyFile2(companionPath, `${snapshotPath}${suffix}`);
   }
   try {
     return await callback(snapshotPath);
   } finally {
-    await rm(snapshotDir, { recursive: true, force: true });
+    await rm2(snapshotDir, { recursive: true, force: true });
   }
 }
 async function iterateOpenCodeDatabaseMessages(databasePath, onMessage) {
@@ -7130,7 +7706,7 @@ async function loadOpenCodeDatabaseMessages(databasePath, onMessage) {
   try {
     await iterateOpenCodeDatabaseMessages(databasePath, onMessage);
   } catch (error) {
-    if (!isSqliteLockedError(error)) {
+    if (!isSqliteLockedError2(error)) {
       throw error;
     }
     await withDatabaseSnapshot(databasePath, async (snapshotPath) => {
@@ -7202,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) {
@@ -7219,11 +7940,34 @@ async function aggregateUsage({
   const rowsByProvider = {
     claude: null,
     codex: null,
-    opencode: null
+    cursor: 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) : 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 };
@@ -7239,13 +7983,15 @@ var HELP_TEXT = `slopmeter
 Generate rolling 1-year usage heatmap image(s) (today is the latest day).
 
 Usage:
-  slopmeter [--all] [--claude] [--codex] [--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
   --claude                    Render Claude Code graph
   --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)
@@ -7265,7 +8011,9 @@ function validateArgs(values) {
       all: ow.boolean,
       claude: ow.boolean,
       codex: ow.boolean,
-      opencode: ow.boolean
+      cursor: ow.boolean,
+      opencode: ow.boolean,
+      pi: ow.boolean
     })
   );
 }
@@ -7320,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, 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(
@@ -7354,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, or Open code."
+      "No usage data found for any provider."
     );
   }
   return providersToRender.map((provider) => rowsByProvider[provider]);
@@ -7388,7 +8165,9 @@ async function main() {
       all: { type: "boolean", default: false },
       claude: { type: "boolean", default: false },
       codex: { type: "boolean", default: false },
-      opencode: { type: "boolean", default: false }
+      cursor: { type: "boolean", default: false },
+      opencode: { type: "boolean", default: false },
+      pi: { type: "boolean", default: false }
     },
     allowPositionals: false
   });
@@ -7408,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,
@@ -7418,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 = resolve4(
+    const outputPath = resolve6(
       values.output ?? `./heatmap-last-year.${format}`
     );
     mkdirSync(dirname(outputPath), { recursive: true });