@guenbankhai/tools 0.0.0-stage → 0.1.0

package/agentmoni/lib/catalog.json

@@ -0,0 +1,493 @@
+{
+  "version": 2,
+  "contextWarn": 0.8,
+  "models": {
+    "claude-haiku-5-5": {
+      "context": 200000,
+      "weights": [
+        {
+          "value": 1,
+          "source": "community",
+          "at": "2026-10-01",
+          "validFrom": "2026-10-01"
+        }
+      ],
+      "agent": "claude",
+      "tier": 1,
+      "color": 145,
+      "prices": [
+        {
+          "input": 0.1,
+          "cacheWrite5m": 0.125,
+          "cacheWrite1h": 0.2,
+          "cacheRead": 0.01,
+          "output": 0.5,
+          "source": "https://platform.claude.com/docs/en/about-claude/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "geoMultipliers": {
+            "us": 1.1,
+            "global": 1
+          },
+          "long": {
+            "above": 100000,
+            "input": 0.5,
+            "cacheWrite5m": 0.625,
+            "cacheWrite1h": 1,
+            "cacheRead": 0.05,
+            "output": 2.5
+          }
+        }
+      ]
+    },
+    "claude-sonnet-5-5": {
+      "context": 200000,
+      "weights": [
+        {
+          "value": 1.5,
+          "source": "community",
+          "at": "2026-10-01",
+          "validFrom": "2026-10-01"
+        }
+      ],
+      "agent": "claude",
+      "tier": 2,
+      "color": 75,
+      "prices": [
+        {
+          "input": 2,
+          "cacheWrite5m": 2.5,
+          "cacheWrite1h": 4,
+          "cacheRead": 0.1,
+          "output": 10,
+          "source": "https://platform.claude.com/docs/en/about-claude/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "geoMultipliers": {
+            "us": 1.1,
+            "global": 1
+          }
+        }
+      ]
+    },
+    "claude-opus-5-5": {
+      "context": 200000,
+      "weights": [
+        {
+          "value": 2.2,
+          "source": "community",
+          "at": "2026-10-01",
+          "validFrom": "2026-10-01"
+        }
+      ],
+      "agent": "claude",
+      "tier": 3,
+      "color": 280,
+      "prices": [
+        {
+          "input": 4,
+          "cacheWrite5m": 5,
+          "cacheWrite1h": 8,
+          "cacheRead": 0.2,
+          "output": 20,
+          "source": "https://platform.claude.com/docs/en/about-claude/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "geoMultipliers": {
+            "us": 1.1,
+            "global": 1
+          },
+          "fastMultiplier": 2
+        }
+      ]
+    },
+    "claude-fable-5-1": {
+      "context": 200000,
+      "weights": [
+        {
+          "value": 10,
+          "source": "community",
+          "at": "2026-10-01",
+          "validFrom": "2026-10-01",
+          "note": "also has its own weekly limit"
+        }
+      ],
+      "agent": "claude",
+      "tier": 4,
+      "color": 335,
+      "prices": [
+        {
+          "input": 10,
+          "cacheWrite5m": 12.5,
+          "cacheWrite1h": 20,
+          "cacheRead": 0.25,
+          "output": 50,
+          "source": "https://platform.claude.com/docs/en/about-claude/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "geoMultipliers": {
+            "us": 1.1,
+            "global": 1
+          }
+        }
+      ]
+    },
+    "gpt-6-luna": {
+      "context": 400000,
+      "weights": [
+        {
+          "value": 0.05,
+          "source": "doc",
+          "at": "2026-11-07",
+          "validFrom": "2026-11-06",
+          "note": "API price ratio to Sol ($0.10 vs $2 input); subscription weight unmeasured"
+        }
+      ],
+      "agent": "codex",
+      "tier": 1,
+      "color": 145,
+      "prices": [
+        {
+          "input": 0.1,
+          "cacheWrite5m": null,
+          "cacheWrite1h": null,
+          "cacheRead": 0.01,
+          "output": 0.5,
+          "source": "https://developers.openai.com/api/docs/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "long": {
+            "above": 272000,
+            "input": 0.2,
+            "cacheWrite5m": null,
+            "cacheWrite1h": null,
+            "cacheRead": 0.02,
+            "output": 0.75
+          }
+        }
+      ]
+    },
+    "gpt-6.1-sol": {
+      "context": 400000,
+      "weights": [
+        {
+          "value": 1,
+          "source": "measured",
+          "at": "2026-11-06",
+          "n": 2,
+          "validFrom": "2026-11-06",
+          "note": "reference model of the Codex weights"
+        }
+      ],
+      "agent": "codex",
+      "tier": 2,
+      "color": 75,
+      "prices": [
+        {
+          "input": 2,
+          "cacheWrite5m": null,
+          "cacheWrite1h": null,
+          "cacheRead": 0.1,
+          "output": 10,
+          "source": "https://developers.openai.com/api/docs/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "long": {
+            "above": 272000,
+            "input": 4,
+            "cacheWrite5m": null,
+            "cacheWrite1h": null,
+            "cacheRead": 0.2,
+            "output": 15
+          }
+        }
+      ]
+    },
+    "gpt-6-astra": {
+      "context": 400000,
+      "weights": [
+        {
+          "value": 5,
+          "source": "doc",
+          "at": "2026-11-07",
+          "validFrom": "2026-11-06",
+          "note": "API price ratio to Sol ($10 vs $2 input); subscription weight unmeasured"
+        }
+      ],
+      "agent": "codex",
+      "tier": 3,
+      "color": 280,
+      "prices": [
+        {
+          "input": 10,
+          "cacheWrite5m": null,
+          "cacheWrite1h": null,
+          "cacheRead": 1,
+          "output": 50,
+          "source": "https://developers.openai.com/api/docs/pricing",
+          "at": "2026-11-10",
+          "validFrom": "2026-11-10",
+          "long": {
+            "above": 272000,
+            "input": 20,
+            "cacheWrite5m": null,
+            "cacheWrite1h": null,
+            "cacheRead": 2,
+            "output": 75
+          }
+        }
+      ]
+    }
+  },
+  "tokenTypes": [
+    "input",
+    "cacheWrite",
+    "cacheRead",
+    "output"
+  ],
+  "agents": {
+    "claude": {
+      "plan": "pro",
+      "plans": {
+        "pro": {
+          "windows": {
+            "5h": [
+              {
+                "capacity": 15000000,
+                "source": "measured",
+                "at": "2026-11-06",
+                "n": 3,
+                "validFrom": "2026-10-01",
+                "note": "Max 20x 300M / 20; matched 3 measured points"
+              }
+            ],
+            "7d": [
+              {
+                "capacity": 85000000,
+                "source": "estimated",
+                "at": "2026-11-06",
+                "n": 1,
+                "validFrom": "2026-10-01",
+                "note": "7d +3% while 5h used ~17%; range 64M-128M"
+              }
+            ]
+          }
+        }
+      },
+      "tokenWeights": [
+        {
+          "input": 1,
+          "cacheWrite": 1.25,
+          "cacheRead": 0.025,
+          "output": 5,
+          "source": "community",
+          "at": "2026-10-01",
+          "validFrom": "2026-10-01",
+          "note": "zenn.dev/tksfjt1024; output includes thinking"
+        }
+      ],
+      "quotaSources": [
+        "oauth-usage"
+      ],
+      "id": "claude",
+      "name": "Claude",
+      "color": 25,
+      "cacheWrite": true,
+      "modelPrefix": "claude-",
+      "windows": [
+        {
+          "id": "5h",
+          "label": "5h",
+          "durationMs": 18000000,
+          "field": "five_hour"
+        },
+        {
+          "id": "7d",
+          "label": "7d",
+          "durationMs": 604800000,
+          "field": "seven_day"
+        }
+      ],
+      "originators": [
+        "Claude Code"
+      ],
+      "pluginData": {
+        "homeEnv": "CLAUDE_CONFIG_DIR",
+        "home": ".claude",
+        "relative": "plugins/data"
+      },
+      "efforts": [
+        {
+          "id": "low",
+          "color": 215
+        },
+        {
+          "id": "medium",
+          "color": 170
+        },
+        {
+          "id": "high",
+          "color": 55
+        },
+        {
+          "id": "xhigh",
+          "color": 30
+        },
+        {
+          "id": "max",
+          "color": 0
+        }
+      ]
+    },
+    "codex": {
+      "plan": "plus",
+      "plans": {
+        "plus": {
+          "windows": {
+            "5h": [
+              {
+                "capacity": 12800000,
+                "source": "measured",
+                "at": "2026-11-06",
+                "n": 2,
+                "validFrom": "2026-11-06",
+                "note": "1% ~ 8k Sol output; rollout regression suggests ~8.1M, unresolved"
+              },
+              {
+                "capacity": 3700000,
+                "source": "measured",
+                "at": "2026-11-07",
+                "n": 735,
+                "validFrom": "2026-11-06T18:00:00Z",
+                "note": "calibrate codex 2026-11-07: 735 points, 9 windows, R2 0.989; mixed models/efforts, possible off-machine use"
+              }
+            ],
+            "7d": [
+              {
+                "capacity": 100000000,
+                "source": "estimated",
+                "at": "2026-11-06",
+                "n": 1,
+                "validFrom": "2026-11-06",
+                "note": "7d +1% while 5h +8%; weak"
+              },
+              {
+                "capacity": 28900000,
+                "source": "estimated",
+                "at": "2026-11-07",
+                "validFrom": "2026-11-06T18:00:00Z",
+                "note": "same 7d/5h ratio as before (~7.8) on the new 5h capacity"
+              }
+            ]
+          }
+        }
+      },
+      "tokenWeights": [
+        {
+          "input": 1,
+          "cacheWrite": 0,
+          "cacheRead": 0.11,
+          "output": 16,
+          "source": "measured",
+          "at": "2026-11-06",
+          "n": 163,
+          "validFrom": "2026-11-06",
+          "note": "regression on one 5h window; output includes reasoning"
+        },
+        {
+          "input": 1,
+          "cacheWrite": 0,
+          "cacheRead": 0.047,
+          "output": 4.67,
+          "source": "measured",
+          "at": "2026-11-07",
+          "n": 735,
+          "validFrom": "2026-11-06T18:00:00Z",
+          "note": "calibrate codex 2026-11-07: 735 points, 9 windows, R2 0.989; mixed models/efforts, possible off-machine use"
+        }
+      ],
+      "quotaSources": [
+        "rollout"
+      ],
+      "id": "codex",
+      "name": "Codex",
+      "color": 200,
+      "cacheWrite": false,
+      "modelPrefix": "",
+      "windows": [
+        {
+          "id": "5h",
+          "label": "5h",
+          "durationMs": 18000000,
+          "minutes": 300
+        },
+        {
+          "id": "7d",
+          "label": "7d",
+          "durationMs": 604800000,
+          "minutes": 10080
+        }
+      ],
+      "pluginOrigins": [
+        "Claude Code"
+      ],
+      "efforts": [
+        {
+          "id": "low",
+          "color": 215
+        },
+        {
+          "id": "medium",
+          "color": 170
+        },
+        {
+          "id": "high",
+          "color": 55
+        },
+        {
+          "id": "xhigh",
+          "color": 30
+        },
+        {
+          "id": "max",
+          "color": 0
+        },
+        {
+          "id": "ultra",
+          "color": 0
+        }
+      ]
+    }
+  },
+  "priceSchema": {
+    "fields": [
+      "input",
+      "cacheWrite5m",
+      "cacheWrite1h",
+      "cacheRead",
+      "output"
+    ],
+    "long": {
+      "above": "token count",
+      "fields": [
+        "input",
+        "cacheWrite5m",
+        "cacheWrite1h",
+        "cacheRead",
+        "output"
+      ]
+    },
+    "metadata": [
+      "source",
+      "at",
+      "validFrom"
+    ],
+    "nullable": [
+      "cacheWrite5m",
+      "cacheWrite1h"
+    ],
+    "fastMultiplier": "positive number; multiplies all token prices",
+    "geoMultipliers": "inference_geo -> positive multiplier; unknown values use 1",
+    "longPrompt": "input + cacheRead + cacheWrite per request"
+  }
+}

