@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/segments/metrics.ts

@@ -1,187 +0,0 @@
-import type { ClaudeHookData, ParsedEntry } from "../utils/claude";
-
-// [LAW:one-source-of-truth] Metrics reads the transcript through the SAME
-// incremental append reader the usage store uses, folding only the bytes added
-// since last render into a running message count + a bounded recent-entry ring —
-// never a whole-file re-parse. Before this, metrics re-parsed the entire growing
-// transcript every render (free only while it piggybacked the store's cache hit);
-// once the store went incremental, a full re-parse here would have re-inherited
-// the very stall the store fix removed. Now both consumers are O(new bytes).
-import { readAppendedEntries, type TranscriptCursor } from "../utils/claude";
-import { statMtimeMs } from "../utils/transcript-fs";
-import { debug } from "../utils/logger";
-import { ABSENT, failed, ok, type Outcome } from "../utils/outcome";
-
-// [LAW:types-are-the-program] An `ok` MetricsInfo carries real values — "no
-// cost data at all" is the `absent` outcome arm, not a bag of nulls. The one
-// remaining null is lastResponseTime, where the domain genuinely has no
-// answer (no qualifying user→assistant pair in the recent window).
-export interface MetricsInfo {
-  responseTime: number;
-  lastResponseTime: number | null;
-  sessionDuration: number;
-  messageCount: number;
-  linesAdded: number;
-  linesRemoved: number;
-}
-
-// lastResponseTime only inspects the most recent turns for a user→assistant
-// pair; a bounded tail of non-sidechain entries is all it needs. The ring caps
-// per-session retained memory at O(1) regardless of transcript length.
-const RECENT_WINDOW = 20;
-// Bound the per-session fold map like the usage store's records — a long-lived
-// daemon sees many sessions; the ring is tiny, but the map must not grow without
-// limit. LRU by insertion order (delete+set on write), evict oldest past the cap.
-const MAX_SESSIONS = 256;
-
-// [LAW:one-source-of-truth] The incremental fold of one session's metrics: the
-// byte cursor already consumed, the running real-user message count, and the
-// recent-entry ring. Canonical; MetricsInfo's transcript-derived fields derive
-// from it, the hookData-derived fields (durations, lines) are always fresh.
-interface MetricsState {
-  cursor: TranscriptCursor;
-  messageCount: number;
-  recent: ParsedEntry[];
-}
-
-// A real user turn vs. a tool_result echoed back as a "user" line. The
-// discriminator is metrics-local policy over the shared ParsedEntry scalars.
-function isRealUserMessage(entry: ParsedEntry): boolean {
-  const messageType = entry.type || entry.message?.role || entry.message?.type;
-  const isToolResult =
-    entry.type === "user" && entry.message?.firstContentType === "tool_result";
-  return messageType === "user" && !isToolResult;
-}
-
-export class MetricsProvider {
-  // [LAW:no-shared-mutable-globals] Single owner, hard cap, LRU eviction — the
-  // per-session incremental fold state. One instance per daemon.
-  private readonly state = new Map<string, MetricsState>();
-
-  private calculateLastResponseTime(entries: ParsedEntry[]): number | null {
-    if (entries.length === 0) return null;
-
-    let lastUserTime: Date | null = null;
-    let bestResponseTime: number | null = null;
-
-    for (const entry of entries) {
-      const messageType =
-        entry.type || entry.message?.role || entry.message?.type;
-
-      if (isRealUserMessage(entry)) {
-        lastUserTime = entry.timestamp;
-      } else if (messageType === "assistant" && lastUserTime) {
-        const responseTime =
-          (entry.timestamp.getTime() - lastUserTime.getTime()) / 1000;
-        if (responseTime > 0.1 && responseTime < 300) {
-          bestResponseTime = responseTime;
-        }
-      }
-    }
-
-    return bestResponseTime;
-  }
-
-  // [LAW:dataflow-not-control-flow] Fold the appended entries onto the prior
-  // state, producing a FRESH state (prior is never mutated) so two concurrent
-  // renders of one session both fold from the same prior and last-writer-wins is
-  // a correct answer, never a double-count. `reset` (a /compact rewrite) folds
-  // from empty. Returns the transcript-derived fields the caller composes with
-  // the always-fresh hookData fields.
-  private async foldMetrics(
-    sessionId: string,
-    transcriptPath: string,
-  ): Promise<
-    // [LAW:types-are-the-program] Never `absent` — a missing transcript is a real
-    // zero-count fold (ok), so the caller has exactly two arms to handle.
-    | { kind: "ok"; value: { messageCount: number; recent: ParsedEntry[] } }
-    | { kind: "failed"; reason: string }
-  > {
-    const prior = this.state.get(sessionId);
-    const mtime = statMtimeMs(transcriptPath);
-    // [LAW:no-ambient-temporal-coupling] Fast hit: the transcript is unchanged
-    // since we last folded it, so the message count + ring stand.
-    if (prior && mtime !== 0 && prior.cursor.mtimeMs === mtime) {
-      // [LAW:no-ambient-temporal-coupling] Re-order on the hit so LRU eviction
-      // reflects READ recency, not just write recency — an active session whose
-      // transcript is momentarily unchanged must not be evicted ahead of idle
-      // ones (matches the usage store's hit path).
-      this.state.delete(sessionId);
-      this.state.set(sessionId, prior);
-      // [LAW:no-shared-mutable-globals] Return a COPY of the stored ring, never
-      // the reference — a caller mutating the returned array would silently
-      // corrupt the retained state (a heisenbug in the next render's
-      // lastResponseTime). Every path (hit/miss/absent) copies. 20 entries.
-      return {
-        kind: "ok",
-        value: { messageCount: prior.messageCount, recent: [...prior.recent] },
-      };
-    }
-
-    const read = await readAppendedEntries(transcriptPath, prior?.cursor);
-    if (read.kind === "failed") return read;
-    if (read.kind === "absent") {
-      // No transcript yet (fresh session) — keep prior if any, don't cache a
-      // cursor so the next render retries when the file appears. Copy the ring
-      // (like the hit/miss paths) so no stored reference escapes.
-      return {
-        kind: "ok",
-        value: {
-          messageCount: prior?.messageCount ?? 0,
-          recent: [...(prior?.recent ?? [])],
-        },
-      };
-    }
-
-    const { entries, cursor, reset } = read.value;
-    const base = prior && !reset ? prior : undefined;
-    let messageCount = base?.messageCount ?? 0;
-    let recent = base ? [...base.recent] : [];
-    for (const entry of entries) {
-      if (entry.isSidechain) continue;
-      if (isRealUserMessage(entry)) messageCount++;
-      recent.push(entry);
-    }
-    if (recent.length > RECENT_WINDOW) recent = recent.slice(-RECENT_WINDOW);
-
-    this.state.delete(sessionId);
-    this.state.set(sessionId, { cursor, messageCount, recent });
-    while (this.state.size > MAX_SESSIONS) {
-      const oldest = this.state.keys().next().value;
-      if (oldest === undefined) break;
-      this.state.delete(oldest);
-    }
-    // [LAW:no-shared-mutable-globals] `recent` is now the STORED array — copy it
-    // out so the returned value shares no reference with retained state.
-    return { kind: "ok", value: { messageCount, recent: [...recent] } };
-  }
-
-  // [LAW:no-silent-failure] A hook payload with no cost block is `absent`
-  // (old clients); a transcript parse error is `failed`, carried to the
-  // payload boundary — the old catch dressed it as the same all-null record
-  // as "no data".
-  async getMetricsInfo(
-    sessionId: string,
-    hookData: ClaudeHookData,
-  ): Promise<Outcome<MetricsInfo>> {
-    debug(`Getting metrics from hook data for session: ${sessionId}`);
-
-    if (!hookData.cost) {
-      return ABSENT;
-    }
-
-    const folded = await this.foldMetrics(sessionId, hookData.transcript_path);
-    if (folded.kind === "failed") {
-      return failed(`metrics (${sessionId}): ${folded.reason}`);
-    }
-
-    return ok({
-      responseTime: hookData.cost.total_api_duration_ms / 1000,
-      lastResponseTime: this.calculateLastResponseTime(folded.value.recent),
-      sessionDuration: hookData.cost.total_duration_ms / 1000,
-      messageCount: folded.value.messageCount,
-      linesAdded: hookData.cost.total_lines_added,
-      linesRemoved: hookData.cost.total_lines_removed,
-    });
-  }
-}

