@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/utils/color-support.ts

@@ -1,118 +0,0 @@
-import process from "node:process";
-import tty from "node:tty";
-
-export function getColorSupport(): "none" | "ansi" | "ansi256" | "truecolor" {
-  const { env } = process;
-
-  let colorEnabled = true;
-
-  if (env.NO_COLOR && env.NO_COLOR !== "") {
-    colorEnabled = false;
-  }
-
-  const forceColor = env.FORCE_COLOR;
-  if (forceColor && forceColor !== "") {
-    if (forceColor === "false" || forceColor === "0") {
-      return "none";
-    }
-    if (forceColor === "true" || forceColor === "1") {
-      return "ansi";
-    }
-    if (forceColor === "2") {
-      return "ansi256";
-    }
-    if (forceColor === "3") {
-      return "truecolor";
-    }
-    return "ansi";
-  }
-
-  if (!colorEnabled) {
-    return "none";
-  }
-
-  if (env.TERM === "dumb") {
-    return "none";
-  }
-
-  if (env.CI) {
-    if (
-      ["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)
-    ) {
-      return "truecolor";
-    }
-    return "ansi";
-  }
-
-  if (env.COLORTERM === "truecolor") {
-    return "truecolor";
-  }
-
-  const truecolorTerminals = [
-    "xterm-kitty",
-    "xterm-ghostty",
-    "wezterm",
-    "alacritty",
-    "foot",
-    "contour",
-  ];
-
-  if (truecolorTerminals.includes(env.TERM || "")) {
-    return "truecolor";
-  }
-
-  if (env.TERM_PROGRAM) {
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app":
-        return "truecolor";
-      case "Apple_Terminal":
-        return "ansi256";
-      case "vscode":
-        return "truecolor";
-      case "Tabby":
-        return "truecolor";
-    }
-  }
-
-  if (/-256(color)?$/i.test(env.TERM || "")) {
-    return "ansi256";
-  }
-
-  if (/-truecolor$/i.test(env.TERM || "")) {
-    return "truecolor";
-  }
-
-  if (
-    /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
-      env.TERM || "",
-    )
-  ) {
-    return "ansi";
-  }
-
-  if (env.COLORTERM) {
-    return "ansi";
-  }
-
-  if (tty?.WriteStream?.prototype?.hasColors) {
-    try {
-      const colors = tty.WriteStream.prototype.hasColors();
-      if (!colors) {
-        return "none";
-      }
-
-      const has256Colors = tty.WriteStream.prototype.hasColors(256);
-      const has16mColors = tty.WriteStream.prototype.hasColors(16777216);
-
-      if (has16mColors) {
-        return "truecolor";
-      } else if (has256Colors) {
-        return "ansi256";
-      } else {
-        return "ansi";
-      }
-    } catch {}
-  }
-
-  return "ansi";
-}

package/src/utils/formatters.ts