package/agentmoni/lib/collect.js

@@ -0,0 +1,11 @@
+// One refresh: registered agents -> state -> links. External evidence is injectable.
+const agents = require('./agents/index.js');
+const { listProcesses } = require('./procs.js');
+const { resolveStates, createTracker } = require('./state.js');
+const { link } = require('./links.js');
+function collect({ registry = agents, since = 0, now = Date.now(), tracker = createTracker(), procs = listProcesses(registry),
+  pidFiles = registry.flatMap(a => a.readPidFiles?.() ?? []),
+  sessions = registry.flatMap(a => a.readSessions({ since })), pluginJobs = registry.flatMap(a => a.readJobs?.() ?? []) } = {}) {
+  return link(resolveStates({ sessions, procs, pidFiles, now, tracker, registry }), { procs, pluginJobs, registry });
+}
+module.exports = { collect };

package/agentmoni/lib/colors.js

@@ -0,0 +1,35 @@
+// One colour source for the terminal (truecolor) and the web (rgb). Colours are hues put through a per-theme
+// saturation/lightness, so text stays readable on light, dark and terminal backgrounds. Unknown value = grey.
+(function (root) {
+  const agents = typeof module === 'object' && module.exports ? require('./agents/index.js') : root.AgentRegistry;
+  const NAMES = Object.fromEntries(agents.map(a => [a.id, a.name]));
+  const short = m => { const text = String(m ?? ''); return agents.reduce((v, a) => a.modelPrefix && v.startsWith(a.modelPrefix) ? v.slice(a.modelPrefix.length) : v, text).replace(/-\d{8}$/, ''); };
+  const LOOK = { light: [0.72, 0.36], dark: [0.8, 0.68] };             // [saturation, lightness]
+  // I / CR / CW / O legend: [light, dark] as rgb; page.html sets its CSS variables from here.
+  const PART = { i: [[59, 120, 196], [91, 155, 234]], cr: [[63, 155, 91], [85, 194, 123]], cw: [[217, 163, 26], [242, 199, 68]], o: [[212, 80, 78], [240, 113, 111]] };
+  const GREY = { light: [102, 112, 133], dark: [152, 162, 179] };
+
+  const idOf = m => String(m ?? '').replace(/-\d{8}$/, '').replace(/\[.*\]$/, '');
+  const modelOf = model => agents.flatMap(a => a.models ?? []).find(m => m.id === idOf(model));
+  const tierOf = model => modelOf(model)?.tier ?? null;
+  const hueOf = (kind, key, provider) => kind === 'provider' ? agents.find(a => a.id === key)?.hue
+    : kind === 'effort' ? agents.find(a => a.id === provider)?.efforts?.find(e => e.id === String(key ?? '').toLowerCase())?.color
+    : modelOf(key)?.color;
+
+  // kind: 'provider' | 'model' | 'effort' -> [r, g, b] 0..255
+  function rgb(kind, key, theme = 'dark', provider) {
+    const hue = hueOf(kind, key, provider);
+    if (hue == null) return GREY[theme];
+    const [s, l] = LOOK[theme], a = s * Math.min(l, 1 - l);
+    const f = n => { const k = (n + hue / 30) % 12; return Math.round(255 * (l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1)))); };
+    return [f(0), f(8), f(4)];
+  }
+  const css = (kind, key, theme = 'dark', provider) => `rgb(${rgb(kind, key, theme, provider).join(',')})`;
+  const ansi = (kind, key, provider) => `38;2;${rgb(kind, key, 'dark', provider).join(';')}`;
+  const cssPart = (p, theme = 'dark') => `rgb(${PART[p][theme === 'dark' ? 1 : 0].join(',')})`;
+  const partAnsi = p => `38;2;${PART[p][1].join(';')}`;
+
+  const api = { NAMES, short, rgb, css, ansi, tierOf, partAnsi, cssPart, PART };
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else root.Colors = api;
+})(typeof globalThis === 'object' ? globalThis : this);

