@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/render/strip.ts

@@ -1,228 +0,0 @@
-import {
-  Strip,
-  RichText,
-  Style,
-  PowerlineJoiner,
-  CapsuleJoiner,
-  PlainJoiner,
-  FlexStrip,
-  renderToString,
-  type Joiner,
-  type PowerlineJoinerOptions,
-  type CapsuleJoinerOptions,
-} from "@promptctl/rich-js";
-import type {
-  Charset,
-  ColorCompatibility,
-  StripStyle,
-} from "../themes/policy.js";
-
-export interface RenderedSegmentLike {
-  type: string;
-  text: string;
-  bgHex?: string;
-  fgHex?: string;
-}
-
-// [LAW:one-source-of-truth] `StripStyle`/`Charset` and their value lists live
-// in themes/policy.ts (the render-identifier policy module, importable by the
-// option-source machinery without a render→template-engine cycle). Re-exported
-// here so render-layer consumers can keep importing them from the strip module.
-export type { Charset, ColorCompatibility, StripStyle };
-
-// [LAW:one-source-of-truth] Raw terminal cols we assume when the wire
-// didn't give us one (older client, env-stripped spawn). RAW — not
-// post-reserve — so the Claude-Code-UI reserve applies uniformly across
-// wire and fallback paths (callers thread this through
-// applyClaudeCodeReserve from src/utils/terminal-width).
-export const DEFAULT_TERMINAL_WIDTH = 120;
-
-// [LAW:one-source-of-truth] autoWrap's and padding's defaults live in
-// themes/policy.ts beside their resolvers and padding's range, because the
-// config loader needs them too and config must not import render
-// [LAW:one-way-deps]. Re-exported here on the same terms as the types above, so
-// render-layer consumers keep importing them from the strip module.
-export { DEFAULT_WRAP, DEFAULT_PADDING } from "../themes/policy.js";
-
-// [LAW:one-source-of-truth] The one statement of the globals.charset default
-// (powerline unicode glyphs — current behavior, matching the legacy
-// display.charset). Every resolver of the config global
-// (`globals.charset ?? DEFAULT_CHARSET`) derives from this constant.
-export const DEFAULT_CHARSET: Charset = "unicode";
-
-// [LAW:one-source-of-truth] The one statement of the globals.colorCompatibility
-// default (truecolor — the CURRENT pinned value, deliberately NOT the legacy
-// "auto" default, which would change rendering for existing users). Every
-// resolver of the config global (`globals.colorCompatibility ??
-// DEFAULT_COLOR_COMPATIBILITY`) derives from this constant.
-export const DEFAULT_COLOR_COMPATIBILITY: ColorCompatibility = "truecolor";
-
-export interface BuildLineOptions {
-  style: StripStyle;
-  // [LAW:types-are-the-program] Narrower than rich-js ColorSystemSpec on
-  // purpose: the four explicit depths only. "auto"/null never reach a render —
-  // the daemon is detached, so env detection would read the wrong terminal;
-  // the loader rejects "auto" at the trust boundary (see COLOR_COMPATIBILITIES
-  // in themes/policy.ts), and every construction site states a resolved depth.
-  colorCompatibility: ColorCompatibility;
-  separator?: string;
-  // [LAW:types-are-the-program] Every render carries a width. Required (not
-  // optional) so callers cannot silently drop the wire's value.
-  // [LAW:one-source-of-truth] Width is a FACT (usable cells) feeding two
-  // consumers — FlexStrip's wrap limit AND the picker's pagination
-  // (`term.cols`). It stays finite even when wrapping is off; `wrap` below is
-  // the separate POLICY of whether rows may soft-break at that width.
-  width: number;
-  // [LAW:types-are-the-program] Required for the same reason as width: the
-  // wrap decision (globals.autoWrap, default on) must reach every render
-  // explicitly — encoding "no wrap" as width=Infinity would corrupt the
-  // picker's pagination, which reads the same width value.
-  wrap: boolean;
-  // [LAW:one-source-of-truth] Spaces inside each segment cell per side
-  // (globals.padding, default 1 — the legacy display.padding, intra-cell,
-  // not rich-js FlexStrip's inter-item gap). Required so every construction
-  // site states the resolved value; the cell builders derive from it and
-  // never re-default.
-  padding: number;
-  // [LAW:one-source-of-truth] Which glyph vocabulary the joiners render with
-  // (globals.charset, default "unicode" — the legacy display.charset).
-  // Required for the same reason as padding: the resolved value reaches every
-  // render explicitly; pickJoiner derives from it and never re-defaults.
-  charset: Charset;
-}
-
-// [LAW:dataflow-not-control-flow] Charset variability lives in these VALUES,
-// not in branches: per style, each charset names the joiner-construction
-// options. The unicode entries are empty on purpose — rich-js owns its
-// canonical powerline glyphs (U+E0B0 / U+E0B6+U+E0B4) and restating them here
-// would be a second source that could drift [LAW:one-source-of-truth]. The
-// ascii glyphs are DELIBERATELY single-column (same display width as the
-// unicode caps) so stripChromeCols stays charset-invariant; the
-// measured-chrome pin in test/picker-pagination.test.ts checks that for every
-// style × charset. Widen a glyph and that pin fails loudly.
-const POWERLINE_GLYPHS: Record<Charset, PowerlineJoinerOptions> = {
-  unicode: {},
-  ascii: { glyph: ">" },
-};
-const CAPSULE_GLYPHS: Record<Charset, CapsuleJoinerOptions> = {
-  unicode: {},
-  ascii: { left: "(", right: ")" },
-};
-
-function pickJoiner(
-  style: StripStyle,
-  charset: Charset,
-  separator?: string,
-): Joiner {
-  // [LAW:dataflow-not-control-flow] joiner choice is data-driven; one arm per
-  // shape. Style picks the joiner CLASS, charset indexes the glyph options fed
-  // to it — the two dimensions stay orthogonal (any style renders under either
-  // charset). Plain takes no charset lookup: its separator is already user
-  // data (globals.default_separator) and its default (" | ") is ASCII-safe.
-  // [LAW:types-are-the-program] Total over StripStyle — the `never`
-  // default makes adding a STRIP_STYLES member a compile error here until it
-  // gets a joiner, so the picker's domain can never offer an unrenderable shape.
-  switch (style) {
-    case "capsule":
-      return new CapsuleJoiner(CAPSULE_GLYPHS[charset]);
-    case "plain":
-      return new PlainJoiner(separator !== undefined ? { separator } : {});
-    case "powerline":
-      return new PowerlineJoiner(POWERLINE_GLYPHS[charset]);
-    default: {
-      const _exhaustive: never = style;
-      return _exhaustive;
-    }
-  }
-}
-
-// [LAW:single-enforcer] Strip geometry has one owner — this module builds every
-// joiner (pickJoiner) and so alone knows the structural chrome a styled row costs
-// beyond its content: the joiner's end-caps, which FlexStrip paints OUTSIDE the
-// width budget. A single full-width row's content can occupy only `width - chrome`
-// before the caps push the line past `width`. Returned per style so a width-fit
-// widget (the picker) can reserve it and never overflow the wrapped line.
-//
-// [LAW:dataflow-not-control-flow] / [LAW:types-are-the-program] Total over
-// StripStyle — the `never` default makes adding a STRIP_STYLES member a compile
-// error here until its chrome is declared, the same guard pickJoiner carries. The
-// numbers are the cap glyphs pickJoiner constructs: powerline appends ONE
-// trailing separator (1 col); capsule brackets BOTH edges (2 cols); plain has no
-// caps. Charset does NOT change these — both glyph vocabularies use
-// single-column caps by construction (see the glyph tables above), which is why
-// this stays total over StripStyle alone. test/picker-pagination.test.ts
-// measures the real rendered chrome against these for every style × charset so
-// the declaration cannot drift from rich-js or from the ascii glyph choice.
-export function stripChromeCols(style: StripStyle): number {
-  switch (style) {
-    case "powerline":
-      return 1;
-    case "capsule":
-      return 2;
-    case "plain":
-      return 0;
-    default: {
-      const _exhaustive: never = style;
-      return _exhaustive;
-    }
-  }
-}
-
-function toCell(seg: RenderedSegmentLike, padding: number): RichText {
-  // [LAW:one-source-of-truth] Intra-cell padding derives from the one resolved
-  // globals.padding value on BuildLineOptions — the joiners sit between cells;
-  // padding sits inside, inheriting the cell's wrapping style (bg fill).
-  const style = new Style({
-    bgcolor: seg.bgHex || undefined,
-    color: seg.fgHex || undefined,
-  });
-  return new RichText(seg.text, { style, end: "", noWrap: true }).pad(padding);
-}
-
-/**
- * [LAW:single-enforcer] The one place RichText cells become an ANSI byte
- * string. Every render path (DSL RichText[] via the template-engine
- * pipeline, buildLineStrip's input-shape adapter, debug per-segment
- * serialization) flows through here. The wrap dispatch lives here too:
- * wrap enabled at a finite width → FlexStrip (rich-js owns the wrap
- * algebra); otherwise → Strip, one unbounded line.
- *
- * [LAW:dataflow-not-control-flow] The dispatch is on values, not on caller
- * branches: `wrap` (the globals.autoWrap policy) gates whether the finite
- * width acts as a break limit. An infinite width has nothing to break at,
- * so it renders unbounded regardless of `wrap`.
- */
-export function renderStripCells(
-  cells: readonly RichText[],
-  options: BuildLineOptions,
-): string {
-  if (cells.length === 0) return "";
-  const joiner = pickJoiner(options.style, options.charset, options.separator);
-  if (options.wrap && Number.isFinite(options.width)) {
-    const flex = new FlexStrip([...cells], { joiner });
-    const out = renderToString(flex, {
-      width: options.width,
-      colorSystem: options.colorCompatibility,
-    });
-    return out.endsWith("\n") ? out.slice(0, -1) : out;
-  }
-  const strip = new Strip([...cells], joiner);
-  return renderToString(strip, {
-    colorSystem: options.colorCompatibility,
-  });
-}
-
-/**
- * Input-shape adapter for callers that hold RenderedSegmentLike[] rather
- * than pre-constructed RichText cells. Wrap behavior is identical to
- * renderStripCells — the cell construction is the only difference.
- */
-export function buildLineStrip(
-  segments: readonly RenderedSegmentLike[],
-  options: BuildLineOptions,
-): string {
-  return renderStripCells(
-    segments.map((seg) => toCell(seg, options.padding)),
-    options,
-  );
-}

