@askdkc/dsh-cli 0.11.3

package/lib/types/components/Tooltip.js

@@ -0,0 +1,266 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import stripAnsi from 'strip-ansi';
+import { Box, Text, useTerminalSize } from '../ui.js';
+import { useTerminalFocus } from '../ink/hooks/use-terminal-focus.js';
+import { useSelection } from '../ink/hooks/use-selection.js';
+import { hasSelection } from '../ink/selection.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { getGraphemeSegmenter } from '../utils/intl.js';
+import { PageInsetContext } from './PageMargin.js';
+/**
+ * Tooltip hover system — the terminal equivalent of the HTML `title`
+ * attribute. Attach {@link useTooltip} props to any Box whose visible text
+ * may be truncated (tool-call header paths, wrapped prompts, status-line
+ * fields); after a ~600ms dwell the full content pops up in a floating card
+ * anchored at the pointer, and disappears the moment the pointer leaves.
+ *
+ * Attach it ONLY when the text is actually hidden: a float that repeats
+ * content already visible next to the pointer is noise, not detail (the
+ * tool-call header gates on folded/clipped content for this reason).
+ *
+ * Tooltips and text selection are mutually exclusive: a drag-copy reads the
+ * painted screen, and the card REPLACES the cells it covers, so
+ * {@link TooltipLayer} hides all tooltips while a selection drag or an
+ * active selection exists (see its subscription on selection mutations).
+ *
+ * Hover events only exist in fullscreen (alternate screen + mouse
+ * tracking); inline mode never fires the handlers, so the store can only
+ * be written from a live fullscreen tree.
+ */
+/** Default dwell before the tooltip appears (GUI `title` convention). */
+const DEFAULT_TOOLTIP_DELAY_MS = 600;
+// Module-level store (the `src/ink/instances.ts` single-instance pattern):
+// writers are the hover handlers, the single reader is TooltipLayer.
+let state = null;
+let invalidationGeneration = 0;
+const listeners = new Set();
+function notify() {
+    for (const listener of listeners)
+        listener();
+}
+/** Subscribe to tooltip show/hide; returns an unsubscribe function. */
+export function subscribeTooltip(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** Stable snapshot for useSyncExternalStore (identity kept until changed). */
+export function getTooltipSnapshot() {
+    return state;
+}
+function showTooltip(owner, col, row, content) {
+    state = { owner, anchorCol: col, anchorRow: row, content };
+    notify();
+}
+function hideTooltip(owner) {
+    if (state !== null && state.owner === owner) {
+        state = null;
+        notify();
+    }
+}
+/** Hide shown content and invalidate every pending dwell timer. */
+export function clearTooltip() {
+    invalidationGeneration++;
+    if (state !== null) {
+        state = null;
+        notify();
+    }
+}
+/**
+ * Hover props that pop a tooltip with the full content after a dwell.
+ *
+ * The pointer position (screen col/row) is taken from the PointerEvent the
+ * renderer hands to `onMouseEnter` — the runtime always passes one even
+ * though the prop type is `() => void`, which is why the handler's parameter
+ * is optional (a `() => void` prop accepts a function with only optional
+ * parameters).
+ */
+export function useTooltip(content, opts) {
+    const ownerRef = React.useRef(null);
+    if (ownerRef.current === null)
+        ownerRef.current = { timer: null };
+    const owner = ownerRef.current;
+    // Resolve function content at show time so callers can pass getters that
+    // read live channel state without re-binding the handlers.
+    const contentRef = React.useRef(content);
+    contentRef.current = content;
+    const delayMs = opts?.delayMs ?? DEFAULT_TOOLTIP_DELAY_MS;
+    React.useEffect(() => () => {
+        // Unmount clears our pending timer and our tooltip — a screen swap must
+        // not leave a ghost anchored to geometry that no longer exists.
+        if (owner.timer !== null)
+            clearTimeout(owner.timer);
+        hideTooltip(owner);
+    }, [owner]);
+    return React.useMemo(() => ({
+        onMouseEnter: (event) => {
+            const col = event?.col ?? 0;
+            const row = event?.row ?? 0;
+            if (owner.timer !== null)
+                clearTimeout(owner.timer);
+            const generationAtEnter = invalidationGeneration;
+            owner.timer = setTimeout(() => {
+                owner.timer = null;
+                if (generationAtEnter !== invalidationGeneration)
+                    return;
+                const resolved = typeof contentRef.current === 'function'
+                    ? contentRef.current()
+                    : contentRef.current;
+                if (resolved === '')
+                    return;
+                showTooltip(owner, col, row, resolved);
+            }, delayMs);
+        },
+        onMouseLeave: () => {
+            if (owner.timer !== null) {
+                clearTimeout(owner.timer);
+                owner.timer = null;
+            }
+            hideTooltip(owner);
+        },
+    }), [owner, delayMs]);
+}
+/**
+ * Convenience wrapper for list rows built from data (a component boundary
+ * makes the hook call legal per item). Renders a plain Box carrying the
+ * hover props around `children`.
+ */
+export function TooltipTarget({ content, children, }) {
+    const hover = useTooltip(content);
+    return _jsx(Box, { ...hover, children: children });
+}
+/**
+ * The singleton floating layer: subscribes to the tooltip store and renders
+ * the rounded card above the anchor row (below it when there is no room),
+ * horizontally clamped inside the terminal. Mount once, LAST in the tree so
+ * it paints over everything else. Terminal resize hides the tooltip — its
+ * anchor is screen geometry that just went stale.
+ */
+export function TooltipLayer({ invalidationKey, subscribeInvalidation, } = {}) {
+    const { columns, rows } = useTerminalSize();
+    const terminalFocused = useTerminalFocus();
+    const tooltip = React.useSyncExternalStore(subscribeTooltip, getTooltipSnapshot);
+    // A text selection and a floating tooltip are mutually exclusive: the copy
+    // reads the PAINTED screen, and the tooltip card REPLACES the cells of the
+    // text it covers — dragging across a shown tooltip (or letting one pop
+    // mid-drag via its dwell timer) puts the tooltip fragment in the clipboard
+    // instead of the message text. Every selection mutation (drag start, each
+    // motion event, release, clear) funnels through this notification, so the
+    // layer goes dark the instant a drag begins and stays dark until the
+    // selection settles. The render guard below is belt-and-suspenders: a
+    // dwell that fires between two motion events must still never paint.
+    const selection = useSelection();
+    const selectionBusy = React.useSyncExternalStore(selection.subscribe, () => {
+        const state = selection.getState();
+        return state !== null && (state.isDragging || hasSelection(state));
+    }, () => false);
+    React.useEffect(() => {
+        return selection.subscribe(() => {
+            // Every selection mutation (drag start, motion, release, clear) resets
+            // the tooltip system wholesale: while busy the card must never paint,
+            // and the settle must also invalidate dwell timers armed while dark,
+            // so a finished copy is not immediately followed by a surprise card.
+            clearTooltip();
+        });
+    }, [selection]);
+    // Remounts and modal/screen transitions invalidate shown AND pending tips.
+    React.useEffect(() => {
+        clearTooltip();
+    }, [invalidationKey]);
+    React.useEffect(() => {
+        if (!terminalFocused)
+            clearTooltip();
+    }, [terminalFocused]);
+    React.useEffect(() => {
+        if (subscribeInvalidation === undefined)
+            return;
+        return subscribeInvalidation(clearTooltip);
+    }, [subscribeInvalidation]);
+    const prevSize = React.useRef({ columns, rows });
+    React.useEffect(() => {
+        if (prevSize.current.columns !== columns || prevSize.current.rows !== rows) {
+            prevSize.current = { columns, rows };
+            clearTooltip();
+        }
+    }, [columns, rows]);
+    if (tooltip === null)
+        return null;
+    // Never paint over an active drag/selection (see the subscription above).
+    if (selectionBusy)
+        return null;
+    // A bordered card needs at least one content cell plus two border cells.
+    // Below that, hiding is safer than creating geometry wider/taller than the
+    // terminal (Yoga would clip unpredictably on 1–2 column/row resize states).
+    if (columns < 3 || rows < 3)
+        return null;
+    const maxWidth = Math.max(3, columns - 4);
+    // Grapheme-aware wrap consistent with PromptInput's wrapToWidth: code-point
+    // iteration splits ZWJ emoji and combining sequences across rows, leaving
+    // broken halves at the row edges. Newlines are honoured like wrapWidth.
+    let lines = wrapTooltipContent(tooltip.content, maxWidth - 2);
+    // A tooltip taller than the terminal is useless; keep the head.
+    const maxLines = Math.max(1, rows - 2);
+    if (lines.length > maxLines)
+        lines = lines.slice(0, maxLines);
+    const innerWidth = Math.min(maxWidth - 2, Math.max(1, ...lines.map(stringWidth)));
+    const width = innerWidth + 2;
+    const height = lines.length + 2;
+    // Prefer resting on the row ABOVE the anchor; when there is no room
+    // (anchor at the top of the screen), drop below it, clamped on-screen.
+    // The anchor is SCREEN geometry (pointer events) while the absolute box is
+    // placed relative to the inset content-area origin, and useTerminalSize()
+    // already reports the content size: convert the anchor into content
+    // coordinates first, then clamp inside the content area. Adding the inset
+    // (the earlier bug) moved the whole card by the page margin — with the
+    // default margin one row low and two columns right, so its bottom border
+    // landed ON the hovered row and that row's glyphs showed beside the card.
+    const inset = React.useContext(PageInsetContext);
+    const anchorRow = tooltip.anchorRow - inset.y;
+    const anchorCol = tooltip.anchorCol - inset.x;
+    const topAbove = anchorRow - height;
+    const top = Math.max(0, Math.min(topAbove >= 0 ? topAbove : anchorRow + 1, Math.max(0, rows - height)));
+    const left = Math.max(0, Math.min(anchorCol, Math.max(0, columns - width)));
+    return (_jsx(Box, { position: "absolute", left: left, top: top, width: width, height: height, flexDirection: "column", flexShrink: 0, borderStyle: "round", borderColor: "permission", backgroundColor: "toolCardBackground", children: lines.map((line, index) => (_jsx(Text, { wrap: "truncate-end", children: line === '' ? ' ' : line }, index))) }));
+}
+/**
+ * Wrap tooltip content to display width, breaking only BETWEEN grapheme
+ * clusters (ZWJ emoji, combining sequences and CJK wide cells stay whole).
+ * Newlines in the input are honoured. Mirrors PromptInput.wrapToWidth's
+ * break rule so the tooltip shows exactly the text the input would wrap.
+ */
+function wrapTooltipContent(text, width) {
+    const rows = [];
+    if (width <= 0)
+        return rows;
+    // Tooltip content is display-only: remove ANSI/C0 controls before grapheme
+    // segmentation so a CSI sequence cannot be split and counted as visible
+    // columns. Newlines remain structural; tabs become deterministic spaces.
+    text = stripAnsi(text)
+        .replace(/\t/gu, '        ')
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, '');
+    const segmenter = getGraphemeSegmenter();
+    for (const line of text.split('\n')) {
+        if (line === '') {
+            rows.push('');
+            continue;
+        }
+        let current = '';
+        let used = 0;
+        for (const { segment } of segmenter.segment(line)) {
+            const w = stringWidth(segment);
+            if (used + w > width && current !== '') {
+                rows.push(current);
+                current = segment;
+                used = w;
+            }
+            else {
+                current += segment;
+                used += w;
+            }
+        }
+        rows.push(current);
+    }
+    return rows;
+}