package/agentmoni/lib/cost.js

@@ -0,0 +1,87 @@
+// One quota formula for every provider: only the numbers in catalog.json differ.
+// % of a window = model weight x sum(token weight x tokens) / window capacity of the plan.
+const { pick, modelWeight, windowIds } = require('./catalog.js');
+
+const unknown = (windows, assumedWeight, weightSource) => ({ units: null, percent: Object.fromEntries(windows.map(w => [w, null])), parts: null, assumedWeight, weightSource });
+
+// percent[w] is the total; parts[w][type] is each token type's share of it (null where the count is unknown).
+function cost(catalog, modelId, tokens, at = Date.now()) {
+  const model = own(catalog.models, modelId);
+  if (!model) throw new Error(`Unknown model: ${modelId}`);
+  const provider = catalog.agents[model.agent];
+  const WINDOWS = windowIds(catalog, model.agent), TOKEN_TYPES = catalog.tokenTypes;
+  const weight = modelWeight(catalog, modelId, at);
+  if (weight.value == null || !provider.tokenWeights) return unknown(WINDOWS, true, weight.source);
+  const weights = pick(provider.tokenWeights, at);
+  // A missing count (null) only blocks the result when that token type costs something.
+  if (TOKEN_TYPES.some(t => tokens[t] == null && weights[t] !== 0)) return unknown(WINDOWS, weight.assumed, weight.source);
+  const units = Object.fromEntries(TOKEN_TYPES.map(t => [t, tokens[t] == null ? null : weight.value * tokens[t] * weights[t]]));
+  const u = TOKEN_TYPES.reduce((sum, t) => sum + (units[t] ?? 0), 0);
+  const percent = {}, parts = {};
+  for (const w of WINDOWS) {
+    const capacity = pick(provider.plans[provider.plan].windows[w], at).capacity;
+    percent[w] = u / capacity * 100;
+    parts[w] = Object.fromEntries(TOKEN_TYPES.map(t => [t, units[t] == null ? null : units[t] / capacity * 100]));
+  }
+  return { units: u, percent, parts, assumedWeight: weight.assumed, weightSource: weight.source };
+}
+
+module.exports = { cost };
+// Pure, provider-independent pricing. All amounts are USD; rates are per million tokens.
+const valid = n => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+const own = (object, key) => object != null && typeof key === 'string' && Object.hasOwn(object, key) ? object[key] : undefined;
+function price(record, catalog) {
+  const unknown = { costUSD: null, source: 'unknown', uncertain: false };
+  if (record?.costUSD != null) return valid(record.costUSD) ? { costUSD: record.costUSD, source: 'log', uncertain: false } : unknown;
+  const at = typeof record?.at === 'number' ? record.at : Date.parse(record?.at);
+  if (!Number.isFinite(at)) return unknown;
+  // shortcut: oldest price applies backwards, add older entries when a price change is known
+  const p = pick(own(catalog?.models, record?.model)?.prices ?? [], at);
+  if (!p || !record.tokens) return unknown;
+  const t = record.tokens;
+  const oneHour = t.cacheWrite1h ?? 0;
+  const write = t.cacheWrite ?? ((t.cacheWrite5m ?? 0) + oneHour);
+  const counts = { input: t.input ?? 0, cacheRead: t.cacheRead ?? 0,
+    cacheWrite5m: t.cacheWrite5m ?? write - oneHour, cacheWrite1h: oneHour, output: t.output ?? 0 };
+  if (Object.values(counts).some(n => !valid(n))) return unknown;
+  const long = !!p.long && counts.input + counts.cacheRead + write > p.long.above;
+  const rates = long ? p.long : p;
+  let amount = 0;
+  for (const [k, n] of Object.entries(counts)) {
+    if (n && !valid(rates[k])) return unknown;
+    amount += n * (rates[k] ?? 0) / 1e6;
+  }
+  const fast = record.speed === 'fast';
+  const geo = own(p.geoMultipliers, record.inference_geo);
+  amount *= (fast && valid(p.fastMultiplier) ? p.fastMultiplier : 1) * (valid(geo) ? geo : 1);
+  if (!valid(amount)) return unknown;
+  return { costUSD: amount, source: 'estimate', uncertain: fast && !p.fastMultiplier,
+    priceSource: p.source, validFrom: p.validFrom, long };
+}
+function summarize(records, catalog) {
+  let knownUSD = 0, knownRecords = 0, unknownRecords = 0, uncertainRecords = 0;
+  const unknownModels = new Set(), sources = new Set();
+  for (const r of records) {
+    const p = price(r, catalog);
+    sources.add(p.source);
+    if (!valid(p.costUSD) || !valid(knownUSD + p.costUSD)) { unknownRecords++; unknownModels.add(r?.model ?? 'unknown'); }
+    else { knownUSD += p.costUSD; knownRecords++; }
+    if (p.uncertain) uncertainRecords++;
+  }
+  return { costUSD: unknownRecords && !knownRecords ? null : knownUSD, knownUSD, knownRecords,
+    unknownRecords, unknownModels: [...unknownModels].sort(), uncertainRecords, sources: [...sources].sort() };
+}
+function byDay(records, catalog) {
+  const groups = new Map();
+  for (const r of records) {
+    const d = new Date(r.at);
+    const day = Number.isFinite(d.getTime()) ? `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}` : 'unknown';
+    if (!groups.has(day)) groups.set(day, []);
+    groups.get(day).push(r);
+  }
+  return Object.fromEntries([...groups].sort(([a], [b]) => a.localeCompare(b)).map(([day, rs]) => [day, summarize(rs, catalog)]));
+}
+// Older stores without per-request usage cannot safely use aggregate tokens for long pricing.
+const recordsOf = s => Array.isArray(s.usage) && s.usage.length ? s.usage : [{ at: s.startedAt, model: s.model }];
+const billingView = billing => ({ billing: billing ?? 'unknown', showQuota: billing !== 'api', costKind: billing === 'api' ? 'api' : 'api-equivalent' });
+module.exports = { cost, price, summarize, byDay, recordsOf, billingView };