package/src/segments/cache.ts

@@ -1,131 +0,0 @@
-// Prompt-cache warmth provider.
-//
-// Anthropic's prompt cache has a fixed TTL (1h): each turn that reads or
-// creates cache entries refreshes it, and after the TTL the next turn pays
-// full cache-creation cost again. This provider answers one question — when
-// does the current session's cache go cold? — by tail-reading the transcript
-// for the most recent entry that touched the cache and projecting its
-// timestamp forward by the TTL.
-//
-// [LAW:dataflow-not-control-flow] The datum is a single epoch instant, not a
-// rendered string. Whether the timer shows "12m", "cold", or hides entirely,
-// and what color it takes, are all functions of this one number evaluated in
-// the DSL template — the same shape block/weekly use with `resetsAt`. The
-// provider carries no display policy.
-//
-// [LAW:types-are-the-program] The return is `Outcome<number>`: a known expiry
-// instant (`ok`), "no cache activity found" (`absent` — no transcript yet, or
-// no cache-bearing entry), or a real read failure (`failed` — the transcript
-// exists but couldn't be read). Absent becomes a missing payload field, which
-// the segment's `when` predicate reads as hidden; failed reaches the payload
-// boundary, the one place that logs it — there is no "0 means hidden"
-// ambiguity to defend against downstream, and no failure dressed as absence.
-
-import { ABSENT, ok, type Outcome } from "../utils/outcome.js";
-import { readTail } from "../utils/transcript-fs.js";
-
-// Anthropic prompt cache TTL. A const, not a knob: it is a property of the
-// upstream cache, not of this renderer. If a future cache tier ships a
-// different TTL, that is a new arm here, not a user config field.
-const CACHE_TTL_MS = 60 * 60 * 1000;
-const TAIL_CHUNK = 64 * 1024;
-const TAIL_MAX = 1 * 1024 * 1024;
-
-// [LAW:types-are-the-program] A cheap CANDIDATE filter, not the authority. It
-// matches any line mentioning a non-zero cache-token field, which includes a
-// line whose *message content* merely quotes the string (a pasted JSON snippet,
-// a transcript of a review discussing these very fields). The authoritative
-// check is the parsed `message.usage` value — the regex only avoids JSON.parsing
-// every line; a match is verified before its timestamp is trusted. The `[1-9]`
-// rejects the `":0` common case so most non-cache lines never reach the parser.
-const CACHE_HIT_RE =
-  /"(?:cache_read_input_tokens|cache_creation_input_tokens)":[1-9]/;
-
-// The transcript-line shape this provider reads. Untrusted JSON — every field is
-// optional and narrowed at use; only positive `message.usage` cache tokens count.
-interface UsageLine {
-  readonly timestamp?: string;
-  readonly message?: {
-    readonly usage?: {
-      readonly cache_read_input_tokens?: number;
-      readonly cache_creation_input_tokens?: number;
-    };
-  };
-}
-
-// Parse a candidate line and return its millisecond timestamp ONLY if its
-// `message.usage` actually records positive cache activity. A content-only
-// mention (or unparseable line) yields null, so a false-positive regex match
-// can never set the timer warm.
-function cacheActivityTs(line: string): number | null {
-  let parsed: UsageLine;
-  try {
-    parsed = JSON.parse(line) as UsageLine;
-  } catch {
-    return null;
-  }
-  const usage = parsed.message?.usage;
-  const positive =
-    (usage?.cache_read_input_tokens ?? 0) > 0 ||
-    (usage?.cache_creation_input_tokens ?? 0) > 0;
-  if (!positive) return null;
-  const ms = parsed.timestamp != null ? Date.parse(parsed.timestamp) : NaN;
-  return Number.isNaN(ms) ? null : ms;
-}
-
-/**
- * Epoch *seconds* at which the session's prompt cache expires; `absent` when
- * no cache-bearing transcript entry can be found; `failed` when the
- * transcript exists but couldn't be read. Seconds (not millis) to match the
- * unit of block/weekly `resetsAt`, so the DSL composes
- * `minutesUntilReset .cache.expiresAt` with no unit translation.
- */
-export async function cacheExpiresAt(
-  transcriptPath: string,
-): Promise<Outcome<number>> {
-  const lastCacheMs = await findLastCacheActivityTs(transcriptPath);
-  if (lastCacheMs.kind !== "ok") return lastCacheMs;
-  return ok(Math.floor((lastCacheMs.value + CACHE_TTL_MS) / 1000));
-}
-
-// Tail-read the JSONL transcript and return the millisecond timestamp of the
-// last entry with cache activity. The relevant entry is almost always within
-// the final few KB, so the common case reads one TAIL_CHUNK; only a transcript
-// whose last cache hit is deeper grows to TAIL_MAX. [LAW:single-enforcer] both
-// reads go through the gated transcript-fs seam (readTail), so this scanner is
-// bounded with every other transcript read instead of blocking the event loop
-// on synchronous fs.
-async function findLastCacheActivityTs(
-  transcriptPath: string,
-): Promise<Outcome<number>> {
-  for (const maxBytes of [TAIL_CHUNK, TAIL_MAX]) {
-    const tail = await readTail(transcriptPath, maxBytes);
-    // absent (no transcript yet) and failed (unreadable) both end the scan;
-    // the outcome carries which one happened to the payload boundary.
-    if (tail.kind !== "ok") return tail;
-    const ts = scanBufferForLastCacheTs(tail.value.buf, tail.value.fromStart);
-    if (ts != null) return ok(ts);
-    // The window reached the file start: the whole transcript is scanned, no
-    // hit exists — growing further would re-read the same bytes.
-    if (tail.value.fromStart) return ABSENT;
-  }
-  return ABSENT;
-}
-
-function scanBufferForLastCacheTs(
-  buf: Buffer,
-  bufStartsAtFileBeginning: boolean,
-): number | null {
-  const text = buf.toString("utf8");
-  const lines = text.split("\n");
-  // When the window doesn't start at the file beginning, the first line is
-  // likely a partial JSON object — skip it so we never mis-parse a fragment.
-  const start = bufStartsAtFileBeginning ? 0 : 1;
-  for (let i = lines.length - 1; i >= start; i--) {
-    const line = lines[i];
-    if (!line || !CACHE_HIT_RE.test(line)) continue; // cheap candidate filter
-    const ts = cacheActivityTs(line); // authoritative: parsed usage must be > 0
-    if (ts != null) return ts;
-  }
-  return null;
-}