package/lib/types/components/TurnInterruptedRow.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+ * The dim "interrupted" row shown when the user stops a turn.
+ */
+export declare function TurnInterruptedRow(): React.ReactNode;
+//# sourceMappingURL=TurnInterruptedRow.d.ts.map

package/lib/types/components/TurnInterruptedRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurnInterruptedRow.d.ts","sourceRoot":"","sources":["../../../src/components/TurnInterruptedRow.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,KAAK,CAAC,SAAS,CAOpD"}

package/lib/types/components/TurnInterruptedRow.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from '../ui.js';
+import { t } from '../i18n.js';
+/**
+ * The dim "interrupted" row shown when the user stops a turn.
+ */
+export function TurnInterruptedRow() {
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: t('interrupted-by-user') }), _jsx(Text, { dimColor: true, children: t('interrupted-ask-next') })] }));
+}

package/lib/types/components/Whale.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { type WhaleLayerPose } from './whaleLayers.js';
+/**
+ * The DeepSeek pixel whale from the hand-drawn Excel art (whale_frames.zip):
+ * a 40×25 sprite in six true-color tones (deep-navy outline, DeepSeek-blue
+ * body, ice-blue belly, white mouth, pink heart, gray sleep-Z). Rendered
+ * with the half-block technique — each terminal cell packs two vertical
+ * pixels into one `▀`/`▄` glyph (foreground = upper pixel, background =
+ * lower), so the whale shows at 40 columns × 13 rows with visually square
+ * pixels.
+ */
+type Rgb = readonly [number, number, number];
+/**
+ * Render one frame to ANSI rows (one per sprite row pair) under its own
+ * palette. Consecutive cells sharing one style are run-length encoded; every
+ * row spans the full sprite width (transparent cells write plain spaces, so
+ * the blank cells of a diff region are re-output and overwrite whatever the
+ * previous frame painted there), and each row closes with an erase-to-EOL:
+ * the text pipeline may trim trailing whitespace, and the erase guarantees
+ * the terminal itself clears every cell past the row's last glyph — no
+ * ghost pixels can survive a frame switch.
+ */
+export declare function renderSpriteRows(sprite: readonly string[], palette: Record<string, Rgb | undefined>): string[];
+/** Render one composed pose (body + action layers) to ANSI rows, cached. */
+export declare function layeredWhaleRows(pose: WhaleLayerPose): string[];
+/** Index of the `standard` frame — the settled header's static pose. */
+export declare const STANDARD_FRAME_INDEX = 0;
+/**
+ * One whale pose as an Ink component: 13 rows × 40 columns, never
+ * shrinking. Pass `frameIndex` from the opening sequence while animating, or
+ * STANDARD_FRAME_INDEX for the static header whale. `width` pins the box
+ * width so the neighbouring text column never shifts when frames widen
+ * (the tail-wag frames reach 4 columns further right than standard).
+ */
+export declare function WhaleArt({ frameIndex, pose, width, }: {
+    frameIndex?: number;
+    /** Layered pose (parallel actions composited); wins over `frameIndex`. */
+    pose?: WhaleLayerPose;
+    width?: number;
+}): React.ReactNode;
+export {};
+//# sourceMappingURL=Whale.d.ts.map