@@ -1,99 +0,0 @@
-const CLAUDE_MODEL_PATTERN =
-  /^(?:(?:global|apac|au|eu|us|us-east-\d|us-west-\d|eu-west-\d|eu-central-\d)\.)?(?:anthropic\.|azure_ai\/|bedrock\/|vertex_ai\/)?claude-(?:(?<family>opus|sonnet|haiku)-(?<newMajor>\d+)(?:-(?<newMinor>\d))?|(?<oldMajor>\d+)(?:-(?<oldMinor>\d))?-(?<oldFamily>opus|sonnet|haiku))(?:[-@]\d{8})?(?:-v\d+:\d+)?(?:-latest)?$/i;
-
-const FRIENDLY_MODEL_PATTERN =
-  /^(?<family>opus|sonnet|haiku)\s+(?<major>\d+)(?:\.(?<minor>\d))?$/i;
-
-export function formatModelName(rawName: string): string {
-  if (!rawName) {
-    return "Claude";
-  }
-
-  // [LAW:one-source-of-truth] strip variant decorations (e.g. " (1M context)",
-  // "[1m]") so all callers see canonical "Family X.Y" output regardless of
-  // whether the input came from model.id or model.display_name.
-  const stripped = rawName
-    .trim()
-    .replace(/\s*\([^)]*\)\s*$/, "")
-    .replace(/\s*\[[^\]]*\]\s*$/, "")
-    .trim();
-
-  const match = stripped.match(CLAUDE_MODEL_PATTERN);
-  if (match?.groups) {
-    const { family, newMajor, newMinor, oldMajor, oldMinor, oldFamily } =
-      match.groups;
-
-    const modelFamily = family || oldFamily;
-    const major = newMajor || oldMajor;
-    const minor = newMinor || oldMinor;
-
-    if (modelFamily && major) {
-      const capitalizedFamily =
-        modelFamily.charAt(0).toUpperCase() +
-        modelFamily.slice(1).toLowerCase();
-      const version = minor ? `${major}.${minor}` : major;
-      return `${capitalizedFamily} ${version}`;
-    }
-  }
-
-  const friendly = stripped.match(FRIENDLY_MODEL_PATTERN);
-  if (friendly?.groups) {
-    const family = friendly.groups.family!;
-    const major = friendly.groups.major!;
-    const minor = friendly.groups.minor;
-    const capitalizedFamily =
-      family.charAt(0).toUpperCase() + family.slice(1).toLowerCase();
-    const version = minor ? `${major}.${minor}` : major;
-    return `${capitalizedFamily} ${version}`;
-  }
-
-  return stripped || rawName;
-}
-
-export function shortenModelName(formatted: string): string {
-  // [LAW:one-type-per-behavior] same parser, different rendering — operates on
-  // the canonical output of formatModelName so callers don't reparse raw IDs.
-  const match = formatted.match(FRIENDLY_MODEL_PATTERN);
-  if (!match?.groups) return formatted;
-  const family = match.groups.family!;
-  const major = match.groups.major!;
-  const minor = match.groups.minor;
-  const initial = family.charAt(0).toUpperCase();
-  const version = minor ? `${major}.${minor}` : major;
-  return `${initial}${version}`;
-}
-
-// [LAW:decomposition] Fish-shell `prompt_pwd` abbreviation: collapse every path
-// segment EXCEPT the leaf to its leading character, keeping any leading dots so
-// `.config` → `.c`. A pure string→string transform that knows nothing about
-// home-collapse or project-relative logic — those live in the directory
-// template and this abbreviates whatever collapsed display path they produce.
-// `~/code/cc-candybar` → `~/c/cc-candybar`; a leading "/" is preserved because
-// the empty pre-slash segment abbreviates to empty (`/usr/local/bin` → `/u/l/bin`).
-export function abbreviatePath(path: string): string {
-  const segments = path.split("/");
-  const lastIndex = segments.length - 1;
-  return segments
-    .map((seg, i) => {
-      if (i === lastIndex) return seg;
-      // Leading dot-run plus the first following char (fish keeps dotfiles
-      // legible: `.config` → `.c`, `..` → `..`). No following char (empty
-      // segment) means no match — return it unchanged.
-      const abbreviated = seg.match(/^\.*./);
-      return abbreviated ? abbreviated[0] : seg;
-    })
-    .join("/");
-}
-
-// [LAW:one-source-of-truth] Locale-grouped integer rendering. Callers that
-// want "50,000" instead of "50000" go through this rather than calling
-// toLocaleString() ad-hoc — the legacy context segment used the latter
-// pattern inline, and the DSL formatter (template-engine/funcs.ts)
-// delegates here so the two producers agree by construction.
-//
-// No locale argument: the default-locale behaviour is exactly what the
-// legacy renderer did (`n.toLocaleString()`), so byte-parity holds with
-// whatever locale the host process picks at startup.
-export function formatInteger(n: number): string {
-  return n.toLocaleString();
-}

package/src/utils/logger.ts

@@ -1,5 +0,0 @@
-export function debug(message: string, ...args: unknown[]): void {
-  if (process.env.CC_CANDYBAR_DEBUG) {
-    console.error(`[DEBUG] ${message}`, ...args);
-  }
-}

