@cad0p/pi-usage 0.11.3 → 0.11.4

package/src/omarchy/publish.js

@@ -7,10 +7,9 @@
  * Omarchy's own `claude.json` / `codex.json` records are never touched.
  */
 
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { isPiRecordId, RECORD_PREFIX } from "./record.js";
 
@@ -57,68 +56,6 @@ function writeRecord(dir, id, record) {
   return target;
 }
 
-/**
- * Copy a file only if the target does not exist or its content differs.
- * This is critical when writing to directories watched by inotify, such as
- * Omarchy's plugins directory, where redundant writes trigger full shell reloads.
- *
- * @param {string} srcPath
- * @param {string} dstPath
- * @returns {boolean} Whether the file was written.
- */
-function copyIfChanged(srcPath, dstPath) {
-  try {
-    if (existsSync(dstPath)) {
-      const srcBuf = readFileSync(srcPath);
-      const dstBuf = readFileSync(dstPath);
-      if (srcBuf.equals(dstBuf)) return false;
-    }
-    copyFileSync(srcPath, dstPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Synchronize provider SVG icons into Omarchy plugin assets directories if present.
- *
- * @param {{ env?: Record<string, string | undefined>, home?: string }} [options]
- * @returns {string[]} Paths of written assets.
- */
-export function syncOmarchyAssets(options = {}) {
-  const env = options.env ?? process.env;
-  const home = options.home ?? (env.HOME || homedir());
-  const pluginsDir = join(home, ".config", "omarchy", "plugins");
-  if (!existsSync(pluginsDir)) return [];
-
-  const assetsSrc = fileURLToPath(new URL("assets", import.meta.url));
-  if (!existsSync(assetsSrc)) return [];
-
-  const copied = [];
-  try {
-    for (const plugin of readdirSync(pluginsDir)) {
-      const pluginDir = join(pluginsDir, plugin);
-      const manifestPath = join(pluginDir, "manifest.json");
-      if (!existsSync(manifestPath)) continue;
-      const targetAssetsDir = join(pluginDir, "assets");
-      if (!existsSync(targetAssetsDir)) {
-        mkdirSync(targetAssetsDir, { recursive: true });
-      }
-
-      for (const file of readdirSync(assetsSrc)) {
-        if (!file.endsWith(".svg")) continue;
-        const srcPath = join(assetsSrc, file);
-        const dstPath = join(targetAssetsDir, file);
-        const piDstPath = join(targetAssetsDir, `pi-${file}`);
-        if (copyIfChanged(srcPath, dstPath)) copied.push(dstPath);
-        if (copyIfChanged(srcPath, piDstPath)) copied.push(piDstPath);
-      }
-    }
-  } catch {}
-  return copied;
-}
-
 /**
  * Write the given records and remove stale `pi-*.json` files whose provider is
  * no longer present.
@@ -146,7 +83,6 @@ export function publishRecords(records, options = {}) {
     removed.push(join(dir, name));
   }
 
-  syncOmarchyAssets(options);
 
   return { dir, written, removed };
 }

package/src/omarchy/record.js

@@ -10,9 +10,15 @@
  *
  * Record contract (see Omarchy's plugins/agents/Main.qml):
  *   id, name, ready, updatedAt, schemaVersion, tierLabel, usageStatusText,
- *   authHelpText and `limits[{label, title, percent, resetsAt}]`. The local
- *   token statistics are optional and are deliberately left out; the panel
- *   treats their absence as "no local stats".
+ *   authHelpText and `limits[{label, title, percent, resetsAt}]`. When the
+ *   report carries local token statistics for the family, the panel's optional
+ *   stats fields are merged in (today's tokens and prompts, the last seven
+ *   days, all-time per-model buckets) and `hasLocalStats` says they are there.
+ *
+ * A family with several accounts also carries `accounts[{id, ok, status,
+ * limits}]`: every window of every account, for panels that can draw them
+ * (this package's own Omarchy plugin). Omarchy's built-in panel ignores the
+ * key and keeps reading the flattened `limits`.
  *
  * `percent` is a FRACTION in 0..1 (the panel multiplies it by 100), so 40.3% used
  * is written as 0.403.
@@ -296,6 +302,18 @@ function compactLabels(labels) {
   return parts.join(", ");
 }
 
+/**
+ * The per-account status line: the same reason as the compact summary, as a
+ * sentence-case label ("Key rejected", "No Go plan").
+ *
+ * @param {string | null | undefined} error
+ * @returns {string}
+ */
+function accountStatus(error) {
+  const reason = failureReason(error);
+  return reason.charAt(0).toUpperCase() + reason.slice(1);
+}
+
 /**
  * Explain failures compactly, grouped by reason in slot order, e.g.
  * "#8–#10 key rejected · #11–#14 no Go plan".
@@ -330,6 +348,9 @@ function compactFailureList(failures) {
  * summarised in the status and the compact help text, which is what makes a
  * revoked key distinguishable from a workspace without a plan.
  *
+ * `accounts` repeats the family per account with every window, untitled by
+ * slot (the account id already says which one), for panels that show them all.
+ *
  * @param {string} family
  * @param {import("../model.js").QuotaResult[]} providers
  * @param {{ now?: number }} [options]
@@ -345,6 +366,8 @@ function buildFamilyRecord(family, providers, options = {}) {
   const limits = [];
   /** @type {Array<{ label: string, reason: string }>} */
   const failures = [];
+  /** @type {Array<{ id: string, ok: boolean, status: string, limits: Array<{ label: string, title: string, percent: number, resetsAt: string }> }>} */
+  const accounts = [];
   let okCount = 0;
 
   providers.forEach((provider, index) => {
@@ -354,9 +377,11 @@ function buildFamilyRecord(family, providers, options = {}) {
       const window = bindingWindow(provider.windows);
       const mapped = window ? mapLimits([window], provider, `${label} · `)[0] : null;
       if (mapped) limits.push(mapped);
+      accounts.push({ id: redact(label), ok: true, status: "", limits: mapLimits(provider.windows, provider) });
       return;
     }
     failures.push({ label, reason: failureReason(provider.error) });
+    accounts.push({ id: redact(label), ok: false, status: accountStatus(provider.error), limits: [] });
   });
 
   const failedCount = providers.length - okCount;
@@ -378,22 +403,68 @@ function buildFamilyRecord(family, providers, options = {}) {
       ready: okCount > 0,
       tierLabel: `${okCount} of ${providers.length} accounts`,
       limits: limits.length > 0 ? limits : [{ ...PLACEHOLDER_LIMIT }],
+      accounts,
       usageStatusText: status.usageStatusText,
       authHelpText: failures.length > 0 ? compactFailureList(failures) : status.authHelpText,
       hasLocalStats: false,
       hasPromptStats: false,
+      ...localStatsFields(options.localStats),
       updatedAt: new Date(now).toISOString(),
     },
   };
 }
 
+/**
+ * The optional token fields Omarchy's Agents panel reads. Only aggregate counts
+ * are copied: no prompt text, no session path, no account identity.
+ *
+ * `totalSessions` counts session-DAYS, not distinct session files: a session
+ * that runs past midnight is one session in 20 files of `sessions/` but two
+ * rows here, because history is frozen per local day and a session's identity is
+ * gone once its day is (see the README's token-stats section).
+ *
+ * @param {import("../local/pi-sessions.js").LocalFamilyStats | undefined} stats
+ * @returns {Record<string, unknown>}
+ */
+function localStatsFields(stats) {
+  if (!stats || stats.hasLocalStats !== true) return {};
+  const modelUsage = {};
+  for (const [model, bucket] of Object.entries(stats.modelUsage ?? {})) {
+    modelUsage[model] = {
+      inputTokens: Number(bucket?.inputTokens) || 0,
+      outputTokens: Number(bucket?.outputTokens) || 0,
+      cacheReadInputTokens: Number(bucket?.cacheReadInputTokens) || 0,
+      cacheCreationInputTokens: Number(bucket?.cacheCreationInputTokens) || 0,
+    };
+  }
+  return {
+    hasLocalStats: true,
+    hasPromptStats: true,
+    todayPrompts: Number(stats.todayPrompts) || 0,
+    todaySessions: Number(stats.todaySessions) || 0,
+    todayTotalTokens: Number(stats.todayTotalTokens) || 0,
+    todayTokensByModel: Object.fromEntries(
+      Object.entries(stats.todayTokensByModel ?? {}).map(([model, tokens]) => [model, Number(tokens) || 0]),
+    ),
+    recentDays: (stats.recentDays ?? []).map((day) => ({
+      date: String(day?.date ?? ""),
+      messageCount: Number(day?.messageCount) || 0,
+    })),
+    totalPrompts: Number(stats.totalPrompts) || 0,
+    totalSessions: Number(stats.totalSessions) || 0,
+    activeDays: Number(stats.activeDays) || 0,
+    activeDates: [...(stats.activeDates ?? [])],
+    modelUsage,
+  };
+}
+
 /**
  * Build the record for one provider, or `null` when the provider is simply not
  * configured: a tab that only says "not configured" is noise, so it is omitted
  * (and any record from an earlier run is removed by the publisher).
  *
  * @param {import("../model.js").QuotaResult} provider
- * @param {{ now?: number }} [options]
+ * @param {{ now?: number, localStats?: import("../local/pi-sessions.js").LocalFamilyStats }} [options]
  * @returns {{ id: string, record: Record<string, unknown> } | null}
  */
 export function buildRecord(provider, options = {}) {
@@ -421,6 +492,7 @@ export function buildRecord(provider, options = {}) {
       authHelpText: status.authHelpText,
       hasLocalStats: false,
       hasPromptStats: false,
+      ...localStatsFields(options.localStats),
       updatedAt: new Date(now).toISOString(),
     },
   };
@@ -434,7 +506,7 @@ export function buildRecord(provider, options = {}) {
  * Never throws: a malformed provider entry is skipped.
  *
  * @param {import("../engine.js").PiQuotaReport} report
- * @param {{ now?: number }} [options]
+ * @param {{ now?: number, localStats?: Record<string, import("../local/pi-sessions.js").LocalFamilyStats> }} [options]
  * @returns {Array<{ id: string, record: Record<string, unknown> }>}
  */
 export function buildRecords(report, options = {}) {
@@ -450,9 +522,12 @@ export function buildRecords(report, options = {}) {
   const records = [];
   for (const [family, providers] of groups) {
     try {
+      // Local stats belong to the family, not to one account: Omarchy's panel
+      // draws one token section per tab.
+      const familyOptions = { ...options, localStats: report?.localStats?.[family] };
       const built = providers.length > 1
-        ? buildFamilyRecord(family, providers, options)
-        : buildRecord(providers[0], options);
+        ? buildFamilyRecord(family, providers, familyOptions)
+        : buildRecord(providers[0], familyOptions);
       if (built) records.push(built);
     } catch {
       // A broken entry must not take the other providers' records down with it.