package/lib/types/components/Whale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Whale.d.ts","sourceRoot":"","sources":["../../../src/components/Whale.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,EAA6B,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEjF;;;;;;;;GAQG;AAEH,KAAK,GAAG,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAoB5C;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,SAAS,CAAC,GAAG,MAAM,EAAE,CA2C9G;AAWD,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,EAAE,CAO/D;AAGD,wEAAwE;AACxE,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAErC;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EACvB,UAAiC,EACjC,IAAI,EACJ,KAAK,GACN,EAAE;IACD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,KAAK,CAAC,SAAS,CAWlB"}

package/lib/types/components/Whale.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from '../ui.js';
+import { WHALE_FRAMES } from './whaleFrames.js';
+import { composeWhaleGrid, poseKey } from './whaleLayers.js';
+/** Sprite palette: D outline · B body · L belly · W mouth · H heart · Z sleep-Z · `.` transparent. */
+const PALETTE = {
+    D: [20, 38, 96],
+    B: [78, 111, 255],
+    L: [190, 225, 255],
+    W: [255, 255, 255],
+    H: [204, 51, 153],
+    Z: [128, 128, 128],
+};
+const fg = (rgb) => `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+const bg = (rgb) => `\x1b[48;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+const RESET = '\x1b[0m';
+/** Erase from the cursor to the end of the physical line (default colors). */
+const ERASE_TO_EOL = '\x1b[K';
+/** Reset the background plane to the terminal default (fg keeps its SGR). */
+const BG_DEFAULT = '\x1b[49m';
+/**
+ * Render one frame to ANSI rows (one per sprite row pair) under its own
+ * palette. Consecutive cells sharing one style are run-length encoded; every
+ * row spans the full sprite width (transparent cells write plain spaces, so
+ * the blank cells of a diff region are re-output and overwrite whatever the
+ * previous frame painted there), and each row closes with an erase-to-EOL:
+ * the text pipeline may trim trailing whitespace, and the erase guarantees
+ * the terminal itself clears every cell past the row's last glyph — no
+ * ghost pixels can survive a frame switch.
+ */
+export function renderSpriteRows(sprite, palette) {
+    const rows = [];
+    for (let r = 0; r < sprite.length; r += 2) {
+        const upper = sprite[r];
+        const lower = sprite[r + 1] ?? '';
+        let out = '';
+        let current = '';
+        for (let x = 0; x < upper.length; x++) {
+            const up = palette[upper[x]];
+            const lo = palette[lower[x]];
+            let seq;
+            let ch;
+            if (up !== undefined && lo !== undefined) {
+                seq = fg(up) + bg(lo);
+                ch = '▀';
+            }
+            else if (up !== undefined) {
+                // Half-filled cell: the empty half must show the terminal's default
+                // background, and SGR persists across cells — a bg left over from
+                // the previous cell would paint a phantom pixel into the empty half
+                // (the contour noise of the sprite). Reset it explicitly.
+                seq = fg(up) + BG_DEFAULT;
+                ch = '▀';
+            }
+            else if (lo !== undefined) {
+                seq = fg(lo) + BG_DEFAULT;
+                ch = '▄';
+            }
+            else {
+                seq = '';
+                ch = ' ';
+            }
+            if (seq !== current) {
+                out += seq === '' ? RESET : seq;
+                current = seq;
+            }
+            out += ch;
+        }
+        // Always close the row's style — a row ending on a colored cell would
+        // otherwise leak its SGR into the line's remaining padding — then append
+        // the erase pass (see the doc above).
+        let row = out;
+        if (!row.endsWith(RESET))
+            row += RESET;
+        rows.push(row + ERASE_TO_EOL);
+    }
+    return rows;
+}
+/** Pre-rendered ANSI rows for every whale frame, computed once at module load. */
+const RENDERED = WHALE_FRAMES.map(frame => renderSpriteRows(frame.rows, PALETTE));
+/**
+ * Layered-pose render cache: composed grids are pure functions of the pose,
+ * and idle ticks repaint the same handful of poses thousands of times.
+ */
+const LAYERED_CACHE = new Map();
+/** Render one composed pose (body + action layers) to ANSI rows, cached. */
+export function layeredWhaleRows(pose) {
+    const key = poseKey(pose);
+    const cached = LAYERED_CACHE.get(key);
+    if (cached !== undefined)
+        return cached;
+    const rows = renderSpriteRows(composeWhaleGrid(pose).map(row => row.join('')), PALETTE);
+    LAYERED_CACHE.set(key, rows);
+    return rows;
+}
+/** Index of the `standard` frame — the settled header's static pose. */
+export const STANDARD_FRAME_INDEX = 0;
+/**
+ * One whale pose as an Ink component: 13 rows × 40 columns, never
+ * shrinking. Pass `frameIndex` from the opening sequence while animating, or
+ * STANDARD_FRAME_INDEX for the static header whale. `width` pins the box
+ * width so the neighbouring text column never shifts when frames widen
+ * (the tail-wag frames reach 4 columns further right than standard).
+ */
+export function WhaleArt({ frameIndex = STANDARD_FRAME_INDEX, pose, width, }) {
+    const rows = pose !== undefined ? layeredWhaleRows(pose) : RENDERED[frameIndex] ?? RENDERED[STANDARD_FRAME_INDEX];
+    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, width: width, children: rows.map((row, index) => (_jsx(Text, { wrap: "truncate-end", children: row }, index))) }));
+}