package/src/segments/context.ts

@@ -1,190 +0,0 @@
-import type { ParsedEntry, ClaudeHookData } from "../utils/claude";
-
-import { debug } from "../utils/logger";
-import { parseJsonlFile } from "../utils/claude";
-import { ABSENT, failed, ok, type Outcome } from "../utils/outcome";
-
-export interface ContextInfo {
-  totalTokens: number;
-  // Used / remaining percentages. Sourced from Claude's native
-  // context_window.used_percentage / remaining_percentage when present; a
-  // plain token-ratio is the only fallback (no auto-compact buffer guess).
-  percentage: number;
-  contextLeftPercentage: number;
-  maxTokens: number;
-}
-
-interface ContextUsageThresholds {
-  LOW: number;
-  MEDIUM: number;
-}
-
-// [LAW:one-source-of-truth] The context-window size is NEVER guessed from the
-// model name. Claude Code reports the real size for the active model in
-// `context_window.context_window_size` (1M for the [1m] variants, 200k
-// otherwise) — that field is the single authority. This constant is the
-// last-resort floor for ancient clients that omit `context_window` entirely;
-// it is not a per-model table and must not grow into one.
-const DEFAULT_CONTEXT_WINDOW = 200000;
-
-export class ContextProvider {
-  private readonly thresholds: ContextUsageThresholds = {
-    LOW: 50,
-    MEDIUM: 80,
-  };
-
-  getContextUsageThresholds(): ContextUsageThresholds {
-    return this.thresholds;
-  }
-
-  // Token-ratio percentages — the fallback ONLY. Used when Claude doesn't
-  // report used_percentage / remaining_percentage natively (transcript path,
-  // or a native window whose percentages are still null pre-first-call). No
-  // auto-compact buffer: that was a hardcoded guess at Claude's threshold and
-  // a soft second source; the native remaining_percentage is authoritative.
-  private ratioPercentages(
-    totalTokens: number,
-    contextLimit: number,
-  ): Pick<ContextInfo, "percentage" | "contextLeftPercentage"> {
-    const percentage = Math.min(
-      100,
-      Math.max(0, Math.round((totalTokens / contextLimit) * 100)),
-    );
-    return { percentage, contextLeftPercentage: Math.max(0, 100 - percentage) };
-  }
-
-  /**
-   * Calculate context info from native Claude Code context_window data (preferred).
-   * Requires Claude Code 2.0.70+ with current_usage field.
-   */
-  calculateContextFromHookData(hookData: ClaudeHookData): ContextInfo | null {
-    const cw = hookData.context_window;
-    if (!cw?.current_usage) {
-      debug(
-        "No current_usage in hook data, falling back to transcript parsing",
-      );
-      return null;
-    }
-
-    const currentUsage = cw.current_usage;
-    // [LAW:no-defensive-null-guards] context_window_size is a required `number`
-    // within context_window; reaching here proves cw is present, so the size
-    // is too. No `|| default` — that would mask a malformed payload as 200k.
-    const contextLimit = cw.context_window_size;
-    const totalTokens =
-      (currentUsage.input_tokens || 0) +
-      (currentUsage.cache_creation_input_tokens || 0) +
-      (currentUsage.cache_read_input_tokens || 0);
-
-    debug(
-      `Native current_usage: input=${currentUsage.input_tokens}, cache_create=${currentUsage.cache_creation_input_tokens}, cache_read=${currentUsage.cache_read_input_tokens}, total=${totalTokens} (limit: ${contextLimit})`,
-    );
-
-    // [LAW:one-source-of-truth] Claude's reported used/remaining percentages
-    // are authoritative; the token-ratio is only a floor for the window whose
-    // percentages are still null (pre-first-call). remaining_percentage is NOT
-    // recomputed from a local buffer — it measures real headroom to the limit.
-    const ratio = this.ratioPercentages(totalTokens, contextLimit);
-    return {
-      totalTokens,
-      maxTokens: contextLimit,
-      percentage:
-        cw.used_percentage != null
-          ? Math.round(cw.used_percentage)
-          : ratio.percentage,
-      contextLeftPercentage:
-        cw.remaining_percentage != null
-          ? Math.round(cw.remaining_percentage)
-          : ratio.contextLeftPercentage,
-    };
-  }
-
-  /**
-   * Calculate context tokens by parsing the transcript file (fallback).
-   * Used for older Claude Code versions that don't provide context_window.
-   *
-   * [LAW:no-silent-failure] An unreadable transcript is `failed` (the payload
-   * boundary logs it); a transcript with no usable usage entry is `absent`.
-   * The old catch-to-null collapsed both into "no data".
-   */
-  async calculateContextTokensFromTranscript(
-    transcriptPath: string,
-    contextLimit: number,
-  ): Promise<Outcome<ContextInfo>> {
-    try {
-      debug(`Calculating context tokens from transcript: ${transcriptPath}`);
-
-      const parsedEntries = await parseJsonlFile(transcriptPath);
-
-      if (parsedEntries.length === 0) {
-        debug("No entries in transcript");
-        return ABSENT;
-      }
-
-      let mostRecentEntry: ParsedEntry | null = null;
-
-      for (let i = parsedEntries.length - 1; i >= 0; i--) {
-        const entry = parsedEntries[i];
-        if (!entry) continue;
-
-        if (!entry.message?.usage?.input_tokens) continue;
-        if (entry.isSidechain === true) continue;
-
-        mostRecentEntry = entry;
-        debug(
-          `Context segment: Found most recent entry at ${entry.timestamp.toISOString()}, stopping search`,
-        );
-        break;
-      }
-
-      if (mostRecentEntry?.message?.usage) {
-        const usage = mostRecentEntry.message.usage;
-        const totalTokens =
-          (usage.input_tokens || 0) +
-          (usage.cache_read_input_tokens || 0) +
-          (usage.cache_creation_input_tokens || 0);
-
-        debug(
-          `Most recent main chain context: ${totalTokens} tokens (limit: ${contextLimit})`,
-        );
-
-        return ok({
-          totalTokens,
-          maxTokens: contextLimit,
-          ...this.ratioPercentages(totalTokens, contextLimit),
-        });
-      }
-
-      debug("No main chain entries with usage data found");
-      return ABSENT;
-    } catch (error) {
-      return failed(
-        `context transcript: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-  }
-
-  /**
-   * Get context info using native data if available, falling back to transcript parsing.
-   */
-  async getContextInfo(
-    hookData: ClaudeHookData,
-  ): Promise<Outcome<ContextInfo>> {
-    const nativeContext = this.calculateContextFromHookData(hookData);
-    if (nativeContext) {
-      return ok(nativeContext);
-    }
-
-    // [LAW:one-source-of-truth] current_usage can be null (pre-first-call or
-    // post-/compact) while context_window_size is still present and
-    // authoritative — prefer it here too, and only fall to the floor when the
-    // client omits context_window entirely.
-    const contextLimit =
-      hookData.context_window?.context_window_size ?? DEFAULT_CONTEXT_WINDOW;
-
-    return this.calculateContextTokensFromTranscript(
-      hookData.transcript_path,
-      contextLimit,
-    );
-  }
-}