package/src/segments/pricing.ts

@@ -1,452 +0,0 @@
-import { debug } from "../utils/logger";
-import { get } from "node:https";
-import { URL } from "node:url";
-import { CacheManager } from "../utils/cache";
-import type { PrunedRaw } from "../utils/claude.js";
-
-export interface ModelPricing {
-  name: string;
-  input: number;
-  cache_write_5m: number;
-  cache_write_1h: number;
-  cache_read: number;
-  output: number;
-}
-const OFFLINE_PRICING_DATA: Record<string, ModelPricing> = {
-  "claude-haiku-4-5-20251001": {
-    name: "Claude Haiku 4.5",
-    input: 1.0,
-    output: 5.0,
-    cache_write_5m: 1.25,
-    cache_write_1h: 2.0,
-    cache_read: 0.1,
-  },
-  "claude-haiku-4-5": {
-    name: "Claude Haiku 4.5",
-    input: 1.0,
-    output: 5.0,
-    cache_write_5m: 1.25,
-    cache_write_1h: 2.0,
-    cache_read: 0.1,
-  },
-  "claude-opus-4-20250514": {
-    name: "Claude Opus 4",
-    input: 15.0,
-    output: 75.0,
-    cache_write_5m: 18.75,
-    cache_write_1h: 30.0,
-    cache_read: 1.5,
-  },
-  "claude-opus-4-1": {
-    name: "Claude Opus 4.1",
-    input: 15.0,
-    output: 75.0,
-    cache_write_5m: 18.75,
-    cache_write_1h: 30.0,
-    cache_read: 1.5,
-  },
-  "claude-opus-4-1-20250805": {
-    name: "Claude Opus 4.1",
-    input: 15.0,
-    output: 75.0,
-    cache_write_5m: 18.75,
-    cache_write_1h: 30.0,
-    cache_read: 1.5,
-  },
-  "claude-sonnet-4-20250514": {
-    name: "Claude Sonnet 4",
-    input: 3.0,
-    output: 15.0,
-    cache_write_5m: 3.75,
-    cache_write_1h: 6.0,
-    cache_read: 0.3,
-  },
-  "claude-4-opus-20250514": {
-    name: "Claude 4 Opus",
-    input: 15.0,
-    output: 75.0,
-    cache_write_5m: 18.75,
-    cache_write_1h: 30.0,
-    cache_read: 1.5,
-  },
-  "claude-4-sonnet-20250514": {
-    name: "Claude 4 Sonnet",
-    input: 3.0,
-    output: 15.0,
-    cache_write_5m: 3.75,
-    cache_write_1h: 6.0,
-    cache_read: 0.3,
-  },
-  "claude-sonnet-4-5": {
-    name: "Claude Sonnet 4.5",
-    input: 3.0,
-    output: 15.0,
-    cache_write_5m: 3.75,
-    cache_write_1h: 6.0,
-    cache_read: 0.3,
-  },
-  "claude-sonnet-4-5-20250929": {
-    name: "Claude Sonnet 4.5",
-    input: 3.0,
-    output: 15.0,
-    cache_write_5m: 3.75,
-    cache_write_1h: 6.0,
-    cache_read: 0.3,
-  },
-  "claude-opus-4-5": {
-    name: "Claude Opus 4.5",
-    input: 5.0,
-    output: 25.0,
-    cache_write_5m: 6.25,
-    cache_write_1h: 10.0,
-    cache_read: 0.5,
-  },
-  "claude-opus-4-5-20251101": {
-    name: "Claude Opus 4.5",
-    input: 5.0,
-    output: 25.0,
-    cache_write_5m: 6.25,
-    cache_write_1h: 10.0,
-    cache_read: 0.5,
-  },
-  "claude-opus-4-6": {
-    name: "Claude Opus 4.6",
-    input: 5.0,
-    output: 25.0,
-    cache_write_5m: 6.25,
-    cache_write_1h: 10.0,
-    cache_read: 0.5,
-  },
-  "claude-opus-4-6-20260205": {
-    name: "Claude Opus 4.6",
-    input: 5.0,
-    output: 25.0,
-    cache_write_5m: 6.25,
-    cache_write_1h: 10.0,
-    cache_read: 0.5,
-  },
-  "claude-sonnet-4-6": {
-    name: "Claude Sonnet 4.6",
-    input: 3.0,
-    output: 15.0,
-    cache_write_5m: 3.75,
-    cache_write_1h: 6.0,
-    cache_read: 0.3,
-  },
-};
-
-export class PricingService {
-  private static executionCache: Record<string, ModelPricing> | null = null;
-  private static modelPricingCache = new Map<string, ModelPricing>();
-  private static readonly GITHUB_PRICING_URL =
-    "https://raw.githubusercontent.com/promptctl/cc-candybar/main/pricing.json";
-
-  private static async loadDiskCache(): Promise<Record<
-    string,
-    ModelPricing
-  > | null> {
-    const TTL_24H = 24 * 60 * 60 * 1000;
-    const minValidTime = Date.now() - TTL_24H;
-    return (await CacheManager.getUsageCache(
-      "pricing",
-      minValidTime,
-    )) as Record<string, ModelPricing> | null;
-  }
-
-  private static async saveDiskCache(
-    data: Record<string, ModelPricing>,
-  ): Promise<void> {
-    await CacheManager.setUsageCache("pricing", data);
-  }
-
-  private static async fetchPricingData(): Promise<Record<
-    string,
-    ModelPricing
-  > | null> {
-    return new Promise((resolve) => {
-      const parsedUrl = new URL(this.GITHUB_PRICING_URL);
-
-      const request = get(
-        {
-          hostname: parsedUrl.hostname,
-          path: parsedUrl.pathname,
-          headers: {
-            "User-Agent": "cc-candybar",
-            "Cache-Control": "no-cache",
-          },
-          timeout: 5000,
-        },
-        (response) => {
-          if (response.statusCode !== 200) {
-            debug(`HTTP ${response.statusCode}: ${response.statusMessage}`);
-            resolve(null);
-            return;
-          }
-
-          let data = "";
-          let size = 0;
-          const MAX_SIZE = 1024 * 1024;
-
-          response.on("data", (chunk) => {
-            size += chunk.length;
-            if (size > MAX_SIZE) {
-              debug("Response too large");
-              request.destroy();
-              resolve(null);
-              return;
-            }
-            data += chunk;
-          });
-
-          response.on("end", () => {
-            try {
-              const json = JSON.parse(data);
-              const dataObj = json as Record<string, unknown>;
-              const meta = dataObj._meta as { updated?: string } | undefined;
-
-              const pricingData: Record<string, unknown> = {};
-              for (const [key, value] of Object.entries(dataObj)) {
-                if (key !== "_meta") {
-                  pricingData[key] = value;
-                }
-              }
-
-              if (this.validatePricingData(pricingData)) {
-                debug(
-                  `Fetched fresh pricing from GitHub for ${Object.keys(pricingData).length} models`,
-                );
-                debug(`Pricing last updated: ${meta?.updated || "unknown"}`);
-                resolve(pricingData);
-              } else {
-                debug("Invalid pricing data structure");
-                resolve(null);
-              }
-            } catch (error) {
-              debug("Failed to parse JSON:", error);
-              resolve(null);
-            }
-          });
-
-          response.on("error", (error) => {
-            debug("Response error:", error);
-            resolve(null);
-          });
-        },
-      );
-
-      request.on("error", (error) => {
-        debug("Request error:", error);
-        resolve(null);
-      });
-
-      request.on("timeout", () => {
-        debug("Request timeout");
-        request.destroy();
-        resolve(null);
-      });
-
-      request.end();
-    });
-  }
-
-  static async getCurrentPricing(): Promise<Record<string, ModelPricing>> {
-    if (this.executionCache !== null) {
-      debug(
-        `[CACHE-HIT] Pricing execution cache: ${Object.keys(this.executionCache).length} models`,
-      );
-      return this.executionCache;
-    }
-
-    const diskCached = await this.loadDiskCache();
-    if (diskCached) {
-      debug(
-        `[CACHE-HIT] Pricing disk cache: ${Object.keys(diskCached).length} models`,
-      );
-      this.executionCache = diskCached;
-      debug(
-        `[CACHE-SET] Pricing execution cache stored: ${Object.keys(diskCached).length} models`,
-      );
-      return diskCached;
-    }
-
-    const freshData = await this.fetchPricingData();
-    if (freshData) {
-      await this.saveDiskCache(freshData);
-      debug(
-        `[CACHE-SET] Pricing disk cache stored: ${Object.keys(freshData).length} models`,
-      );
-      this.executionCache = freshData;
-      debug(
-        `[CACHE-SET] Pricing execution cache stored: ${Object.keys(freshData).length} models`,
-      );
-      return freshData;
-    }
-
-    debug(
-      `[CACHE-FALLBACK] Using offline pricing data: ${Object.keys(OFFLINE_PRICING_DATA).length} models`,
-    );
-    this.executionCache = OFFLINE_PRICING_DATA;
-    debug(
-      `[CACHE-SET] Pricing execution cache stored: ${Object.keys(OFFLINE_PRICING_DATA).length} models`,
-    );
-    return OFFLINE_PRICING_DATA;
-  }
-
-  private static validatePricingData(
-    data: unknown,
-  ): data is Record<string, ModelPricing> {
-    if (!data || typeof data !== "object") return false;
-
-    for (const [, value] of Object.entries(data)) {
-      if (!value || typeof value !== "object") return false;
-      const pricing = value as Record<string, unknown>;
-
-      if (
-        typeof pricing.input !== "number" ||
-        typeof pricing.output !== "number" ||
-        typeof pricing.cache_read !== "number"
-      ) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  static async getModelPricing(modelId: string): Promise<ModelPricing> {
-    if (this.modelPricingCache.has(modelId)) {
-      debug(`[CACHE-HIT] Model pricing cache: ${modelId}`);
-      return this.modelPricingCache.get(modelId)!;
-    }
-
-    const allPricing = await this.getCurrentPricing();
-    let pricing: ModelPricing;
-
-    if (allPricing[modelId]) {
-      pricing = allPricing[modelId];
-    } else {
-      pricing = this.fuzzyMatchModel(modelId, allPricing);
-    }
-
-    this.modelPricingCache.set(modelId, pricing);
-    debug(`[CACHE-SET] Model pricing cache: ${modelId}`);
-    return pricing;
-  }
-
-  private static fuzzyMatchModel(
-    modelId: string,
-    allPricing: Record<string, ModelPricing>,
-  ): ModelPricing {
-    const lowerModelId = modelId.toLowerCase();
-
-    for (const [key, pricing] of Object.entries(allPricing)) {
-      if (key.toLowerCase() === lowerModelId) {
-        return pricing;
-      }
-    }
-    const patterns = [
-      {
-        pattern: ["opus-4-6", "claude-opus-4-6"],
-        fallback: "claude-opus-4-6-20260205",
-      },
-      {
-        pattern: ["opus-4-5", "claude-opus-4-5"],
-        fallback: "claude-opus-4-5-20251101",
-      },
-      {
-        pattern: ["opus-4-1", "claude-opus-4-1"],
-        fallback: "claude-opus-4-1-20250805",
-      },
-      {
-        pattern: ["opus-4", "claude-opus-4"],
-        fallback: "claude-opus-4-20250514",
-      },
-      {
-        pattern: ["sonnet-4-6", "sonnet-4.6", "claude-sonnet-4-6"],
-        fallback: "claude-sonnet-4-6",
-      },
-      {
-        pattern: ["sonnet-4.5", "4-5-sonnet", "sonnet-4-5"],
-        fallback: "claude-sonnet-4-5-20250929",
-      },
-      {
-        pattern: ["sonnet-4", "claude-sonnet-4"],
-        fallback: "claude-sonnet-4-20250514",
-      },
-      {
-        pattern: ["haiku-4.5", "4-5-haiku", "haiku-4-5"],
-        fallback: "claude-haiku-4-5-20251001",
-      },
-      { pattern: ["haiku"], fallback: "claude-haiku-4-5-20251001" },
-      { pattern: ["opus"], fallback: "claude-opus-4-20250514" },
-      { pattern: ["sonnet"], fallback: "claude-sonnet-4-5-20250929" },
-    ];
-
-    for (const { pattern, fallback } of patterns) {
-      if (pattern.some((p) => lowerModelId.includes(p))) {
-        if (allPricing[fallback]) {
-          return allPricing[fallback];
-        }
-      }
-    }
-
-    return (
-      allPricing["claude-sonnet-4-5-20250929"] || {
-        name: `${modelId} (Unknown Model)`,
-        input: 3.0,
-        cache_write_5m: 3.75,
-        cache_write_1h: 6.0,
-        cache_read: 0.3,
-        output: 15.0,
-      }
-    );
-  }
-
-  static async calculateCostForEntry(entry: PrunedRaw): Promise<number> {
-    const usage = entry.message?.usage;
-    if (!usage) {
-      return 0;
-    }
-
-    const modelId = this.extractModelId(entry);
-    const pricing = await this.getModelPricing(modelId);
-
-    const inputTokens = usage.input_tokens || 0;
-    const outputTokens = usage.output_tokens || 0;
-    const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
-    const cacheReadTokens = usage.cache_read_input_tokens || 0;
-
-    const inputCost = (inputTokens / 1_000_000) * pricing.input;
-    const outputCost = (outputTokens / 1_000_000) * pricing.output;
-    const cacheReadCost = (cacheReadTokens / 1_000_000) * pricing.cache_read;
-    const cacheCreationCost =
-      (cacheCreationTokens / 1_000_000) * pricing.cache_write_5m;
-
-    return inputCost + outputCost + cacheCreationCost + cacheReadCost;
-  }
-
-  private static extractModelId(entry: Record<string, unknown>): string {
-    if (entry.model && typeof entry.model === "string") {
-      return entry.model;
-    }
-
-    const message = entry.message as Record<string, unknown> | undefined;
-    if (message?.model) {
-      const model = message.model;
-      if (typeof model === "string") {
-        return model;
-      }
-      const modelObj = model as Record<string, unknown> | undefined;
-      return (
-        (typeof modelObj?.id === "string" ? modelObj.id : null) ||
-        "claude-sonnet-4-5-20250929"
-      );
-    }
-
-    if (entry.model_id && typeof entry.model_id === "string") {
-      return entry.model_id;
-    }
-
-    return "claude-sonnet-4-5-20250929";
-  }
-}

package/src/segments/session.ts

@@ -1,23 +0,0 @@
-// [LAW:decomposition] The session usage CONTRACT — the shapes the daemon's
-// SessionUsageStore produces and the render payload reads. The transcript fold
-// that produces them is incremental and lives in the store (its single owner);
-// this module is the type seam both sides agree on.
-
-export interface TokenBreakdown {
-  input: number;
-  output: number;
-  cacheCreation: number;
-  cacheRead: number;
-}
-
-export interface SessionInfo {
-  cost: number | null;
-  calculatedCost: number | null;
-  officialCost: number | null;
-  tokens: number | null;
-  tokenBreakdown: TokenBreakdown | null;
-}
-
-export interface UsageInfo {
-  session: SessionInfo;
-}