package/lib/types/components/WorkingSpinner.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { SpinnerMode } from './Spinner/spinnerMode.js';
+/**
+ * The working spinner block shown between the transcript and the prompt
+ * input while a turn is in flight. The channel feeds the mode, token count,
+ * and thinking status while this component owns the compact presentation.
+ *
+ * Random verb is picked once per turn (per mount of the spinner).
+ */
+export declare function WorkingSpinner({ mode, hasActiveTools, responseLengthRef, uploadTokensRef, loadingStartTimeRef, totalPausedMsRef, pauseStartTimeRef, thinkingStatus, }: {
+    mode: SpinnerMode;
+    hasActiveTools: boolean;
+    responseLengthRef: React.RefObject<number>;
+    /** Most recent request's real upload tokens; 0 until the first usage event. */
+    uploadTokensRef: React.RefObject<number>;
+    loadingStartTimeRef: React.RefObject<number>;
+    totalPausedMsRef: React.RefObject<number>;
+    pauseStartTimeRef: React.RefObject<number | null>;
+    thinkingStatus: 'thinking' | number | null;
+}): React.ReactNode;
+/**
+ * Tracks thinking status: 'thinking' while the model is streaming reasoning,
+ * then the duration in ms for a minimum 2s display (avoids UI jank).
+ */
+export declare function useThinkingStatus(isThinking: boolean): 'thinking' | number | null;
+//# sourceMappingURL=WorkingSpinner.d.ts.map

