@mbeato/contextscope 0.1.3 → 0.1.4

package/.next/standalone/lib/model-prices.json

@@ -0,0 +1,147 @@
+{
+  "_source": "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json",
+  "_refreshedAt": "2026-05-27T17:24:45.345Z",
+  "_description": "Anthropic model prices in USD per token (input, output, cache_read, cache_creation 5min default). Refresh with `npm run refresh-prices`.",
+  "models": {
+    "claude-3-7-sonnet-20250219": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.000006
+    },
+    "claude-3-haiku-20240307": {
+      "input": 2.5e-7,
+      "output": 0.00000125,
+      "cache_read": 3e-8,
+      "cache_creation_5m": 3e-7,
+      "cache_creation_1h": 0.000006
+    },
+    "claude-3-opus-20240229": {
+      "input": 0.000015,
+      "output": 0.000075,
+      "cache_read": 0.0000015,
+      "cache_creation_5m": 0.00001875,
+      "cache_creation_1h": 0.000006
+    },
+    "claude-4-opus-20250514": {
+      "input": 0.000015,
+      "output": 0.000075,
+      "cache_read": 0.0000015,
+      "cache_creation_5m": 0.00001875,
+      "cache_creation_1h": 0.0000375
+    },
+    "claude-4-sonnet-20250514": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.0000075
+    },
+    "claude-haiku-4-5": {
+      "input": 0.000001,
+      "output": 0.000005,
+      "cache_read": 1e-7,
+      "cache_creation_5m": 0.00000125,
+      "cache_creation_1h": 0.000002
+    },
+    "claude-haiku-4-5-20251001": {
+      "input": 0.000001,
+      "output": 0.000005,
+      "cache_read": 1e-7,
+      "cache_creation_5m": 0.00000125,
+      "cache_creation_1h": 0.000002
+    },
+    "claude-opus-4-1": {
+      "input": 0.000015,
+      "output": 0.000075,
+      "cache_read": 0.0000015,
+      "cache_creation_5m": 0.00001875,
+      "cache_creation_1h": 0.00003
+    },
+    "claude-opus-4-1-20250805": {
+      "input": 0.000015,
+      "output": 0.000075,
+      "cache_read": 0.0000015,
+      "cache_creation_5m": 0.00001875,
+      "cache_creation_1h": 0.00003
+    },
+    "claude-opus-4-20250514": {
+      "input": 0.000015,
+      "output": 0.000075,
+      "cache_read": 0.0000015,
+      "cache_creation_5m": 0.00001875,
+      "cache_creation_1h": 0.00003
+    },
+    "claude-opus-4-5": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-opus-4-5-20251101": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-opus-4-6": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-opus-4-6-20260205": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-opus-4-7": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-opus-4-7-20260416": {
+      "input": 0.000005,
+      "output": 0.000025,
+      "cache_read": 5e-7,
+      "cache_creation_5m": 0.00000625,
+      "cache_creation_1h": 0.00001
+    },
+    "claude-sonnet-4-20250514": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.000006
+    },
+    "claude-sonnet-4-5": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.0000075
+    },
+    "claude-sonnet-4-5-20250929": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.0000075
+    },
+    "claude-sonnet-4-6": {
+      "input": 0.000003,
+      "output": 0.000015,
+      "cache_read": 3e-7,
+      "cache_creation_5m": 0.00000375,
+      "cache_creation_1h": 0.0000075
+    }
+  }
+}

package/.next/standalone/lib/pricing.ts