package/agentmoni/lib/format.js

@@ -0,0 +1,18 @@
+// Number and time formats shared by the terminal and the web (step 7).
+// Percent: always a leading zero and one decimal; >0 but <0.1 is "<0.1"; unknown is "—".
+const pct = n => n == null || !Number.isFinite(n) ? '—' : n > 0 && n < 0.1 ? '<0.1' : n.toFixed(1);
+// Tokens: 1.24M, 38.2k, 512; unknown is "—".
+// The unit switches after rounding: 999960 is 1.00M, not 1000.0k.
+const tok = n => n == null || !Number.isFinite(n) ? '—' : n >= 1e6 || (n >= 1e3 && (n / 1e3).toFixed(1) === '1000.0') ? (n / 1e6).toFixed(2) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'k' : String(Math.round(n));
+// Context size: whole thousands (96k/200k).
+const ctx = n => n == null ? '—' : n >= 1e6 || Math.round(n / 1e3) >= 1000 ? (n / 1e6).toFixed(1).replace(/\.0$/, '') + 'M' : n >= 1e3 ? Math.round(n / 1e3) + 'k' : String(n);
+// Duration: 48m, 2h14m, 3d.
+function dur(ms) {
+  const m = Math.max(0, Math.round(ms / 60000));
+  return m >= 1440 ? `${Math.floor(m / 1440)}d` : m >= 60 ? `${Math.floor(m / 60)}h${String(m % 60).padStart(2, '0')}m` : `${m}m`;
+}
+const hhmm = ms => { const d = new Date(ms); return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`; };
+// "outside monitor" value: +1.2, <0.1, —
+const rise = n => n == null ? '—' : n > 0 && n < 0.1 ? '<0.1' : (n > 0 ? '+' : '') + n.toFixed(1);
+
+module.exports = { pct, tok, ctx, dur, hhmm, rise };