package/lib/types/components/WorkingSpinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkingSpinner.d.ts","sourceRoot":"","sources":["../../../src/components/WorkingSpinner.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAA;AAG1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAM3D;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAC7B,IAAI,EACJ,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,GACf,EAAE;IACD,IAAI,EAAE,WAAW,CAAA;IACjB,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC1C,+EAA+E;IAC/E,eAAe,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IACxC,mBAAmB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5C,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IACzC,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACjD,cAAc,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAA;CAC3C,GAAG,KAAK,CAAC,SAAS,CA4BlB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,OAAO,GAClB,UAAU,GAAG,MAAM,GAAG,IAAI,CA6C5B"}

package/lib/types/components/WorkingSpinner.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { useTerminalSize } from '../ink/hooks/use-terminal-size.js';
+import { Box } from '../ui.js';
+import { SpinnerAnimationRow } from './Spinner/SpinnerAnimationRow.js';
+import { SPINNER_VERBS } from '../terminal-utils/spinnerVerbs.js';
+import { tOr } from '../i18n.js';
+import { sample } from 'lodash-es';
+/**
+ * The working spinner block shown between the transcript and the prompt
+ * input while a turn is in flight. The channel feeds the mode, token count,
+ * and thinking status while this component owns the compact presentation.
+ *
+ * Random verb is picked once per turn (per mount of the spinner).
+ */
+export function WorkingSpinner({ mode, hasActiveTools, responseLengthRef, uploadTokensRef, loadingStartTimeRef, totalPausedMsRef, pauseStartTimeRef, thinkingStatus, }) {
+    const { columns } = useTerminalSize();
+    // Pick a random verb once per spinner mount (per turn).
+    const [randomVerb] = useState(() => sample(SPINNER_VERBS) ?? 'Working');
+    const message = `${tOr(`spinner-verb-${randomVerb.toLowerCase()}`, randomVerb)}…`;
+    return (_jsx(Box, { flexDirection: "column", width: "100%", alignItems: "flex-start", children: _jsx(SpinnerAnimationRow, { mode: mode, reducedMotion: false, hasActiveTools: hasActiveTools, responseLengthRef: responseLengthRef, uploadTokensRef: uploadTokensRef, message: message, messageColor: "accent", shimmerColor: "accentShimmer", loadingStartTimeRef: loadingStartTimeRef, totalPausedMsRef: totalPausedMsRef, pauseStartTimeRef: pauseStartTimeRef, spinnerSuffix: null, verbose: true, columns: columns, thinkingStatus: thinkingStatus }) }));
+}
+/**
+ * Tracks thinking status: 'thinking' while the model is streaming reasoning,
+ * then the duration in ms for a minimum 2s display (avoids UI jank).
+ */
+export function useThinkingStatus(isThinking) {
+    const [thinkingStatus, setThinkingStatus] = useState(null);
+    const thinkingStartRef = useRef(null);
+    useEffect(() => {
+        let showDurationTimer = null;
+        let clearStatusTimer = null;
+        if (isThinking) {
+            // Started thinking
+            if (thinkingStartRef.current === null) {
+                thinkingStartRef.current = Date.now();
+                setThinkingStatus('thinking');
+            }
+        }
+        else if (thinkingStartRef.current !== null) {
+            // Stopped thinking - calculate duration and ensure 2s minimum display
+            const duration = Date.now() - thinkingStartRef.current;
+            const elapsed = Date.now() - thinkingStartRef.current;
+            const remainingThinkingTime = Math.max(0, 2000 - elapsed);
+            thinkingStartRef.current = null;
+            // Show "thinking..." for remaining time if < 2s elapsed, then show duration
+            const showDuration = () => {
+                setThinkingStatus(duration);
+                // Clear after 2s
+                clearStatusTimer = setTimeout(() => setThinkingStatus(null), 2000);
+            };
+            if (remainingThinkingTime > 0) {
+                showDurationTimer = setTimeout(showDuration, remainingThinkingTime);
+            }
+            else {
+                showDuration();
+            }
+        }
+        return () => {
+            if (showDurationTimer)
+                clearTimeout(showDurationTimer);
+            if (clearStatusTimer)
+                clearTimeout(clearStatusTimer);
+        };
+    }, [isThinking]);
+    return thinkingStatus;
+}

