@heyhuynhgiabuu/pi-pretty 0.6.24 → 0.6.26

package/dist/working-indicator.js

@@ -0,0 +1,679 @@
+/**
+ * omp-style shimmer working indicator (widget takeover).
+ *
+ * Ports the shimmer sweep from oh-my-pi's `modes/theme/shimmer.ts`: the sweep
+ * is discretized into one pre-rendered frame per band position, cycled at
+ * 1000/30 ms so the band travels 30 cells/second — omp's exact speed.
+ *
+ * Why a widget: the host `Loader` extends `Text` with a hardcoded paddingX=1,
+ * and `setWorkingIndicator({ frames })` cannot change host component layout.
+ * To render the row flush-left we hide the host loader
+ * (`setWorkingVisible(false)`) and install our own zero-padding component via
+ * `setWidget(..., "aboveEditor")`, animating it with a 33ms interval.
+ *
+ * Frame layout: `<dim spinner> <shimmer text> <dim interrupt hint>`, one full
+ * sweep per phrase — `texts` rotates through phrases chapter by chapter with
+ * a continuous spinner phase.
+ */
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { FG_BLUE, FG_DIM, FG_MUTED } from "./config.js";
+import { dimAccentHex, hexToAnsiFg, sessionAccentHex } from "./session-color.js";
+// ─── Sweep tunables (oh-my-pi shimmer.ts) ────────────────────────────────────
+const CLASSIC_PADDING = 10;
+const CLASSIC_BAND_HALF_WIDTH = 6;
+const KITT_HEAD_HALF = 0.6;
+const KITT_TRAIL_LEN = 7;
+const TIER_HIGH = 0.65;
+const TIER_MID = 0.22;
+/** One cell per frame at 33ms = omp's 30 cells/second band speed. */
+export const WORKING_INTERVAL_MS = Math.round(1000 / 30);
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Spinner glyph advances every N frames (~99ms ≈ pi's default 80ms cadence). */
+const SPINNER_STEP = 3;
+const RESET_FG = "\x1b[39m";
+const BOLD_OPEN = "\x1b[1m";
+const BOLD_CLOSE = "\x1b[22m";
+const ITALIC_OPEN = "\x1b[3m";
+const ITALIC_CLOSE = "\x1b[23m";
+/** Fallback for pi's thinkingText tier when no theme is available. */
+const FG_THINKING_FALLBACK = "\x1b[38;2;148;148;184m";
+export const WORKING_INDICATOR_DEFAULTS = {
+    enabled: true,
+    texts: ["Working…"],
+    mode: "shimmer",
+    palette: { low: "dim", mid: "muted", high: "accent" },
+    bold: true,
+    hint: true,
+    sessionAccent: true,
+    tiersCustomized: false,
+};
+const MODES = ["shimmer", "kitt", "static"];
+function isMode(value) {
+    return typeof value === "string" && MODES.includes(value);
+}
+function envFlag(value) {
+    const v = value?.trim().toLowerCase();
+    if (!v)
+        return undefined;
+    if (v === "off" || v === "false" || v === "0")
+        return false;
+    if (v === "on" || v === "true" || v === "1")
+        return true;
+    return undefined;
+}
+/** Longest working label we build frames for (the sweep is one frame per code point + padding). */
+const MAX_TEXT_CODE_POINTS = 120;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what we sanitize out of user text
+const CONTROL_CHARS_RE = /[\u0000-\u001f\u007f]/;
+/**
+ * Accept a configured label only if it renders safely in the single-line
+ * working row: no control characters (including newlines) and bounded length.
+ * Returns undefined for anything invalid, falling back to the default.
+ */
+function sanitizeText(value) {
+    const text = typeof value === "string" ? value.trim() : undefined;
+    if (!text)
+        return undefined;
+    if (CONTROL_CHARS_RE.test(text))
+        return undefined;
+    if ([...text].length > MAX_TEXT_CODE_POINTS)
+        return undefined;
+    return text;
+}
+/** Sanitize a `string | string[]` config value into a valid phrase list. */
+function sanitizeTexts(input) {
+    const list = Array.isArray(input) ? input : [input];
+    const out = [];
+    for (const item of list) {
+        const text = sanitizeText(item);
+        if (text)
+            out.push(text);
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Resolve final settings from `pi-pretty.json`'s flat `workingIndicator` object
+ * and env overrides. Precedence: env var > config > default; empty or invalid
+ * env values mean unset (matching pi-pretty's config conventions).
+ */
+export function resolveWorkingIndicatorSettings(config, env = process.env) {
+    const settings = {
+        ...WORKING_INDICATOR_DEFAULTS,
+        palette: { ...WORKING_INDICATOR_DEFAULTS.palette },
+    };
+    const envEnabled = envFlag(env.PRETTY_WORKING_INDICATOR);
+    if (envEnabled !== undefined)
+        settings.enabled = envEnabled;
+    else if (typeof config?.enabled === "boolean")
+        settings.enabled = config.enabled;
+    const envMode = isMode(env.PRETTY_WORKING_INDICATOR_MODE) ? env.PRETTY_WORKING_INDICATOR_MODE : undefined;
+    settings.mode = envMode ?? (isMode(config?.mode) ? config.mode : settings.mode);
+    const envTexts = sanitizeTexts(env.PRETTY_WORKING_INDICATOR_TEXT?.split(",").map((part) => part.trim()));
+    settings.texts = envTexts ?? sanitizeTexts(config?.text) ?? settings.texts;
+    for (const tier of ["low", "mid", "high"]) {
+        const value = config?.[tier];
+        if (typeof value === "string" && value.trim() !== "")
+            settings.palette[tier] = value;
+    }
+    if (typeof config?.bold === "boolean")
+        settings.bold = config.bold;
+    if (typeof config?.hint === "boolean")
+        settings.hint = config.hint;
+    if (typeof config?.sessionAccent === "boolean")
+        settings.sessionAccent = config.sessionAccent;
+    settings.tiersCustomized = typeof config?.mid === "string" || typeof config?.high === "string";
+    return settings;
+}
+function colorToAnsi(value, theme, fallback) {
+    const hex = hexToAnsiFg(value);
+    if (hex)
+        return hex;
+    try {
+        // Pi's ThemeColor is a closed TS union, but getFgAnsi accepts any registered
+        // theme color at runtime; unknown names throw or return non-ANSI garbage,
+        // both handled below.
+        const getFgAnsi = theme?.getFgAnsi;
+        const viaTheme = getFgAnsi?.(value);
+        if (viaTheme?.startsWith("\x1b["))
+            return viaTheme;
+    }
+    catch {
+        // Unknown theme color name: fall through to the built-in constant.
+    }
+    return fallback;
+}
+/**
+ * Resolve tier colors to ANSI open sequences. `#rrggbb` wins, then the active
+ * pi theme (`getFgAnsi`), then pi-pretty's built-in constants.
+ */
+export function resolvePaletteAnsi(palette, theme) {
+    return {
+        low: colorToAnsi(palette.low, theme, FG_DIM),
+        mid: colorToAnsi(palette.mid, theme, FG_MUTED),
+        high: colorToAnsi(palette.high, theme, FG_BLUE),
+    };
+}
+function tierFor(intensity) {
+    if (intensity >= TIER_HIGH)
+        return "high";
+    if (intensity >= TIER_MID)
+        return "mid";
+    return "low";
+}
+/** Smooth cosine bump sweeping left → right with edge padding. */
+function classicIntensity(index, pos) {
+    const dist = Math.abs(index + CLASSIC_PADDING - pos);
+    if (dist >= CLASSIC_BAND_HALF_WIDTH)
+        return 0;
+    return 0.5 * (1 + Math.cos((Math.PI * dist) / CLASSIC_BAND_HALF_WIDTH));
+}
+/**
+ * Knight Rider K.I.T.T. scanner: a single bright head ping-pongs across the
+ * text with a quadratic-decay trail behind it (oh-my-pi shimmer.ts).
+ */
+function kittIntensity(index, head, goingRight) {
+    const delta = index - head;
+    if (Math.abs(delta) <= KITT_HEAD_HALF)
+        return 1;
+    const behind = goingRight ? -delta : delta;
+    if (behind <= KITT_HEAD_HALF)
+        return 0;
+    const t = (behind - KITT_HEAD_HALF) / KITT_TRAIL_LEN;
+    if (t >= 1)
+        return 0;
+    const f = 1 - t;
+    return f * f;
+}
+/** UTF-16 [start, end] index pairs per code point (surrogate-pair safe). */
+function codePointRanges(text) {
+    const ranges = [];
+    let i = 0;
+    while (i < text.length) {
+        const c = text.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length) {
+            const c2 = text.charCodeAt(i + 1);
+            if (c2 >= 0xdc00 && c2 <= 0xdfff) {
+                ranges.push([i, i + 2]);
+                i += 2;
+                continue;
+            }
+        }
+        ranges.push([i, i + 1]);
+        i += 1;
+    }
+    return ranges;
+}
+/**
+ * Build the frame list for the working row: one full sweep per phrase, in
+ * order, with the spinner phase running continuously across chapter
+ * boundaries. Same-tier runs share one ANSI pair (omp's run coalescing).
+ */
+export function buildWorkingFrames(texts, options) {
+    const intervalMs = options.intervalMs ?? WORKING_INTERVAL_MS;
+    const bold = options.bold ?? true;
+    const suffix = options.hint ?? "";
+    const withSpinner = options.spinner ?? true;
+    const spinnerColor = options.spinnerColor ?? options.ansi.low;
+    const highOpen = bold ? `${BOLD_OPEN}${options.ansi.high}` : options.ansi.high;
+    const highClose = bold ? `${BOLD_CLOSE}${RESET_FG}` : RESET_FG;
+    const seq = {
+        low: { open: options.ansi.low, close: RESET_FG },
+        mid: { open: options.ansi.mid, close: RESET_FG },
+        high: { open: highOpen, close: highClose },
+    };
+    const spinnerPrefix = (frameIndex) => {
+        if (!withSpinner)
+            return "";
+        const glyph = SPINNER_FRAMES[Math.floor(frameIndex / SPINNER_STEP) % SPINNER_FRAMES.length] ?? "";
+        return `${spinnerColor}${glyph}${RESET_FG} `;
+    };
+    const paintFrame = (text, ranges, tiers) => {
+        const total = ranges.length;
+        let out = "";
+        let runStart = 0;
+        let runTier = null;
+        const flush = (endIndex) => {
+            if (runTier === null || endIndex <= runStart)
+                return;
+            const s = seq[runTier];
+            out += `${s.open}${text.slice(ranges[runStart][0], ranges[endIndex - 1][1])}${s.close}`;
+        };
+        for (let i = 0; i < total; i++) {
+            if (tiers[i] !== runTier) {
+                flush(i);
+                runTier = tiers[i] ?? null;
+                runStart = i;
+            }
+        }
+        flush(total);
+        return options.italic ? `${ITALIC_OPEN}${out}${ITALIC_CLOSE}` : out;
+    };
+    const frames = [];
+    let spinnerIndex = 0;
+    for (const raw of texts) {
+        const text = raw.trim();
+        const ranges = codePointRanges(text);
+        const total = ranges.length;
+        if (total === 0)
+            continue;
+        if (options.mode === "static") {
+            // Static mode: one unanimated frame — only the first phrase renders.
+            frames.push(`${spinnerPrefix(spinnerIndex++)}${paintFrame(text, ranges, Array.from({ length: total }, () => "mid"))}${suffix}`);
+            return { frames, intervalMs };
+        }
+        if (options.mode === "kitt") {
+            const range = total - 1;
+            if (range <= 0) {
+                frames.push(`${spinnerPrefix(spinnerIndex++)}${paintFrame(text, ranges, Array.from({ length: total }, () => "high"))}${suffix}`);
+                continue;
+            }
+            const cycleCells = 2 * range;
+            for (let sweep = 0; sweep < cycleCells; sweep++) {
+                const goingRight = sweep < range;
+                const head = goingRight ? sweep : cycleCells - sweep;
+                const tiers = Array.from({ length: total }, (_, i) => tierFor(kittIntensity(i, head, goingRight)));
+                frames.push(`${spinnerPrefix(spinnerIndex++)}${paintFrame(text, ranges, tiers)}${suffix}`);
+            }
+        }
+        else {
+            const period = total + CLASSIC_PADDING * 2;
+            for (let pos = 0; pos < period; pos++) {
+                const tiers = Array.from({ length: total }, (_, i) => tierFor(classicIntensity(i, pos)));
+                frames.push(`${spinnerPrefix(spinnerIndex++)}${paintFrame(text, ranges, tiers)}${suffix}`);
+            }
+        }
+    }
+    return { frames, intervalMs };
+}
+/** Estimate streamed output tokens: provider `usage.output` when exposed, else visible chars ÷ 4. */
+export function workingTokens(message) {
+    const usage = message?.usage;
+    const output = Number(usage?.output);
+    if (Number.isFinite(output) && output > 0)
+        return Math.round(output);
+    const content = message
+        ?.content;
+    if (!Array.isArray(content))
+        return 0;
+    let chars = 0;
+    for (const block of content) {
+        if (block?.type === "text" && typeof block.text === "string")
+            chars += block.text.length;
+        else if (block?.type === "thinking" && typeof block.thinking === "string")
+            chars += block.thinking.length;
+    }
+    return Math.round(chars / 4);
+}
+/**
+ * Zero-padding working-row component. The host renders whatever `render()`
+ * returns with no margins, so the row sits flush-left — the thing the frames
+ * API could not do.
+ */
+export class WorkingWidget {
+    #frames = [];
+    #index = 0;
+    #intervalMs = WORKING_INTERVAL_MS;
+    #interval;
+    #tui;
+    #started = false;
+    #disposed = false;
+    #stats;
+    setFrames(frames, intervalMs) {
+        this.#frames = frames;
+        this.#intervalMs = intervalMs;
+        this.#index = 0;
+    }
+    attach(tui) {
+        this.#tui = tui;
+    }
+    /** Ask the host for a render — lets non-widget consumers (the thinking label
+     * ticker) reuse this widget's TUI handle instead of relying on natural
+     * streaming renders. */
+    requestRender() {
+        this.#tui?.requestRender();
+    }
+    /** Dynamic right-side status segment (e.g. live token count), styled dim at
+     * render time so theme changes don't bake stale ANSI into it. */
+    setStats(text) {
+        this.#stats = text || undefined;
+    }
+    start() {
+        if (this.#disposed || this.#started)
+            return;
+        this.#started = true;
+        this.#index = 0;
+        // A single frame has nothing to cycle — skip the 30fps render churn.
+        if (this.#frames.length <= 1)
+            return;
+        this.#interval = setInterval(() => {
+            this.#index = (this.#index + 1) % Math.max(1, this.#frames.length);
+            this.#tui?.requestRender();
+        }, this.#intervalMs);
+    }
+    stop() {
+        this.#started = false;
+        if (this.#interval) {
+            clearInterval(this.#interval);
+            this.#interval = undefined;
+        }
+    }
+    /** Flush-left single line; invisible (no lines) while stopped. */
+    render(width) {
+        if (!this.#started || this.#frames.length === 0)
+            return [];
+        const frame = this.#frames[this.#index % this.#frames.length] ?? "";
+        const suffix = this.#stats ? `${FG_DIM}${this.#stats}${RESET_FG}` : "";
+        return [truncateToWidth(frame + suffix, Math.max(1, width))];
+    }
+    invalidate() {
+        // Stateless per render — nothing to invalidate.
+    }
+    dispose() {
+        this.stop();
+        this.#disposed = true;
+    }
+}
+export const THINKING_INDICATOR_DEFAULTS = { enabled: true };
+/**
+ * Resolve thinking-label shimmer settings from `pi-pretty.json`'s
+ * `thinkingIndicator` object and env overrides (env > config > default).
+ */
+export function resolveThinkingIndicatorSettings(config, env = process.env) {
+    const settings = { ...THINKING_INDICATOR_DEFAULTS };
+    const envEnabled = envFlag(env.PRETTY_THINKING_INDICATOR);
+    if (envEnabled !== undefined)
+        settings.enabled = envEnabled;
+    else if (typeof config?.enabled === "boolean")
+        settings.enabled = config.enabled;
+    return settings;
+}
+const PER_ROW_PATCH = Symbol.for("pi-pretty.per-row-thinking-labels");
+/**
+ * Intercept the host's per-row label fan-out method
+ * (`AssistantMessageComponent.prototype.setHiddenThinkingLabel`): each row
+ * substitutes the incoming global label with its own — the streaming row
+ * animates, completed rows stay frozen at their own `Thought for Xs`, unknown
+ * rows fall back to pi's default. Any per-call failure passes the incoming
+ * label through unchanged, so a host internals change degrades to pi-pretty's
+ * global-label behavior instead of breaking. Durations live per session.
+ */
+export function installPerRowThinkingLabels(componentClass) {
+    const proto = componentClass?.prototype;
+    const original = proto?.setHiddenThinkingLabel;
+    if (typeof componentClass !== "function" || !proto || typeof original !== "function")
+        return undefined;
+    const existing = original[PER_ROW_PATCH];
+    // Reuse the installed patch but start from clean state: a session_start
+    // without an intervening shutdown (defensive) must not resurrect stale rows.
+    if (existing) {
+        existing.clearActive();
+        return existing;
+    }
+    const state = { completed: new Map() };
+    const patched = function (label) {
+        const own = ownLabel(this, label);
+        original.call(this, own);
+    };
+    const ownLabel = (component, incoming) => {
+        try {
+            const ts = component?.lastMessage?.timestamp;
+            if (typeof ts !== "number")
+                return incoming;
+            if (ts === state.activeTs)
+                return incoming;
+            const ms = state.completed.get(ts);
+            return ms === undefined ? THINKING_LABEL : `Thought for ${formatThinkingDuration(ms)}`;
+        }
+        catch {
+            return incoming;
+        }
+    };
+    const controller = {
+        setActive(timestamp) {
+            state.activeTs = timestamp;
+        },
+        complete(timestamp, durationMs) {
+            state.completed.set(timestamp, durationMs);
+        },
+        clearActive() {
+            state.activeTs = undefined;
+        },
+        uninstall() {
+            if (proto.setHiddenThinkingLabel === patched) {
+                proto.setHiddenThinkingLabel = original;
+            }
+            state.completed.clear();
+            state.activeTs = undefined;
+        },
+    };
+    patched[PER_ROW_PATCH] = controller;
+    proto.setHiddenThinkingLabel = patched;
+    return controller;
+}
+const THINKING_LABEL = "Thinking...";
+/** Format elapsed milliseconds as whole seconds with compact padded units. */
+export function formatThinkingDuration(elapsedMs) {
+    const totalSeconds = Math.floor(elapsedMs / 1000);
+    const seconds = totalSeconds % 60;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
+    if (hours > 0)
+        return `${hours}h ${String(minutes).padStart(2, "0")}m ${String(seconds).padStart(2, "0")}s`;
+    if (totalMinutes > 0)
+        return `${totalMinutes}m ${String(seconds).padStart(2, "0")}s`;
+    return `${seconds}s`;
+}
+/**
+ * Couple elapsed-time wording to the label animator through an injected clock.
+ * The timer starts on the first thinking delta, freezes once, and is terminal
+ * after completion or restore. `startElapsedMs` resumes a later run in the
+ * same message from its accumulated thinking time (per-message semantics:
+ * the host renders one label line per thinking run, all sharing the message
+ * label, so a fresh-zero restart would visibly rewind earlier lines).
+ */
+export function createThinkingTimer(animator, now = Date.now, startElapsedMs = 0) {
+    const startedAt = now() - startElapsedMs;
+    let terminal = false;
+    const elapsed = () => now() - startedAt;
+    const duration = () => formatThinkingDuration(elapsed());
+    return {
+        tick() {
+            if (terminal)
+                return;
+            animator.tick(`${THINKING_LABEL} ${duration()}`);
+        },
+        complete() {
+            if (terminal)
+                return undefined;
+            terminal = true;
+            const ms = elapsed();
+            animator.show(`Thought for ${formatThinkingDuration(ms)}`);
+            return ms;
+        },
+        restore() {
+            terminal = true;
+            animator.restore();
+        },
+    };
+}
+/**
+ * True while a streaming assistant message is currently emitting a thinking
+ * block (its last content block). Used to gate label ticks to the thinking
+ * phase — once text or tool calls stream, the label is frozen back to pi's
+ * default instead of rebuilding the transcript for a row nobody watches.
+ */
+export function thinkingBlockActive(message) {
+    const content = message?.content;
+    if (!Array.isArray(content) || content.length === 0)
+        return false;
+    return content[content.length - 1]?.type === "thinking";
+}
+/**
+ * Animate pi's hidden-thinking label ("Thinking...") with the same shimmer as
+ * the working row. Pi renders the label as static italic `thinkingText` text;
+ * the only extension lever is `setHiddenThinkingLabel(label)`, which rebuilds
+ * chat children, so index.ts drives it at 30fps only while the streaming
+ * message's last block is thinking. The elapsed label is rebuilt only when its
+ * whole-second text changes; the shimmer frame still advances every tick.
+ *
+ * Tiers: low = theme `thinkingText` (pi's own label look), mid/high = session
+ * accent when enabled; every frame is italic like pi's label; no spinner.
+ */
+export function createThinkingLabelAnimator(ui, workSettings, sessionName, thinking) {
+    const noop = {
+        tick() { },
+        show() { },
+        restore() { },
+        frames: [],
+    };
+    if (thinking && !thinking.enabled)
+        return noop;
+    if (typeof ui.setHiddenThinkingLabel !== "function")
+        return noop;
+    const ansiResolved = resolvePaletteAnsi(workSettings.palette, ui.theme);
+    let ansi = {
+        ...ansiResolved,
+        low: colorToAnsi("thinkingText", ui.theme, FG_THINKING_FALLBACK),
+    };
+    if (workSettings.sessionAccent && sessionName && !workSettings.tiersCustomized) {
+        const accent = hexToAnsiFg(sessionAccentHex(sessionName));
+        if (accent)
+            ansi = { ...ansi, mid: accent, high: accent };
+    }
+    const buildLabelFrames = (label) => buildWorkingFrames([label], {
+        mode: workSettings.mode,
+        ansi,
+        bold: workSettings.bold,
+        spinner: false,
+        italic: true,
+    }).frames;
+    let currentLabel = THINKING_LABEL;
+    let frames = buildLabelFrames(currentLabel);
+    let index = 0;
+    let appliedLabel;
+    return {
+        get frames() {
+            return frames;
+        },
+        tick(label = THINKING_LABEL) {
+            if (label !== currentLabel) {
+                frames = buildLabelFrames(label);
+                currentLabel = label;
+            }
+            // A static frame changes only when its elapsed-time label changes.
+            if (appliedLabel === currentLabel && frames.length === 1)
+                return;
+            ui.setHiddenThinkingLabel(frames[index % frames.length]);
+            index++;
+            appliedLabel = currentLabel;
+        },
+        show(label) {
+            ui.setHiddenThinkingLabel(label);
+        },
+        restore() {
+            // undefined → pi falls back to its default static label.
+            ui.setHiddenThinkingLabel(undefined);
+        },
+    };
+}
+const WIDGET_KEY = "pi-pretty-working";
+async function loadHostKeybindings() {
+    try {
+        const tui = (await import("@earendil-works/pi-tui"));
+        return tui.getKeybindings?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatKeyText(keys) {
+    const darwin = process.platform === "darwin";
+    return keys
+        .join("/")
+        .split("/")
+        .map((key) => key
+        .split("+")
+        .map((part) => (darwin && part.toLowerCase() === "alt" ? "option" : part))
+        .join("+"))
+        .join("/");
+}
+async function resolveHint(ui, deps) {
+    try {
+        const loader = deps?.getKeybindings ?? loadHostKeybindings;
+        const keybindings = await loader();
+        const keys = keybindings?.getKeys?.("app.interrupt");
+        if (!keys?.length)
+            return undefined;
+        const text = ` (${formatKeyText(keys)} to interrupt)`;
+        return ui.theme?.fg ? ui.theme.fg("dim", text) : text;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Take over pi's working row with our own flush-left shimmer widget.
+ *
+ * Installs a zero-padding component above the editor and hides the host
+ * loader; returns a controller the host lifecycle drives (`start` on
+ * agent_start, `stop` on agent_end). No-op (host defaults untouched) when
+ * disabled or the phrase list is empty.
+ */
+export async function installWorkingIndicator(ui, settings, deps, sessionName) {
+    const noopController = {
+        start() { },
+        stop() { },
+        dispose() { },
+        setStats() { },
+        requestRender() { },
+        frames: [],
+    };
+    if (!settings.enabled)
+        return noopController;
+    const texts = settings.texts.map((t) => t.trim()).filter((t) => t.length > 0);
+    if (texts.length === 0)
+        return noopController;
+    const ansiResolved = resolvePaletteAnsi(settings.palette, ui.theme);
+    let ansi = ansiResolved;
+    let spinnerColor;
+    if (settings.sessionAccent && sessionName && !settings.tiersCustomized) {
+        const accentHex = sessionAccentHex(sessionName);
+        const accent = hexToAnsiFg(accentHex);
+        if (accent) {
+            ansi = { ...ansi, mid: accent, high: accent };
+            spinnerColor = hexToAnsiFg(dimAccentHex(accentHex));
+        }
+    }
+    const hint = settings.hint ? await resolveHint(ui, deps) : undefined;
+    const { frames, intervalMs } = buildWorkingFrames(texts, {
+        mode: settings.mode,
+        ansi,
+        bold: settings.bold,
+        spinnerColor,
+        hint,
+    });
+    if (frames.length === 0)
+        return noopController;
+    const widget = new WorkingWidget();
+    widget.setFrames(frames, intervalMs);
+    // Widget first, visibility second: if setWidget throws (older host without
+    // the API) the host loader was never hidden and pi's default remains.
+    ui.setWidget(WIDGET_KEY, (tui) => {
+        widget.attach(tui);
+        return widget;
+    }, { placement: "aboveEditor" });
+    ui.setWorkingVisible(false);
+    return {
+        start: () => widget.start(),
+        stop: () => widget.stop(),
+        dispose: () => {
+            widget.dispose();
+            ui.setWidget(WIDGET_KEY, undefined);
+        },
+        setStats: (text) => widget.setStats(text),
+        requestRender: () => widget.requestRender(),
+        frames,
+    };
+}
+//# sourceMappingURL=working-indicator.js.map