package/src/utils/outcome.ts

@@ -1,33 +0,0 @@
-// [LAW:types-are-the-program] The provider-outcome vocabulary: a data fetch
-// either produced a value, found that the domain genuinely has none (no
-// upstream configured, no transcript yet), or failed to get an answer at all
-// (timeout, spawn error, unreadable file). Before this type, the third state
-// was unrepresentable — failure had to wear a real value's clothes (0, "",
-// a basename) and the lie flowed all the way to the rendered bar.
-//
-// [LAW:dataflow-not-control-flow] Failure is a value that flows to a
-// boundary, not a swallowed branch. Producers classify once, where the
-// command semantics are known; consumers fold once, at the edge where the
-// log effect and the payload mapping live.
-export type Outcome<T> =
-  | { readonly kind: "ok"; readonly value: T }
-  | { readonly kind: "absent" }
-  | { readonly kind: "failed"; readonly reason: string };
-
-export function ok<T>(value: T): Outcome<T> {
-  return { kind: "ok", value };
-}
-
-export const ABSENT: Outcome<never> = { kind: "absent" };
-
-export function failed(reason: string): Outcome<never> {
-  return { kind: "failed", reason };
-}
-
-// [LAW:dataflow-not-control-flow] Total fold for consumers that only need a
-// value-or-fallback view (e.g. var-system's typed projection). Both non-ok
-// arms collapse to the fallback; consumers that must distinguish absent from
-// failed (the logging boundaries) match on `kind` instead.
-export function orElse<T>(outcome: Outcome<T> | undefined, fallback: T): T {
-  return outcome?.kind === "ok" ? outcome.value : fallback;
-}

package/src/utils/schema-validator.ts

@@ -1,126 +0,0 @@
-// [LAW:single-enforcer] All hookData schema validation flows through
-// validateHookData. One trust boundary, one check.
-//
-// [LAW:dataflow-not-control-flow] Every check runs unconditionally. Results
-// accumulate into a ValidationReport — callers decide what to do with them.
-// No early exits, no control-flow branches that skip checks.
-
-import type { ClaudeHookData } from "./claude";
-
-export interface ValidationReport {
-  // Required fields that were absent or had wrong types.
-  missingRequired: string[];
-  typeMismatches: Array<{ path: string; expected: string; got: string }>;
-  // Top-level keys not in the known schema — Anthropic may have added new fields.
-  unknownTopLevelFields: string[];
-}
-
-// Top-level keys Anthropic sends (plus hook_event_name, which cc-candybar adds).
-// Adding a new Anthropic field here suppresses the "unknown field" log for it.
-const KNOWN_TOP_LEVEL = new Set([
-  "hook_event_name", // cc-candybar internal
-  "session_id",
-  "session_name",
-  "transcript_path",
-  "cwd",
-  "model",
-  "workspace",
-  "version",
-  "output_style",
-  "cost",
-  "context_window",
-  "exceeds_200k_tokens",
-  "effort",
-  "thinking",
-  "rate_limits",
-  "vim",
-  "agent",
-  "worktree",
-]);
-
-// Required fields: [dot-separated path, expected typeof result]
-// "object" means non-null, non-array object. Checked in declaration order.
-const REQUIRED_FIELDS: Array<
-  [string, "string" | "number" | "boolean" | "object"]
-> = [
-  ["session_id", "string"],
-  ["transcript_path", "string"],
-  ["cwd", "string"],
-  ["model", "object"],
-  ["model.id", "string"],
-  ["model.display_name", "string"],
-  ["workspace", "object"],
-  ["workspace.current_dir", "string"],
-  ["workspace.project_dir", "string"],
-];
-
-/**
- * Validate raw hookData received over the wire against the known Anthropic schema.
- *
- * Returns the data typed as ClaudeHookData alongside a ValidationReport.
- * Never throws — divergences are reported, not thrown. The daemon decides
- * how to surface them (dlog warn/info).
- *
- * [LAW:no-defensive-null-guards] Validation at the trust boundary is correct.
- * Everywhere else in the codebase, hookData fields are used without guards
- * because this boundary guarantees their presence.
- */
-export function validateHookData(raw: unknown): {
-  data: ClaudeHookData;
-  report: ValidationReport;
-} {
-  const report: ValidationReport = {
-    missingRequired: [],
-    typeMismatches: [],
-    unknownTopLevelFields: [],
-  };
-
-  const obj: Record<string, unknown> =
-    raw !== null && typeof raw === "object" && !Array.isArray(raw)
-      ? (raw as Record<string, unknown>)
-      : {};
-
-  for (const [path, expectedType] of REQUIRED_FIELDS) {
-    const value = resolvePath(obj, path);
-    if (value === undefined || value === null) {
-      report.missingRequired.push(path);
-    } else {
-      const actualType = Array.isArray(value) ? "array" : typeof value;
-      const mismatch =
-        expectedType === "object"
-          ? actualType !== "object"
-          : actualType !== expectedType;
-      if (mismatch) {
-        report.typeMismatches.push({
-          path,
-          expected: expectedType,
-          got: actualType,
-        });
-      }
-    }
-  }
-
-  for (const key of Object.keys(obj)) {
-    if (!KNOWN_TOP_LEVEL.has(key)) {
-      report.unknownTopLevelFields.push(key);
-    }
-  }
-
-  return { data: raw as ClaudeHookData, report };
-}
-
-function resolvePath(obj: Record<string, unknown>, dotPath: string): unknown {
-  let cur: unknown = obj;
-  for (const key of dotPath.split(".")) {
-    if (
-      cur === null ||
-      cur === undefined ||
-      typeof cur !== "object" ||
-      Array.isArray(cur)
-    ) {
-      return undefined;
-    }
-    cur = (cur as Record<string, unknown>)[key];
-  }
-  return cur;
-}