package/lib/types/components/WorkspaceFlowPicker.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { TuiWorkspaceChoice } from '../workspaces.js';
+/** Generic nested choice surface returned by a workspace provider command. */
+export declare function WorkspaceFlowPicker({ title, choices, focusIndex, busy, input, onPick, }: {
+    title: string;
+    choices: readonly TuiWorkspaceChoice[];
+    focusIndex: number;
+    busy?: boolean;
+    input?: {
+        value: string;
+        cursor: number;
+        placeholder?: string;
+    } | null;
+    /** Mouse pick (fullscreen): reports the clicked row's absolute index —
+     *  Chat applies it with the same code path as the keyboard Enter. Rows
+     *  are inert while busy (keyboard is swallowed too) and while the inline
+     *  text input owns the interaction. */
+    onPick?: (index: number) => void;
+}): React.ReactNode;
+//# sourceMappingURL=WorkspaceFlowPicker.d.ts.map

package/lib/types/components/WorkspaceFlowPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceFlowPicker.d.ts","sourceRoot":"","sources":["../../../src/components/WorkspaceFlowPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAO1D,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,OAAO,EACP,UAAU,EACV,IAAY,EACZ,KAAY,EACZ,MAAM,GACP,EAAE;IACD,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IACtE;;;2CAGuC;IACvC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC,GAAG,KAAK,CAAC,SAAS,CA0DlB"}

