sonex-agent 0.1.0-alpha.1

package/dist/layout.js

@@ -0,0 +1,134 @@
+const CHAT_HEADER_MASCOT_MIN_COLUMNS = 72;
+const MINI_COLUMN_GAP = 1;
+const MINI_INFO_RATIO = 0.32;
+const MINI_INFO_MIN_COLUMNS = 24;
+const MINI_INFO_MAX_COLUMNS = 40;
+const MINI_INFO_LEFT_PADDING = 4;
+const MINI_COVER_MIN_COLUMNS = 32;
+const MINI_COVER_MIN_ROWS = 16;
+const MINI_COVER_TARGET_COLUMNS = 80;
+const MINI_CONTENT_START_ROW = 1;
+const MINI_CONTENT_START_COLUMN = 1;
+const MINI_INFO_ROWS = 4;
+const SPOTIFY_IMMERSIVE_ROWS = 10;
+const SPOTIFY_PROGRESS_MIN_COLUMNS = 18;
+const SPOTIFY_PROGRESS_MAX_COLUMNS = 48;
+export function resolveChatHeaderVariant(columns) {
+    const availableColumns = columns ?? 0;
+    if (availableColumns >= CHAT_HEADER_MASCOT_MIN_COLUMNS)
+        return 'mascot';
+    return 'compact';
+}
+export function resolveMiniPlayerLayout(size) {
+    const columns = Math.max(0, size.columns ?? 0);
+    const rows = Math.max(0, size.rows ?? 0);
+    const contentColumns = columns;
+    const contentRows = rows;
+    const hasArtworkSpace = contentColumns >= MINI_INFO_MIN_COLUMNS + MINI_COLUMN_GAP + MINI_COVER_MIN_COLUMNS
+        && contentRows >= MINI_COVER_MIN_ROWS;
+    const mode = hasArtworkSpace ? 'artwork' : 'infoOnly';
+    const gap = hasArtworkSpace ? MINI_COLUMN_GAP : 0;
+    const availableSplitColumns = Math.max(0, contentColumns - gap);
+    const targetCoverRowsFit = contentRows >= MINI_COVER_TARGET_COLUMNS / 2;
+    const priorityCoverWidth = targetCoverRowsFit
+        ? Math.min(MINI_COVER_TARGET_COLUMNS, Math.max(MINI_COVER_MIN_COLUMNS, availableSplitColumns - MINI_INFO_MIN_COLUMNS))
+        : 0;
+    const preferredInfoWidth = targetCoverRowsFit
+        ? availableSplitColumns - priorityCoverWidth
+        : Math.floor(availableSplitColumns * MINI_INFO_RATIO);
+    const maxInfoWidth = Math.min(MINI_INFO_MAX_COLUMNS, Math.max(0, availableSplitColumns - MINI_COVER_MIN_COLUMNS));
+    const infoWidth = hasArtworkSpace
+        ? Math.min(Math.max(preferredInfoWidth, MINI_INFO_MIN_COLUMNS), maxInfoWidth)
+        : contentColumns;
+    const infoLeftPadding = hasArtworkSpace ? MINI_INFO_LEFT_PADDING : 0;
+    const infoInnerWidth = Math.max(0, infoWidth - infoLeftPadding);
+    const coverWidth = hasArtworkSpace ? Math.max(0, availableSplitColumns - infoWidth) : 0;
+    const infoTop = Math.max(0, Math.floor((contentRows - MINI_INFO_ROWS) / 2));
+    return {
+        mode,
+        contentColumns,
+        contentRows,
+        infoWidth,
+        infoLeftPadding,
+        infoTop,
+        gap,
+        coverWidth,
+        progressSlot: {
+            row: Math.max(1, Math.min(Math.max(1, rows - 1), MINI_CONTENT_START_ROW + infoTop + MINI_INFO_ROWS - 2)),
+            column: MINI_CONTENT_START_COLUMN + infoLeftPadding,
+            width: infoInnerWidth,
+        },
+        statusIconSlot: {
+            row: Math.max(1, Math.min(Math.max(1, rows - 1), MINI_CONTENT_START_ROW + infoTop + MINI_INFO_ROWS - 1)),
+            column: MINI_CONTENT_START_COLUMN + infoLeftPadding,
+            width: infoInnerWidth,
+        },
+    };
+}
+export function resolveSpotifyImmersiveLayout(size) {
+    const columns = Math.max(0, size.columns ?? 0);
+    const rows = Math.max(0, size.rows ?? 0);
+    const topPadding = Math.max(1, Math.floor((Math.max(rows, 1) - SPOTIFY_IMMERSIVE_ROWS) / 2));
+    const preferredWidth = Math.min(SPOTIFY_PROGRESS_MAX_COLUMNS, Math.max(SPOTIFY_PROGRESS_MIN_COLUMNS, Math.max(columns - 16, 0)));
+    const width = Math.max(0, Math.min(Math.max(columns - 4, 0), preferredWidth));
+    const row = Math.max(1, Math.min(Math.max(1, rows - 1), topPadding + 6));
+    const deviceRow = Math.max(1, Math.min(Math.max(1, rows), row + 1));
+    const column = Math.max(1, Math.floor((Math.max(columns, width) - width) / 2) + 1);
+    return {
+        topPadding,
+        progressSlot: {
+            row,
+            column,
+            width,
+        },
+        deviceSlot: {
+            row: deviceRow,
+            column,
+            width,
+        },
+    };
+}
+function hasTrackIdentity(player) {
+    return Boolean(player.session_id
+        || player.provider
+        || player.source
+        || player.name !== '-'
+        || player.artist !== '-'
+        || player.album !== '-');
+}
+export function hasActivePlaybackSession(player, _wasSessionActive) {
+    if (player.ended === true)
+        return false;
+    if (player.is_playing === true)
+        return true;
+    return hasTrackIdentity(player);
+}
+export function resolveRegionAfterPlayerEvent({ currentRegion, wasSessionActive, player, spotifyModeEnabled = false, providerMode = null, }) {
+    const sessionActive = hasActivePlaybackSession(player, wasSessionActive);
+    if (!sessionActive) {
+        return { region: 'chat', sessionActive: false };
+    }
+    if (providerMode && !wasSessionActive) {
+        return { region: 'providerImmersive', sessionActive: true };
+    }
+    if (spotifyModeEnabled && !wasSessionActive) {
+        return { region: 'spotifyImmersive', sessionActive: true };
+    }
+    if (!wasSessionActive) {
+        return { region: 'miniPlayer', sessionActive: true };
+    }
+    return { region: currentRegion, sessionActive: true };
+}
+export function toggleShellRegion(currentRegion, sessionActive, spotifyModeEnabled = false, providerModeEnabled = false) {
+    if (!sessionActive)
+        return 'chat';
+    if (currentRegion === 'providerImmersive')
+        return 'chat';
+    if (currentRegion === 'spotifyImmersive')
+        return 'chat';
+    if (providerModeEnabled && currentRegion === 'chat')
+        return 'providerImmersive';
+    if (spotifyModeEnabled && currentRegion === 'chat')
+        return 'spotifyImmersive';
+    return currentRegion === 'chat' ? 'miniPlayer' : 'chat';
+}