package/src/utils/single-flight.ts

@@ -1,57 +0,0 @@
-// [LAW:one-source-of-truth] A keyed in-flight coalescer: while a computation
-// for a given key is running, every concurrent caller for that same key shares
-// the ONE in-flight promise instead of starting its own. The fs gate
-// (transcript-fs.ts) bounds how many fs ops run at once; it does NOT dedupe the
-// work — K concurrent renders each still launch their own (now-bounded)
-// whole-tree scan. This is the missing piece: K renders trigger ONE scan, not
-// K. The gate makes that one scan's cost bounded; this makes there be one.
-//
-// [LAW:types-are-the-program] Coalescing is expressed by ROUTING through one
-// owner of "is this key already computing", not by a guard scattered at each
-// callsite. The selection is dataflow — `inflight.get(key) ?? start(...)` —
-// both arms yield a `Promise<T>`, so the operation (return the shared promise)
-// always runs; only the value varies. There is no `if (alreadyRunning) return`
-// branch that skips work.
-//
-// Scope of sharing is exactly the in-flight WINDOW: the entry is removed when
-// the promise settles (success OR failure), so this is a coalescer, never a
-// cache. A fresh call after completion starts a new computation — staleness is
-// impossible because nothing is retained past settle. Result caching, when
-// wanted, is a separate concern owned by the caller (the disk/LRU caches).
-//
-// This also dissolves the render-timeout orphaning problem
-// (brandon-daemon-memory-leak-gn4.3): a render that abandons its await (the
-// daemon's 200ms response timeout fires) does not cancel or duplicate the
-// shared computation — there is only ever one scan in flight per key, so the
-// timed-out render leaves behind the single canonical computation that the next
-// render coalesces onto. A timeout therefore adds zero new fs work.
-export class SingleFlight {
-  private readonly inflight = new Map<string, Promise<unknown>>();
-
-  run<T>(key: string, factory: () => Promise<T>): Promise<T> {
-    return (
-      (this.inflight.get(key) as Promise<T> | undefined) ??
-      this.start(key, factory)
-    );
-  }
-
-  private start<T>(key: string, factory: () => Promise<T>): Promise<T> {
-    const promise = factory();
-    this.inflight.set(key, promise);
-    // Deregister on settle. The identity check guards the (impossible-by-key
-    // but cheap-to-prove) case where a newer promise has replaced this one:
-    // only the promise that registered itself clears itself.
-    const deregister = (): void => {
-      if (this.inflight.get(key) === promise) this.inflight.delete(key);
-    };
-    promise.then(deregister, deregister);
-    return promise;
-  }
-
-  // Number of computations currently in flight — a read-only observability
-  // surface for tests asserting the coalescing contract (one in-flight entry
-  // per key). Never read as control flow.
-  get size(): number {
-    return this.inflight.size;
-  }
-}