package/lib/types/components/WorkspaceFlowPicker.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from '../ui.js';
+import { t } from '../i18n.js';
+import { Pane } from './design-system/Pane.js';
+import { ListItem } from './design-system/ListItem.js';
+import { HintLine } from './design-system/HintLine.js';
+const WINDOW = 8;
+/** Generic nested choice surface returned by a workspace provider command. */
+export function WorkspaceFlowPicker({ title, choices, focusIndex, busy = false, input = null, onPick, }) {
+    const start = Math.max(0, Math.min(focusIndex - Math.floor(WINDOW / 2), choices.length - WINDOW));
+    const visible = choices.slice(start, start + WINDOW);
+    return (_jsxs(Pane, { color: "permission", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "remember", bold: true, children: title }) }), visible.map((choice, index) => (_jsxs(ListItem, { isFocused: start + index === focusIndex, isSelected: false, description: choice.description, disabled: busy, showScrollUp: index === 0 && start > 0, showScrollDown: index === visible.length - 1 && start + visible.length < choices.length, onClick: onPick !== undefined && !busy && input === null
+                            ? () => onPick(start + index)
+                            : undefined, children: [choice.badge ? `${choice.badge} · ` : '', choice.label] }, choice.id))), input !== null && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "remember", children: "\u276F " }), input.value.length === 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: input.placeholder ?? '' })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: input.value.slice(0, input.cursor) }), _jsx(Text, { inverse: true, children: input.value[input.cursor] ?? ' ' }), _jsx(Text, { children: input.value.slice(input.cursor + 1) })] }))] }))] }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: busy
+                        ? t('workspace-flow-loading')
+                        : input !== null
+                            ? t('workspace-flow-input-hint')
+                            : choices[focusIndex]?.input !== undefined
+                                ? t('workspace-flow-edit-hint')
+                                : t('workspace-flow-hint') }) })] }));
+}