package/dist/list.js

@@ -0,0 +1,3 @@
+export function trimList(items, limit) {
+    return items.slice(Math.max(0, items.length - limit));
+}

package/dist/login-navigation.js

@@ -0,0 +1,7 @@
+export function resolveLoginProviderSelectionIndex(providers, currentProvider) {
+    const providerIndex = providers.findIndex((choice) => choice.value === currentProvider);
+    if (providerIndex >= 0)
+        return providerIndex;
+    const activeIndex = providers.findIndex((choice) => choice.connection_status === 'active');
+    return activeIndex >= 0 ? activeIndex : 0;
+}

package/dist/mini-progress-writer.js

@@ -0,0 +1,122 @@
+import React from 'react';
+import { buildProgressBar, formatDuration } from './format.js';
+import { isPlaybackProgressFrozen, isPlaybackStarting, playbackProgressAt, PLAYBACK_PROGRESS_INTERVAL_MS } from './hooks.js';
+const PLAYING_STATUS_ICON = '▶';
+const PAUSED_STATUS_ICON = '▌▌';
+const SAVED_PLAYLIST_ICON = '✔';
+const ADD_TO_PLAYLIST_ICON = '+';
+const ANSI_GREEN = '\u001B[32m';
+const ANSI_RESET_FG = '\u001B[39m';
+export function resolvePlaybackProgressUpdateMode(enabled, player) {
+    if (!enabled || player.ended === true)
+        return 'off';
+    if (isPlaybackProgressFrozen(player))
+        return 'once';
+    return player.is_playing === true ? 'interval' : 'once';
+}
+export function shouldRefreshMiniSnapshot(reason) {
+    return reason === 'region' || reason === 'resize';
+}
+function playbackProgressLabel(player, progressMs) {
+    if (isPlaybackStarting(player))
+        return 'starting';
+    if (player.progress_sync_lost === true)
+        return 'syncing';
+    if (player.paused_for_cache === true)
+        return 'buffering';
+    if (player.diagnostic_notice)
+        return 'diagnostic';
+    return formatDuration(progressMs);
+}
+function playbackProgressLayout(player, now, width) {
+    const progress = playbackProgressLabel(player, playbackProgressAt(player, now));
+    const duration = formatDuration(player.duration_ms);
+    const barWidth = Math.max(6, width - progress.length - duration.length - 2);
+    return {
+        progress,
+        duration,
+        barWidth,
+        barStart: progress.length + 1,
+    };
+}
+export function buildPlaybackProgressLine(player, now, width) {
+    const progressMs = playbackProgressAt(player, now);
+    const layout = playbackProgressLayout(player, now, width);
+    const progressBar = buildProgressBar(progressMs, player.duration_ms, layout.barWidth);
+    return `${layout.progress} ${progressBar} ${layout.duration}`;
+}
+export function playbackStatusIconSegments(player, width, now) {
+    const playbackIcon = player.is_playing === true ? PLAYING_STATUS_ICON : PAUSED_STATUS_ICON;
+    const progressLayout = playbackProgressLayout(player, now, width);
+    const centeredStart = progressLayout.barStart + Math.floor((progressLayout.barWidth - playbackIcon.length) / 2);
+    const playbackStart = Math.max(0, Math.min(centeredStart, Math.max(0, width - playbackIcon.length)));
+    const visiblePlaybackIcon = sliceVisible(playbackIcon, Math.max(0, width - playbackStart));
+    const segments = [];
+    if (playbackStart > 0)
+        segments.push({ text: ' '.repeat(playbackStart) });
+    if (visiblePlaybackIcon)
+        segments.push({ text: visiblePlaybackIcon });
+    const playlistIcon = player.is_in_playlist === true ? SAVED_PLAYLIST_ICON : ADD_TO_PLAYLIST_ICON;
+    const remainingWidth = width - playbackStart - visiblePlaybackIcon.length;
+    if (remainingWidth >= playlistIcon.length + 1) {
+        segments.push({ text: ' ' });
+        segments.push({
+            text: playlistIcon,
+            color: player.is_in_playlist === true ? 'green' : undefined,
+        });
+    }
+    return segments;
+}
+function visibleText(segments) {
+    return segments.map((segment) => segment.text).join('');
+}
+function sliceVisible(text, width) {
+    return Array.from(text).slice(0, Math.max(0, width)).join('');
+}
+export function buildPlaybackStatusIconLine(player, width, now = Date.now()) {
+    const segments = playbackStatusIconSegments(player, width, now);
+    const text = visibleText(segments);
+    return { text, segments };
+}
+function renderTerminalLine(line) {
+    if (typeof line === 'string')
+        return line;
+    return line.segments.map((segment) => {
+        if (segment.color === 'green')
+            return `${ANSI_GREEN}${segment.text}${ANSI_RESET_FG}`;
+        return segment.text;
+    }).join('');
+}
+export function writeTerminalLine(stdout, position, line) {
+    if (position.width <= 0)
+        return;
+    const text = typeof line === 'string' ? line : line.text;
+    const visible = sliceVisible(text, position.width);
+    const rendered = renderTerminalLine(line);
+    const padded = `${rendered}${' '.repeat(Math.max(0, position.width - visible.length))}`;
+    stdout.write(`\u001B7\u001B[${position.row};${position.column}H${padded}\u001B8`);
+}
+export function usePlaybackProgressWriter({ enabled, player, position, stdout, }) {
+    const playerRef = React.useRef(player);
+    playerRef.current = player;
+    const writeProgress = React.useCallback(() => {
+        writeTerminalLine(stdout, position, buildPlaybackProgressLine(playerRef.current, Date.now(), position.width));
+    }, [position.column, position.row, position.width, stdout]);
+    const updateMode = resolvePlaybackProgressUpdateMode(enabled, player);
+    React.useEffect(() => {
+        if (updateMode === 'off')
+            return;
+        writeProgress();
+        if (updateMode === 'once')
+            return;
+        const timer = setInterval(writeProgress, PLAYBACK_PROGRESS_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [player, updateMode, writeProgress]);
+}
+export function usePlaybackStatusIconWriter({ enabled, player, position, stdout, }) {
+    React.useEffect(() => {
+        if (!enabled)
+            return;
+        writeTerminalLine(stdout, position, buildPlaybackStatusIconLine(player, position.width, Date.now()));
+    }, [enabled, player.is_in_playlist, player.is_playing, player.playback_status, player.progress_ms, position.column, position.row, position.width, stdout]);
+}

package/dist/mini-progress.js

@@ -0,0 +1,77 @@
+import React from 'react';
+import { buildProgressBar, formatDuration } from './format.js';
+import { playbackProgressAt, PLAYBACK_PROGRESS_INTERVAL_MS } from './hooks.js';
+export function resolveMiniProgressUpdateMode(enabled, player) {
+    if (!enabled || player.ended === true)
+        return 'off';
+    return player.is_playing === true ? 'interval' : 'once';
+}
+/**
+ * Coordinates the build mini progress line operation for the CLI UI runtime.
+ *
+ * @param player Input value used by the build mini progress line operation.
+ * @param now Input value used by the build mini progress line operation.
+ * @param width Input value used by the build mini progress line operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function buildMiniProgressLine(player, now, width) {
+    const progress = formatDuration(playbackProgressAt(player, now));
+    const duration = formatDuration(player.duration_ms);
+    const barWidth = Math.max(6, width - progress.length - duration.length - 2);
+    const progressBar = buildProgressBar(playbackProgressAt(player, now), player.duration_ms, barWidth);
+    return `${progress} ${progressBar} ${duration}`;
+}
+/**
+ * Coordinates the resolve mini progress position operation for the CLI UI runtime.
+ *
+ * @param size Input value used by the resolve mini progress position operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function resolveMiniProgressPosition(size) {
+    if (!size.columns || !size.rows || size.columns < 18 || size.rows < 6) {
+        return null;
+    }
+    return {
+        row: Math.max(1, size.rows - 2),
+        column: 3,
+        width: Math.max(6, size.columns - 6),
+    };
+}
+/**
+ * Coordinates the write terminal line operation for the CLI UI runtime.
+ *
+ * @param stdout Input value used by the write terminal line operation.
+ * @param position Input value used by the write terminal line operation.
+ * @param text Input value used by the write terminal line operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function writeTerminalLine(stdout, position, text) {
+    const padded = text.slice(0, position.width).padEnd(position.width, ' ');
+    stdout.write(`\u001B7\u001B[${position.row};${position.column}H\u001B[2K${padded}\u001B8`);
+}
+/**
+ * Coordinates the use mini progress writer operation for the CLI UI runtime.
+ *
+ * @param enabled,player,terminalSize,stdout, Input value used by the use mini progress writer operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function useMiniProgressWriter({ enabled, player, terminalSize, stdout, }) {
+    const playerRef = React.useRef(player);
+    playerRef.current = player;
+    const writeProgress = React.useCallback(() => {
+        const position = resolveMiniProgressPosition(terminalSize);
+        if (!position)
+            return;
+        writeTerminalLine(stdout, position, buildMiniProgressLine(playerRef.current, Date.now(), position.width));
+    }, [stdout, terminalSize.columns, terminalSize.rows]);
+    const updateMode = resolveMiniProgressUpdateMode(enabled, player);
+    React.useEffect(() => {
+        if (updateMode === 'off')
+            return;
+        writeProgress();
+        if (updateMode === 'once')
+            return;
+        const timer = setInterval(writeProgress, PLAYBACK_PROGRESS_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [player, updateMode, writeProgress]);
+}

package/dist/model-selection.js

@@ -0,0 +1,20 @@
+import stringWidth from 'string-width';
+export const modelPanelLabelWidth = (choices) => (Math.max(0, ...choices.map((choice) => stringWidth(choice.label))) + 1);
+export const formatModelPanelLabel = (choice, width) => {
+    const label = choice.label;
+    const labelWidth = stringWidth(label);
+    if (labelWidth >= width)
+        return label;
+    return `${label}${" ".repeat(width - labelWidth)}`;
+};
+export const filterModelChoices = (choices, query) => {
+    const tokens = query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return choices;
+    return choices.filter((choice) => {
+        const searchable = [choice.value, choice.label, choice.provider ?? '']
+            .join(' ')
+            .toLocaleLowerCase();
+        return tokens.every((token) => searchable.includes(token));
+    });
+};

package/dist/model-status.js

@@ -0,0 +1,34 @@
+const PROVIDER_BRANDS = {
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    gemini: 'Google Gemini',
+    deepseek: 'DeepSeek',
+    openrouter: 'OpenRouter',
+    zai: 'Z.AI',
+    kimi_global: 'Kimi Global',
+    kimi_cn: 'Kimi CN',
+    minimax_global: 'MiniMax Global',
+    minimax_cn: 'MiniMax CN',
+    xai: 'xAI',
+    custom: 'Custom',
+};
+export const formatTokenCount = (value) => {
+    const tokens = Math.max(0, Math.floor(value));
+    return tokens > 1_000 ? `${Math.floor(tokens / 1_000)}k` : String(tokens);
+};
+export const formatModelStatus = (input, tokenUsage) => {
+    if (!input.ready)
+        return null;
+    const provider = input.provider.trim();
+    const model = (input.model_label || input.model).trim();
+    if (!provider || !model)
+        return null;
+    const normalizedProvider = provider.toLowerCase();
+    const providerLabel = normalizedProvider.startsWith('custom__')
+        ? 'Custom'
+        : PROVIDER_BRANDS[normalizedProvider] ?? provider;
+    const modelLabel = `[${providerLabel}] ${model}`;
+    if (tokenUsage.inputTokens <= 0 && tokenUsage.outputTokens <= 0)
+        return modelLabel;
+    return `↑${formatTokenCount(tokenUsage.inputTokens)} ↓${formatTokenCount(tokenUsage.outputTokens)} ${modelLabel}`;
+};

package/dist/mouse-input.js

@@ -0,0 +1,173 @@
+import { Transform } from 'node:stream';
+export const MOUSE_TRACKING_ENABLE = "\u001B[?1000h\u001B[?1006h";
+export const MOUSE_TRACKING_DISABLE = "\u001B[?1006l\u001B[?1000l";
+const ESCAPE = 0x1B;
+const CSI = 0x5B;
+const SGR_MARKER = 0x3C;
+const X10_MARKER = 0x4D;
+const SGR_RELEASE = 0x6D;
+const MAX_SGR_SEQUENCE_BYTES = 64;
+const isAsciiDigit = (value) => value >= 0x30 && value <= 0x39;
+const wheelEventForButton = (button) => {
+    const baseButton = button & ~(4 | 8 | 16 | 32);
+    if (baseButton === 64)
+        return "up";
+    if (baseButton === 65)
+        return "down";
+    return null;
+};
+export class MouseSequenceFilter {
+    onWheel;
+    pending = Buffer.alloc(0);
+    constructor(onWheel) {
+        this.onWheel = onWheel;
+    }
+    transform(chunk) {
+        const input = this.pending.length > 0
+            ? Buffer.concat([this.pending, chunk])
+            : chunk;
+        const output = [];
+        let plainStart = 0;
+        let index = 0;
+        const flushPlain = (end) => {
+            if (end > plainStart)
+                output.push(input.subarray(plainStart, end));
+        };
+        while (index < input.length) {
+            if (input[index] !== ESCAPE) {
+                index += 1;
+                continue;
+            }
+            const remaining = input.length - index;
+            if (remaining < 2) {
+                flushPlain(index);
+                this.pending = input.subarray(index);
+                return Buffer.concat(output);
+            }
+            if (input[index + 1] !== CSI) {
+                index += 1;
+                continue;
+            }
+            if (remaining < 3) {
+                flushPlain(index);
+                this.pending = input.subarray(index);
+                return Buffer.concat(output);
+            }
+            const protocol = input[index + 2];
+            if (protocol === X10_MARKER) {
+                if (remaining < 6) {
+                    flushPlain(index);
+                    this.pending = input.subarray(index);
+                    return Buffer.concat(output);
+                }
+                flushPlain(index);
+                const event = wheelEventForButton(input[index + 3] - 32);
+                if (event)
+                    this.onWheel(event);
+                index += 6;
+                plainStart = index;
+                continue;
+            }
+            if (protocol !== SGR_MARKER) {
+                index += 1;
+                continue;
+            }
+            let cursor = index + 3;
+            let validPayload = true;
+            while (cursor < input.length && input[cursor] !== X10_MARKER && input[cursor] !== SGR_RELEASE) {
+                if (!isAsciiDigit(input[cursor]) && input[cursor] !== 0x3B) {
+                    validPayload = false;
+                    break;
+                }
+                cursor += 1;
+            }
+            if (!validPayload || cursor - index > MAX_SGR_SEQUENCE_BYTES) {
+                index += 1;
+                continue;
+            }
+            if (cursor >= input.length) {
+                flushPlain(index);
+                this.pending = input.subarray(index);
+                return Buffer.concat(output);
+            }
+            const match = input.subarray(index, cursor + 1).toString("ascii")
+                .match(/^\u001B\[<(\d+);(\d+);(\d+)[Mm]$/);
+            if (!match) {
+                index += 1;
+                continue;
+            }
+            flushPlain(index);
+            const event = wheelEventForButton(Number(match[1]));
+            if (event)
+                this.onWheel(event);
+            index = cursor + 1;
+            plainStart = index;
+        }
+        flushPlain(input.length);
+        this.pending = Buffer.alloc(0);
+        return output.length === 0 ? Buffer.alloc(0) : Buffer.concat(output);
+    }
+    flush() {
+        const pending = this.pending;
+        this.pending = Buffer.alloc(0);
+        return pending;
+    }
+}
+class FilteredMouseInput extends Transform {
+    source;
+    sequenceFilter;
+    constructor(source, onWheel) {
+        super();
+        this.source = source;
+        this.sequenceFilter = new MouseSequenceFilter(onWheel);
+        source.pipe(this);
+    }
+    get isTTY() {
+        return Boolean(this.source.isTTY);
+    }
+    setRawMode(mode) {
+        this.source.setRawMode?.(mode);
+        return this;
+    }
+    ref() {
+        this.source.ref?.();
+        return this;
+    }
+    unref() {
+        this.source.unref?.();
+        return this;
+    }
+    _transform(chunk, encoding, callback) {
+        const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        const output = this.sequenceFilter.transform(input);
+        callback(null, output.length > 0 ? output : undefined);
+    }
+    _flush(callback) {
+        const output = this.sequenceFilter.flush();
+        callback(null, output.length > 0 ? output : undefined);
+    }
+    _destroy(error, callback) {
+        this.source.unpipe(this);
+        callback(error);
+    }
+}
+export const createMouseInputAdapter = (stdin) => {
+    const listeners = new Set();
+    const filteredInput = new FilteredMouseInput(stdin, (event) => {
+        for (const listener of listeners)
+            listener(event);
+    });
+    return {
+        stdin: filteredInput,
+        wheelSource: {
+            subscribe(listener) {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        },
+        dispose() {
+            listeners.clear();
+            filteredInput.destroy();
+        },
+    };
+};

package/dist/panel-frame.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, Transform } from 'ink';
+import stringWidth from 'string-width';
+import { wrapChatMessageContent } from './chat-message.js';
+import { BORDER_BLUE, SPOTIFY_GREEN } from './constants.js';
+import { withTrueColorBackground } from './terminal-frame-writer.js';
+export const PANEL_BACKGROUND = "#48273e";
+export const PANEL_TITLE = "#c8a6ff";
+export const PANEL_PRIMARY = "#fff4f6";
+export const PANEL_SECONDARY = "#808791";
+export const withPanelBackground = (value) => (withTrueColorBackground(value, PANEL_BACKGROUND));
+const boundedPanelWidth = (width) => Math.max(3, Math.floor(width));
+export const panelContentWidth = (width, paddingX = 1) => (Math.max(1, boundedPanelWidth(width) - Math.max(0, Math.floor(paddingX)) * 2));
+export const fitPanelSegments = (segments, width) => {
+    const targetWidth = Math.max(0, Math.floor(width));
+    const fitted = [];
+    let usedWidth = 0;
+    for (const segment of segments) {
+        let text = "";
+        for (const character of Array.from(segment.text)) {
+            const characterWidth = stringWidth(character);
+            if (usedWidth + characterWidth > targetWidth)
+                break;
+            text += character;
+            usedWidth += characterWidth;
+        }
+        if (text)
+            fitted.push({ ...segment, text });
+        if (usedWidth >= targetWidth)
+            break;
+    }
+    return fitted;
+};
+export const resolvePanelChoiceSegments = (item, selected, spotifyTheme) => {
+    if (!selected) {
+        return item.unselectedBold
+            ? item.segments.map((segment) => ({ ...segment, bold: true }))
+            : item.segments;
+    }
+    if (item.segments.some((segment) => segment.preserveColorWhenSelected)) {
+        const selectedColor = spotifyTheme ? SPOTIFY_GREEN : BORDER_BLUE;
+        return item.segments.map((segment) => ({
+            ...segment,
+            color: item.selectedColor ?? (segment.preserveColorWhenSelected ? segment.color : selectedColor),
+            bold: true,
+        }));
+    }
+    return [{
+            text: item.segments.map((segment) => segment.text).join(""),
+            color: item.selectedColor ?? (spotifyTheme ? SPOTIFY_GREEN : BORDER_BLUE),
+            bold: true,
+        }];
+};
+export const PanelEmptyRow = ({ width }) => (_jsx(Text, { children: _jsx(Transform, { transform: withPanelBackground, children: _jsx(Text, { children: " ".repeat(boundedPanelWidth(width)) }) }) }));
+export const PanelRow = ({ width, segments, paddingX = 1, }) => {
+    const boundedWidth = boundedPanelWidth(width);
+    const boundedPadding = Math.max(0, Math.min(Math.floor(paddingX), Math.floor((boundedWidth - 1) / 2)));
+    const contentWidth = panelContentWidth(boundedWidth, boundedPadding);
+    const fittedSegments = fitPanelSegments(segments, contentWidth);
+    const fittedWidth = fittedSegments.reduce((total, segment) => total + stringWidth(segment.text), 0);
+    const rightPadding = Math.max(boundedPadding, boundedWidth - boundedPadding - fittedWidth);
+    return (_jsx(Text, { children: _jsx(Transform, { transform: withPanelBackground, children: _jsxs(Text, { children: [" ".repeat(boundedPadding), fittedSegments.map((segment, index) => (_jsx(Text, { color: segment.color ?? PANEL_PRIMARY, bold: segment.bold, italic: segment.italic, children: segment.text }, `${index}-${segment.text}`))), " ".repeat(rightPadding)] }) }) }));
+};
+export const PanelChoiceList = ({ items, selectedIndex, width, paddingX = 1, spotifyTheme = false, visibleLimit, }) => {
+    if (items.length === 0)
+        return null;
+    const boundedIndex = selectedIndex < 0
+        ? -1
+        : Math.min(selectedIndex, items.length - 1);
+    const limit = Math.max(1, Math.min(visibleLimit ?? items.length, items.length));
+    const maxStart = Math.max(0, items.length - limit);
+    const startIndex = Math.min(Math.max(0, boundedIndex - limit + 1), maxStart);
+    const visibleItems = items.slice(startIndex, startIndex + limit);
+    return (_jsx(Box, { flexDirection: "column", children: visibleItems.map((item, index) => {
+            const selected = startIndex + index === boundedIndex;
+            return (_jsxs(React.Fragment, { children: [item.gapBefore ? _jsx(PanelEmptyRow, { width: width }) : null, _jsx(PanelRow, { width: width, paddingX: paddingX, segments: resolvePanelChoiceSegments(item, selected, spotifyTheme) })] }, item.key));
+        }) }));
+};
+export const PanelFrame = ({ width, title, titleSegments = null, hint = null, hintColor = PANEL_SECONDARY, titleDetailSegments = null, paddingX = 1, children, }) => {
+    const boundedWidth = boundedPanelWidth(width);
+    const contentWidth = panelContentWidth(boundedWidth, paddingX);
+    const titleRows = wrapChatMessageContent(title, contentWidth);
+    const hintRows = hint ? wrapChatMessageContent(hint, contentWidth) : [];
+    return (_jsxs(Box, { width: boundedWidth, flexDirection: "column", flexShrink: 0, children: [_jsx(PanelEmptyRow, { width: boundedWidth }), titleSegments ? (_jsx(PanelRow, { width: boundedWidth, paddingX: paddingX, segments: titleSegments })) : titleRows.map((row, index) => (_jsx(PanelRow, { width: boundedWidth, paddingX: paddingX, segments: [{ text: row, color: PANEL_TITLE, bold: true }] }, `panel-title-${index}`))), hintRows.map((row, index) => (_jsx(PanelRow, { width: boundedWidth, paddingX: paddingX, segments: [{ text: row, color: hintColor }] }, `panel-hint-${index}`))), titleDetailSegments ? (_jsx(PanelRow, { width: boundedWidth, paddingX: paddingX, segments: titleDetailSegments })) : null, _jsx(PanelEmptyRow, { width: boundedWidth }), children, _jsx(PanelEmptyRow, { width: boundedWidth })] }));
+};

package/dist/panel-lifecycle.js

@@ -0,0 +1,17 @@
+const plan = (close, resetSelection = []) => ({ close, resetSelection });
+export function planPanelLifecycle(trigger) {
+    switch (trigger) {
+        case 'input':
+        case 'info':
+        case 'safe_exit':
+            return plan(['help', 'track', 'language'], ['help', 'track']);
+        case 'extension_event':
+            return plan(['track', 'memory', 'help', 'language']);
+        case 'help_event':
+            return plan(['track', 'language'], ['help']);
+        case 'setup_event':
+            return plan(['help'], ['help']);
+        case 'bye':
+            return plan(['help', 'track'], ['help', 'track']);
+    }
+}