@@ -0,0 +1,80 @@
+/**
+ * Per-message API cost calculator.
+ *
+ * Prices come from lib/model-prices.json (refreshed from LiteLLM — see
+ * scripts/refresh-prices.mjs). They're Anthropic's PUBLIC API rates — the
+ * "you'd pay this on the API" number, not what CC subscribers actually pay.
+ *
+ * Cache-creation cost uses the 5-minute (default) tier. CC sometimes uses the
+ * 1-hour tier; transcripts don't tell us which, so we use the more conservative
+ * lower price (5min). Real cost may be marginally higher.
+ *
+ * Unknown models log once and return 0 — never silently fudge.
+ */
+import prices from "./model-prices.json";
+
+type ModelPrice = {
+  input: number;
+  output: number;
+  cache_read: number;
+  cache_creation_5m: number;
+  cache_creation_1h: number;
+};
+
+const MODELS = prices.models as Record<string, ModelPrice>;
+
+// Aliases for short model names that appear in some CC transcripts.
+// Map each to the latest released model of that tier.
+const ALIASES: Record<string, string> = {
+  opus: "claude-opus-4-7",
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5",
+};
+
+const warned = new Set<string>();
+
+export type Usage = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheCreation5m: number;
+  cacheCreation1h: number;
+};
+
+function resolveModel(model: string): ModelPrice | null {
+  if (!model || model === "<synthetic>") return null;
+  if (MODELS[model]) return MODELS[model];
+  if (ALIASES[model] && MODELS[ALIASES[model]]) return MODELS[ALIASES[model]];
+  // Strip [variant] suffix (e.g. claude-opus-4-7[1m] → claude-opus-4-7)
+  const noSuffix = model.replace(/\[[^\]]+\]$/, "");
+  if (noSuffix !== model && MODELS[noSuffix]) return MODELS[noSuffix];
+  // Strip date suffix (-YYYYMMDD) and retry
+  const noDate = noSuffix.replace(/-\d{8}$/, "");
+  if (MODELS[noDate]) return MODELS[noDate];
+  if (!warned.has(model)) {
+    warned.add(model);
+    console.warn(`[contextscope] no price found for model "${model}" — treating as $0. Add to lib/model-prices.json or alias.`);
+  }
+  return null;
+}
+
+export function costForUsage(model: string, u: Usage): number {
+  const p = resolveModel(model);
+  if (!p) return 0;
+  return (
+    u.input * p.input +
+    u.output * p.output +
+    u.cacheRead * p.cache_read +
+    u.cacheCreation5m * p.cache_creation_5m +
+    u.cacheCreation1h * p.cache_creation_1h
+  );
+}
+
+export function formatUsd(n: number): string {
+  if (n >= 100) return `$${n.toFixed(0)}`;
+  if (n >= 10) return `$${n.toFixed(1)}`;
+  if (n >= 1) return `$${n.toFixed(2)}`;
+  if (n >= 0.01) return `$${n.toFixed(2)}`;
+  if (n > 0) return `<$0.01`;
+  return `$0`;
+}

package/.next/standalone/lib/sessions.ts

@@ -1,4 +1,5 @@
 import { getAllTranscripts, type TranscriptResult } from "./transcripts";