package/lib/types/components/WorkspaceMenuPicker.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+/**
+ * Bare `/workspace` action menu: the built-in subcommands (resume / rename /
+ * open) plus any dynamically registered workspace extensions. Enter runs the
+ * focused action through the same paths a hand-typed subcommand takes;
+ * actions needing free text (rename/open) fall back to their usage notice.
+ */
+export declare function WorkspaceMenuPicker({ options, focusIndex, onPick, }: {
+    options: readonly {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    focusIndex: number;
+    /** Mouse pick (fullscreen): reports the clicked row's index — Chat
+     *  applies it with the same code path as the keyboard Enter. */
+    onPick?: (index: number) => void;
+}): React.ReactNode;
+//# sourceMappingURL=WorkspaceMenuPicker.d.ts.map

package/lib/types/components/WorkspaceMenuPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceMenuPicker.d.ts","sourceRoot":"","sources":["../../../src/components/WorkspaceMenuPicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAOzB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,OAAO,EACP,UAAU,EACV,MAAM,GACP,EAAE;IACD,OAAO,EAAE,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACtE,UAAU,EAAE,MAAM,CAAA;IAClB;oEACgE;IAChE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC,GAAG,KAAK,CAAC,SAAS,CAyBlB"}

package/lib/types/components/WorkspaceMenuPicker.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { t } from '../i18n.js';
+import { Box, Text } from '../ui.js';
+import { Pane } from './design-system/Pane.js';
+import { Select } from './Select.js';
+import { HintLine } from './design-system/HintLine.js';
+/**
+ * Bare `/workspace` action menu: the built-in subcommands (resume / rename /
+ * open) plus any dynamically registered workspace extensions. Enter runs the
+ * focused action through the same paths a hand-typed subcommand takes;
+ * actions needing free text (rename/open) fall back to their usage notice.
+ */
+export function WorkspaceMenuPicker({ options, focusIndex, onPick, }) {
+    return (_jsx(Pane, { color: "permission", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "remember", bold: true, children: t('workspace-menu-title') }) }), _jsx(Select, { options: options.map(option => ({
+                        value: option.id,
+                        label: option.label,
+                        description: option.description,
+                    })), focusIndex: focusIndex, selectedValue: undefined, onPick: onPick === undefined ? undefined : (index) => onPick(index) }), _jsx(Text, { dimColor: true, italic: true, children: _jsx(HintLine, { text: t('hint-confirm-exit') }) })] }) }));
+}

package/lib/types/components/WorkspacePicker.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { TuiWorkspaceTarget } from '../workspaces.js';
+/** `/workspace` target picker contributed by local and optional providers. */
+export declare function WorkspacePicker({ targets, focusIndex, currentCwd, onPick, }: {
+    targets: readonly TuiWorkspaceTarget[];
+    focusIndex: number;
+    currentCwd: string;
+    /** Mouse pick (fullscreen): reports the clicked row's absolute index —
+     *  Chat applies it with the same code path as the keyboard Enter. */
+    onPick?: (index: number) => void;
+}): React.ReactNode;
+//# sourceMappingURL=WorkspacePicker.d.ts.map

package/lib/types/components/WorkspacePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspacePicker.d.ts","sourceRoot":"","sources":["../../../src/components/WorkspacePicker.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAO1D,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,UAAU,EACV,UAAU,EACV,MAAM,GACP,EAAE;IACD,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB;yEACqE;IACrE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC,GAAG,KAAK,CAAC,SAAS,CA0BlB"}