package/src/utils/terminal-width.ts

@@ -1,51 +0,0 @@
-// [LAW:single-enforcer] Terminal width has exactly one authoritative source:
-// the live client's shell context (env / ioctl), captured at the wire boundary
-// and threaded through as request data. This module is a pure resolver from
-// (caller-supplied hint, ambient env, stderr TTY) to "width with reserve
-// applied, or null." Subprocess-based fallbacks belong at the wire boundary,
-// not here. stderr (not stdout) is the TTY-side fallback: when this resolver
-// runs in a hook context, stdout is the captured statusline pipe while stderr
-// stays attached to the parent terminal.
-//
-// [LAW:dataflow-not-control-flow] The function always runs the same code path.
-// Variability lives in the inputs (hint set or not, env set or not, stderr a
-// TTY or not), never in whether work runs.
-
-// @info Reserves columns for Claude Code's statusline left gutter. Claude Code
-// prints each statusline row inset by a fixed left margin, so a row rendered at
-// the full raw column count would be shifted right past the terminal edge and
-// soft-wrap its trailing cells. The reserve is exactly that left margin — NOT a
-// right-side overlay budget. The version/autoupdate/"Remote Control" hints render
-// on their own right-aligned lines below the bar and never overlap a statusline
-// row, so they cost zero usable width here. Verified empirically against a live
-// Claude Code statusline (the older value of 45 was a guess for a right-side
-// overlay that does not sit on the statusline row); re-measure if Claude Code's
-// statusline gutter changes.
-const RESERVED_CHARS = 2;
-
-// [LAW:single-enforcer] The canonical raw-cols → usable-cols transform.
-// Every consumer that needs to honor Claude Code's statusline gutter routes
-// through here; there is no parallel `cols - N` math anywhere. Exposed so callers
-// that already have a raw width (e.g. the daemon's wire-fallback path,
-// the demo reading process.stdout.columns) can apply the reserve without
-// re-entering the env/stderr resolution chain in getTerminalWidth.
-export function applyClaudeCodeReserve(rawCols: number): number {
-  return Math.max(1, rawCols - RESERVED_CHARS);
-}
-
-export function getTerminalWidth(termColsHint?: number): number | null {
-  if (termColsHint && termColsHint > 0)
-    return applyClaudeCodeReserve(termColsHint);
-
-  const envColumns = process.env.COLUMNS;
-  if (envColumns) {
-    const parsed = parseInt(envColumns, 10);
-    if (!isNaN(parsed) && parsed > 0) return applyClaudeCodeReserve(parsed);
-  }
-
-  if (process.stderr.columns && process.stderr.columns > 0) {
-    return applyClaudeCodeReserve(process.stderr.columns);
-  }
-
-  return null;
-}

package/src/utils/terminal.ts

@@ -1,11 +0,0 @@
-export const ESC = String.fromCharCode(27);
-const ANSI_REGEX = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
-export const ANSI_SPLIT = new RegExp(`(${ESC}\\[[0-9;]*m)`);
-
-export function stripAnsi(str: string): string {
-  return str.replace(ANSI_REGEX, "");
-}
-
-export function visibleLength(str: string): number {
-  return stripAnsi(str).length;
-}