+import { costForUsage } from "./pricing";
 
 export type Session = {
   sessionId: string;
@@ -14,11 +15,26 @@ export type Session = {
   cacheCreationTokens: number;
   outputTokens: number;
   totalTokens: number;
+  costUsd: number;
   toolCalls: Record<string, number>;
   toolErrors: number;
   sidechainTurns: number;
 };
 
+function computeCost(t: TranscriptResult): number {
+  let cost = 0;
+  for (const [model, u] of Object.entries(t.byModel)) {
+    cost += costForUsage(model, {
+      input: u.inputTokens,
+      output: u.outputTokens,
+      cacheRead: u.cacheReadTokens,
+      cacheCreation5m: u.cacheCreation5mTokens,
+      cacheCreation1h: u.cacheCreation1hTokens,
+    });
+  }
+  return cost;
+}
+
 function toSession(t: TranscriptResult): Session {
   const totalTokens =
     t.inputTokens + t.cacheReadTokens + t.cacheCreationTokens + t.outputTokens;
@@ -36,6 +52,7 @@ function toSession(t: TranscriptResult): Session {
     cacheCreationTokens: t.cacheCreationTokens,
     outputTokens: t.outputTokens,
     totalTokens,
+    costUsd: computeCost(t),
     toolCalls: t.toolCalls,
     toolErrors: t.toolErrors,
     sidechainTurns: t.sidechainTurns,
@@ -55,14 +72,15 @@ export type SessionsSummary = {
   totalTokens: number;
   totalOutputTokens: number;
   totalInputPlusCache: number;
+  totalCostUsd: number;
   cacheHitRatio: number;
   outputInputRatio: number;
   averageSessionTokens: number;
   medianSessionTokens: number;
   p95SessionTokens: number;
   longSessions: Session[];
-  dailyBurn: { date: string; tokens: number }[];
-  byProject: { project: string; projectPath: string; count: number; tokens: number; turns: number }[];
+  dailyBurn: { date: string; tokens: number; cost: number }[];
+  byProject: { project: string; projectPath: string; count: number; tokens: number; cost: number; turns: number }[];
   totalToolCalls: Record<string, number>;
   totalToolErrors: number;
   totalSidechainTurns: number;
@@ -78,6 +96,7 @@ export function summarizeSessions(sessions: Session[]): SessionsSummary {
       totalTokens: 0,
       totalOutputTokens: 0,
       totalInputPlusCache: 0,
+      totalCostUsd: 0,
       cacheHitRatio: 0,
       outputInputRatio: 0,
       averageSessionTokens: 0,
@@ -110,7 +129,7 @@ export function summarizeSessions(sessions: Session[]): SessionsSummary {
 
   const longSessions = sessions.filter((s) => s.totalTokens >= LONG_SESSION_THRESHOLD);
 
-  const byDay = new Map<string, number>();
+  const byDay = new Map<string, { tokens: number; cost: number }>();
   for (const s of sessions) {
     const ts = s.endTime || s.startTime;
     if (!ts) continue;
@@ -118,27 +137,34 @@ export function summarizeSessions(sessions: Session[]): SessionsSummary {
     const key = `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(
       d.getUTCDate()
     ).padStart(2, "0")}`;
-    byDay.set(key, (byDay.get(key) ?? 0) + s.totalTokens);
+    const cur = byDay.get(key) ?? { tokens: 0, cost: 0 };
+    cur.tokens += s.totalTokens;
+    cur.cost += s.costUsd;
+    byDay.set(key, cur);
   }
   const dailyBurn = [...byDay.entries()]
-    .map(([date, tokens]) => ({ date, tokens }))
+    .map(([date, v]) => ({ date, tokens: v.tokens, cost: v.cost }))
     .sort((a, b) => a.date.localeCompare(b.date));
 
   // By project
   const projectMap = new Map<
     string,
-    { project: string; projectPath: string; count: number; tokens: number; turns: number }
+    { project: string; projectPath: string; count: number; tokens: number; cost: number; turns: number }
   >();
+  let totalCostUsd = 0;
   for (const s of sessions) {
+    totalCostUsd += s.costUsd;
     const cur = projectMap.get(s.project) ?? {
       project: s.project,
       projectPath: s.projectPath,
       count: 0,
       tokens: 0,
+      cost: 0,
       turns: 0,
     };
     cur.count += 1;
     cur.tokens += s.totalTokens;
+    cur.cost += s.costUsd;
     cur.turns += s.turnCount;
     projectMap.set(s.project, cur);
   }
@@ -163,6 +189,7 @@ export function summarizeSessions(sessions: Session[]): SessionsSummary {
     totalTokens: total,
     totalOutputTokens: outSum,
     totalInputPlusCache: inputPlusCache,
+    totalCostUsd,
     cacheHitRatio,
     outputInputRatio,
     averageSessionTokens: Math.round(total / sessions.length),

package/.next/standalone/lib/transcripts.ts

@@ -6,7 +6,10 @@
  *   - invocations (Skill / Agent tool_use events)  -> consumed by lib/usage.ts
  *   - session stats (turn count, token usage)      -> consumed by lib/sessions.ts
  *
- * Subsequent page loads reuse cached results when mtime is unchanged.
+ * CC creates a new JSONL when you `--continue` a session, which replays the
+ * prior turns. To match ccusage's totals we dedup messages by `msg.id:requestId`
+ * across all files at aggregate time. Per-file records are cached unchanged
+ * (preserves mtime cache); dedupAndSum runs on every getAllTranscripts call.
  */
 import { readdir, stat } from "node:fs/promises";
 import { createReadStream } from "node:fs";
@@ -18,6 +21,28 @@ const PROJECTS_DIR = join(homedir(), ".claude", "projects");
 
 export type Invocation = { kind: "skill" | "agent"; name: string; ts: number };
 
+export type ModelUsage = {
+  inputTokens: number;
+  cacheReadTokens: number;
+  cacheCreation5mTokens: number;
+  cacheCreation1hTokens: number;
+  outputTokens: number;
+};
+
+export type UsageRecord = {
+  // `${message.id}:${requestId}` — same key ccusage uses. Empty string if msg
+  // lacked an id (treat as un-dedupable; count it).
+  dedupKey: string;
+  model: string;
+  ts: number;
+  input: number;
+  cacheRead: number;
+  cacheCreation5m: number;
+  cacheCreation1h: number;
+  output: number;
+  isSidechain: boolean;
+};
+
 export type TranscriptResult = {
   filePath: string;
   mtimeMs: number;
@@ -28,20 +53,22 @@ export type TranscriptResult = {
   endTime: number;
   turnCount: number;
   models: string[];
+  // Aggregate totals — sums after dedup (when produced via getAllTranscripts).
+  // On raw parseFile output these are pre-dedup; getAllTranscripts rebuilds them.
   inputTokens: number;
   cacheReadTokens: number;
-  cacheCreationTokens: number;
+  cacheCreationTokens: number;   // total: 5m + 1h
   outputTokens: number;
+  byModel: Record<string, ModelUsage>;
+  // Per-message records — kept on the cached result so dedup at aggregate time
+  // is exact across resumed sessions.
+  usageRecords: UsageRecord[];
   invocations: Invocation[];
-  toolCalls: Record<string, number>;  // tool name -> count
-  toolErrors: number;                  // total tool_result with is_error: true
-  sidechainTurns: number;              // turns with isSidechain: true (subagent context)
+  toolCalls: Record<string, number>;
+  toolErrors: number;
+  sidechainTurns: number;
 };
 
-// Module-level cache: persists across server-component renders within the same
-// Next.js dev/prod process. Keyed by filePath; invalidated on mtime change.
-// Capped via simple FIFO eviction (Map preserves insertion order) so a
-// long-running process scanning thousands of transcripts can't grow unbounded.
 const cache = new Map<string, TranscriptResult>();
 const MAX_CACHE_ENTRIES = 5000;
 
@@ -67,12 +94,13 @@ async function parseFile(filePath: string, mtimeMs: number): Promise<TranscriptR
     cacheReadTokens: 0,
     cacheCreationTokens: 0,
     outputTokens: 0,
+    byModel: {},
+    usageRecords: [],
     invocations: [],
     toolCalls: {},
     toolErrors: 0,
     sidechainTurns: 0,
   };
-  const modelSet = new Set<string>();
 
   return new Promise((resolve) => {
     const rl = createInterface({
@@ -81,7 +109,6 @@ async function parseFile(filePath: string, mtimeMs: number): Promise<TranscriptR
     });
     rl.on("line", (line) => {
       if (!line || line[0] !== "{") return;
-      // Prefilter: usage events, tool_use events, and tool_result events (for errors).
       const hasUsage = line.includes('"usage"');
       const hasToolUse = line.includes('"tool_use"');
       const hasToolResult = line.includes('"tool_result"');
@@ -94,29 +121,49 @@ async function parseFile(filePath: string, mtimeMs: number): Promise<TranscriptR
         return;
       }
       const msg = rec.message as
-        | { model?: string; usage?: Record<string, unknown>; content?: unknown }
+        | { id?: string; model?: string; usage?: Record<string, unknown>; content?: unknown }
         | undefined;
       const tsRaw = rec.timestamp;
       const tsMs = typeof tsRaw === "string" ? Date.parse(tsRaw) : NaN;
       const isSidechain = rec.isSidechain === true;
 
-      // Usage aggregation (assistant messages)
       const usage = msg?.usage;
       if (usage) {
-        result.inputTokens += Number(usage.input_tokens) || 0;
-        result.cacheReadTokens += Number(usage.cache_read_input_tokens) || 0;
-        result.cacheCreationTokens += Number(usage.cache_creation_input_tokens) || 0;
-        result.outputTokens += Number(usage.output_tokens) || 0;
-        result.turnCount += 1;
-        if (isSidechain) result.sidechainTurns += 1;
-        if (msg?.model) modelSet.add(msg.model);
-        if (Number.isFinite(tsMs)) {
-          if (!result.startTime || tsMs < result.startTime) result.startTime = tsMs;
-          if (tsMs > result.endTime) result.endTime = tsMs;
+        const msgId = typeof msg?.id === "string" ? msg.id : "";
+        const requestId = typeof rec.requestId === "string" ? rec.requestId : "";
+        const dedupKey = msgId ? `${msgId}:${requestId}` : "";
+        // cache_creation may have an ephemeral_{5m,1h}_input_tokens breakdown
+        // (priced separately at $6.25/M vs $10/M for opus-4-7). Older transcripts
+        // lack the sub-object — fall back to treating the total as 5min.
+        const ccTotal = Number(usage.cache_creation_input_tokens) || 0;
+        const ccBreakdown = (usage.cache_creation ?? null) as
+          | { ephemeral_5m_input_tokens?: number; ephemeral_1h_input_tokens?: number }
+          | null;
+        let cc5m = 0;
+        let cc1h = 0;
+        if (ccBreakdown && typeof ccBreakdown === "object") {
+          cc5m = Number(ccBreakdown.ephemeral_5m_input_tokens) || 0;
+          cc1h = Number(ccBreakdown.ephemeral_1h_input_tokens) || 0;
+          // If breakdown is present but sum doesn't match the parent total,
+          // trust the parent and attribute the diff to 5min (conservative).
+          const diff = ccTotal - (cc5m + cc1h);
+          if (diff > 0) cc5m += diff;
+        } else {
+          cc5m = ccTotal;
         }
+        result.usageRecords.push({
+          dedupKey,
+          model: msg?.model || "<synthetic>",
+          ts: Number.isFinite(tsMs) ? tsMs : 0,
+          input: Number(usage.input_tokens) || 0,
+          cacheRead: Number(usage.cache_read_input_tokens) || 0,
+          cacheCreation5m: cc5m,
+          cacheCreation1h: cc1h,
+          output: Number(usage.output_tokens) || 0,
+          isSidechain,
+        });
       }
 
-      // Content scan: tool_use (counts + invocations) and tool_result (errors)
       if (Array.isArray(msg?.content)) {
         for (const c of msg.content) {
           if (!c || typeof c !== "object") continue;
@@ -146,14 +193,8 @@ async function parseFile(filePath: string, mtimeMs: number): Promise<TranscriptR
         }
       }
     });
-    rl.on("close", () => {
-      result.models = [...modelSet];
-      resolve(result);
-    });
-    rl.on("error", () => {
-      result.models = [...modelSet];
-      resolve(result);
-    });
+    rl.on("close", () => resolve(result));
+    rl.on("error", () => resolve(result));
   });
 }
 
@@ -161,7 +202,7 @@ async function getFileResult(filePath: string, mtimeMs: number): Promise<Transcr
   const cached = cache.get(filePath);
   if (cached && cached.mtimeMs === mtimeMs) return cached;
   const fresh = await parseFile(filePath, mtimeMs);
-  if (cached) cache.delete(filePath); // re-insert at tail so FIFO eviction stays correct
+  if (cached) cache.delete(filePath);
   cache.set(filePath, fresh);
   while (cache.size > MAX_CACHE_ENTRIES) {
     const oldest = cache.keys().next().value;
@@ -185,7 +226,67 @@ async function pMapLimit<T, R>(items: T[], limit: number, fn: (x: T) => Promise<
   return out;
 }
 
-/** Scan all transcripts modified in the last N days. Cached per (filePath, mtime). */
+/**
+ * Walk raw per-file results oldest first; attribute each unique message UUID
+ * to the earliest file that mentions it. Returns new TranscriptResult objects
+ * with totals/byModel/timestamps recomputed from the surviving records.
+ *
+ * Important: do NOT mutate the cached `raws` objects — clone fields we rewrite.
+ */
+function dedupAndSum(raws: TranscriptResult[]): TranscriptResult[] {
+  const sorted = [...raws].sort((a, b) => a.mtimeMs - b.mtimeMs);
+  const seen = new Set<string>();
+  return sorted.map((r) => {
+    const t: TranscriptResult = {
+      ...r,
+      startTime: 0,
+      endTime: 0,
+      turnCount: 0,
+      inputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      outputTokens: 0,
+      byModel: {},
+      models: [],
+      sidechainTurns: 0,
+    };
+    const modelSet = new Set<string>();
+    for (const u of r.usageRecords) {
+      if (u.dedupKey) {
+        if (seen.has(u.dedupKey)) continue;
+        seen.add(u.dedupKey);
+      }
+      t.inputTokens += u.input;
+      t.cacheReadTokens += u.cacheRead;
+      t.cacheCreationTokens += u.cacheCreation5m + u.cacheCreation1h;
+      t.outputTokens += u.output;
+      t.turnCount += 1;
+      if (u.isSidechain) t.sidechainTurns += 1;
+      modelSet.add(u.model);
+      const bm = t.byModel[u.model] ?? {
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreation5mTokens: 0,
+        cacheCreation1hTokens: 0,
+        outputTokens: 0,
+      };
+      bm.inputTokens += u.input;
+      bm.cacheReadTokens += u.cacheRead;
+      bm.cacheCreation5mTokens += u.cacheCreation5m;
+      bm.cacheCreation1hTokens += u.cacheCreation1h;
+      bm.outputTokens += u.output;
+      t.byModel[u.model] = bm;
+      if (u.ts > 0) {
+        if (!t.startTime || u.ts < t.startTime) t.startTime = u.ts;
+        if (u.ts > t.endTime) t.endTime = u.ts;
+      }
+    }
+    t.models = [...modelSet];
+    return t;
+  });
+}
+
+/** Scan all transcripts modified in the last N days. Deduped across resumed sessions. */
 export async function getAllTranscripts(daysBack: number = 30): Promise<TranscriptResult[]> {
   const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1000;
   let projDirs: import("node:fs").Dirent[];
@@ -217,5 +318,6 @@ export async function getAllTranscripts(daysBack: number = 30): Promise<Transcri
       }
     })
   );
-  return pMapLimit(candidates, 16, (c) => getFileResult(c.filePath, c.mtimeMs));
+  const raws = await pMapLimit(candidates, 16, (c) => getFileResult(c.filePath, c.mtimeMs));
+  return dedupAndSum(raws);
 }

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mbeato/contextscope",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Local dashboard auditing Claude Code's per-turn token context (skills, agents, commands, CLAUDE.md, MEMORY.md, hooks, MCP) with toggle-based disable and session analytics.",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "start": "next start",
     "prod": "next build && next start",
     "lint": "eslint",
+    "refresh-prices": "node scripts/refresh-prices.mjs",
     "prepublishOnly": "next build",
     "release": "test -f .env.publish || (echo 'missing .env.publish — copy .env.publish.example and add your NPM_TOKEN' && exit 1) && set -a && . ./.env.publish && set +a && npm publish"
   },

package/.next/standalone/scripts/refresh-prices.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Refresh lib/model-prices.json from LiteLLM's authoritative price list.
+ *
+ * Pulls https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json,
+ * keeps only Anthropic models with the cost fields we use, and writes a pruned
+ * JSON to lib/model-prices.json. Run before each contextscope release so npm
+ * users get current prices.
+ *
+ * Usage: node scripts/refresh-prices.mjs
+ */
+import { writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const SRC = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DST = join(HERE, "..", "lib", "model-prices.json");
+
+const res = await fetch(SRC);
+if (!res.ok) {
+  console.error(`fetch failed: ${res.status} ${res.statusText}`);
+  process.exit(1);
+}
+const all = await res.json();
+
+const pruned = {};
+for (const [name, m] of Object.entries(all)) {
+  if (m?.litellm_provider !== "anthropic") continue;
+  if (typeof m.input_cost_per_token !== "number") continue;
+  const cc5m = m.cache_creation_input_token_cost ?? 0;
+  pruned[name] = {
+    input: m.input_cost_per_token,
+    output: m.output_cost_per_token ?? 0,
+    cache_read: m.cache_read_input_token_cost ?? 0,
+    cache_creation_5m: cc5m,
+    // Anthropic's documented 1hr cache rate is 2x the 5min rate.
+    // Fall back to 2x when LiteLLM doesn't list it explicitly.
+    cache_creation_1h: m.cache_creation_input_token_cost_above_1hr ?? cc5m * 2,
+  };
+}
+
+const sorted = Object.fromEntries(Object.entries(pruned).sort(([a], [b]) => a.localeCompare(b)));
+await writeFile(
+  DST,
+  JSON.stringify(
+    {
+      _source: SRC,
+      _refreshedAt: new Date().toISOString(),
+      _description: "Anthropic model prices in USD per token (input, output, cache_read, cache_creation 5min default). Refresh with `npm run refresh-prices`.",
+      models: sorted,
+    },
+    null,
+    2
+  ) + "\n",
+  "utf8"
+);
+console.log(`wrote ${Object.keys(sorted).length} anthropic models → ${DST}`);