sonex-agent 0.1.0-alpha.1

package/dist/confirm-choice.js

@@ -0,0 +1,65 @@
+const normalize = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}_-]+/gu, '');
+export function isCancelConfirmChoice(choice) {
+    const value = normalize(choice.value);
+    const label = normalize(choice.label);
+    return value === 'cancel'
+        || value === 'deny'
+        || label === 'cancel'
+        || label === 'no'
+        || label === '取消';
+}
+export function getVisibleConfirmChoices(choices, includeCancel = false) {
+    return includeCancel
+        ? choices
+        : choices.filter((choice) => !isCancelConfirmChoice(choice));
+}
+export function getSelectableConfirmChoices(choices, includeCancel = false) {
+    return getVisibleConfirmChoices(choices, includeCancel).filter((choice) => !choice.disabled);
+}
+export function resolveConfirmChoiceDisplayIndex(choices, selectableIndex, includeCancel = false) {
+    const visibleChoices = getVisibleConfirmChoices(choices, includeCancel);
+    const selectableChoices = getSelectableConfirmChoices(choices, includeCancel);
+    const selectedChoice = selectableChoices[Math.min(Math.max(selectableIndex, 0), Math.max(0, selectableChoices.length - 1))];
+    if (!selectedChoice)
+        return -1;
+    return Math.max(0, visibleChoices.findIndex((choice) => choice.value === selectedChoice.value));
+}
+/**
+ * Coordinates the resolve confirm decision from input operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the resolve confirm decision from input operation.
+ * @param choices Input value used by the resolve confirm decision from input operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function resolveConfirmDecisionFromInput(input, choices) {
+    const selectableChoices = getSelectableConfirmChoices(choices);
+    const normalized = normalize(input);
+    if (!normalized)
+        return null;
+    const numeric = Number.parseInt(normalized, 10);
+    if (Number.isInteger(numeric) && String(numeric) === normalized) {
+        return selectableChoices[numeric - 1]?.value ?? null;
+    }
+    for (const choice of selectableChoices) {
+        if (normalize(choice.value) === normalized || normalize(choice.label) === normalized) {
+            return choice.value;
+        }
+    }
+    return null;
+}
+/**
+ * Coordinates the resolve confirm input decision operation for the CLI UI runtime.
+ *
+ * @param input Input value used by the resolve confirm input decision operation.
+ * @param choice Input value used by the resolve confirm input decision operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function resolveConfirmInputDecision(input, choice) {
+    const text = input.trim();
+    if (!text || !choice?.input)
+        return null;
+    return `${choice.value}:${encodeURIComponent(text)}`;
+}

package/dist/constants.js

@@ -0,0 +1,109 @@
+export const wsUrl = process.env.SONEX_WS_URL ?? "ws://localhost:9001/ws";
+export const APP_VERSION = "0.1.0-alpha.1";
+export const FALLBACK_MODEL_NAME = "gpt-5.5";
+export const BORDER_BLUE = "#3b82f6";
+export const BORDER_BLUE_SOFT = "#9fd9ff";
+export const TOOL_NAVY = "#182e66";
+export const TOOL_VALUE = "#ffffff";
+export const SPOTIFY_GREEN = "#1db954";
+export const APP_TIP_PLACEHOLDER = "Tip: use /random to play a recent song.";
+export const MAX_ACTIVITY_ITEMS = 80;
+export const DEFAULT_CONFIRM_CHOICES = [
+    { value: "allow_once", label: "Yes" },
+    { value: "deny", label: "No" },
+];
+export const MAX_VISIBLE_SLASH_COMMANDS = 4;
+export const MAX_VISIBLE_MODEL_CHOICES = 4;
+export const SLASH_COMMANDS = [
+    { name: "bye", usage: "/bye", description: "save and exit", needsArgument: false },
+    { name: "extension", usage: "/extension", description: "check and manage music extensions", needsArgument: false },
+    { name: "exit", usage: "/exit", description: "save and exit", needsArgument: false },
+    { name: "help", usage: "/help", description: "show commands", needsArgument: false },
+    { name: "info", usage: "/info", description: "show runtime info", needsArgument: false },
+    { name: "lang", usage: "/lang", description: "choose display language", needsArgument: false, enabled: false },
+    { name: "login", usage: "/login", description: "connect or switch LLM provider", needsArgument: false },
+    { name: "logout", usage: "/logout", description: "sign out and exit", needsArgument: false },
+    { name: "memory", usage: "/memory", description: "configure long-term memory", needsArgument: false },
+    { name: "model", usage: "/model", description: "switch active model", needsArgument: false },
+    { name: "playlist", usage: "/playlist [name]|save [name]", description: "browse or save playlists", needsArgument: false },
+    { name: "queue", usage: "/queue", description: "show playback queue", needsArgument: false },
+    { name: "random", usage: "/random", description: "play a recent song", needsArgument: false },
+    { name: "recommend", usage: "/recommend", description: "recommend songs", needsArgument: false },
+    { name: "resume", usage: "/resume", description: "resume playback", needsArgument: false },
+    { name: "sandbox", usage: "/sandbox", description: "check Agent Bash sandbox", needsArgument: false },
+    { name: "settings", usage: "/settings", description: "configure Sonex settings", needsArgument: false, aliases: ["setting"] },
+    { name: "spotify", usage: "/spotify", description: "toggle Spotify mode", needsArgument: false },
+].sort((a, b) => a.name.localeCompare(b.name));
+export const API_NOT_RUNNING_MESSAGE = "Sonex API is not running";
+export const API_NOT_RUNNING_DETAIL = "Start with `sonex`, or run `sonex api` before `sonex tui`.";
+export const SONEX_MASCOT = [
+    [
+        { text: "    " },
+        { text: "▄", fg: "#000000" },
+        { text: "▀▀▀▀▀", fg: "#000000", bg: "#f4f1f3" },
+        { text: "▄", fg: "#000000" },
+    ],
+    [
+        { text: "  " },
+        { text: "▄", fg: "#000000" },
+        { text: "▀", fg: "#000000", bg: "#f4f1f3" },
+        { text: "▀", fg: "#f4f1f3", bg: "#000000" },
+        { text: "▀▀▀▀▀", fg: "#000000", bg: "#9fd9ff" },
+        { text: "▀", fg: "#f4f1f3", bg: "#000000" },
+        { text: "▄", fg: "#000000" },
+    ],
+    [
+        { text: "  " },
+        { text: "█", fg: "#000000" },
+        { text: "▀", fg: "#f4f1f3", bg: "#000000" },
+        { text: "▀", fg: "#000000", bg: "#9fd9ff" },
+        { text: "██████", fg: "#9fd9ff" },
+        { text: "▀", fg: "#4b5161", bg: "#9fd9ff" },
+        { text: "▄", fg: "#4b5161" },
+    ],
+    [
+        { text: " " },
+        { text: "█", fg: "#000000" },
+        { text: "██", fg: "#f4f1f3" },
+        { text: "█", fg: "#000000" },
+        { text: "██", fg: "#9fd9ff" },
+        { text: "█", fg: "#000000" },
+        { text: "██", fg: "#9fd9ff" },
+        { text: "█", fg: "#000000" },
+        { text: "█", fg: "#9fd9ff" },
+        { text: "█", fg: "#4b5161" },
+    ],
+    [
+        { text: " " },
+        { text: "▀", fg: "#000000" },
+        { text: "▀▀", fg: "#f4f1f3", bg: "#000000" },
+        { text: "▀", fg: "#000000", bg: "#9fd9ff" },
+        { text: "███████", fg: "#9fd9ff" },
+        { text: "▀", fg: "#4b5161" },
+    ],
+    [
+        { text: "  " },
+        { text: "▄", fg: "#4b5161" },
+        { text: "▀", fg: "#4b5161", bg: "#9fd9ff" },
+        { text: "██████", fg: "#9fd9ff" },
+        { text: "█", fg: "#9fd9ff" },
+        { text: "▀", fg: "#9fd9ff" },
+    ],
+    [
+        { text: "  " },
+        { text: "▀", fg: "#4b5161" },
+        { text: "▀", fg: "#9fd9ff" },
+        { text: "▀", fg: "#9fd9ff" },
+        { text: "█████", fg: "#9fd9ff" },
+        { text: "▀", fg: "#9fd9ff" },
+    ],
+];
+export const SONEX_MASCOT_MICRO = [
+    [
+        { text: "█", fg: "#9fd9ff" },
+        { text: "▀", fg: "#9fd9ff", bg: "#000000" },
+        { text: "██", fg: "#9fd9ff" },
+        { text: "▀", fg: "#9fd9ff", bg: "#000000" },
+        { text: "█", fg: "#9fd9ff" },
+    ],
+];

package/dist/conversation-flow.js

@@ -0,0 +1,21 @@
+export const EMPTY_CONVERSATION_RESERVE_ROWS = 3;
+function normalizeRows(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+export function resolveConversationFlow(input) {
+    const availableRows = Math.max(1, normalizeRows(input.availableRows));
+    const showTailDock = normalizeRows(input.scrollOffset) === 0;
+    if (!showTailDock) {
+        return { chatRows: availableRows, showTailDock: false, emptyReserveRows: 0 };
+    }
+    const emptyReserveRows = input.hasRuntimeBanner && !input.hasMessages
+        ? EMPTY_CONVERSATION_RESERVE_ROWS
+        : 0;
+    const maximumChatRows = Math.max(1, availableRows - normalizeRows(input.tailRows));
+    const desiredChatRows = Math.max(1, normalizeRows(input.contentRows) + emptyReserveRows);
+    return {
+        chatRows: Math.min(desiredChatRows, maximumChatRows),
+        showTailDock: true,
+        emptyReserveRows,
+    };
+}

package/dist/cover-pattern.js

@@ -0,0 +1,58 @@
+const DEPRECATED_COVER_PATTERN_SIZES = new Set([32, 36]);
+/**
+ * Coordinates the choose cover pattern variant operation for the CLI UI runtime.
+ *
+ * @param pattern Input value used by the choose cover pattern variant operation.
+ * @param space Input value used by the choose cover pattern variant operation.
+ * @param options Input value used by the choose cover pattern variant operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function chooseCoverPatternVariant(pattern, space, options = {}) {
+    if (!pattern || !space.columns || !space.rows)
+        return null;
+    const sizes = Object.keys(pattern.variants)
+        .map((value) => Number(value))
+        .filter((value) => Number.isInteger(value) && value > 0 && !DEPRECATED_COVER_PATTERN_SIZES.has(value))
+        .sort((left, right) => right - left);
+    for (const size of sizes) {
+        if (options.maxSize && size > options.maxSize)
+            continue;
+        const grid = pattern.variants[String(size)];
+        if (!grid || grid.length !== size)
+            continue;
+        if (space.columns >= size && space.rows >= size / 2) {
+            return { size, grid };
+        }
+    }
+    return null;
+}
+export function resolveCoverPatternDisplay(pattern, space, options = {}) {
+    if (!pattern)
+        return { status: 'none' };
+    if (pattern.unavailable_reason)
+        return { status: 'unavailable' };
+    if (!space)
+        return { status: 'unfit' };
+    const variant = chooseCoverPatternVariant(pattern, space, options);
+    return variant ? { status: 'renderable', variant } : { status: 'unfit' };
+}
+/**
+ * Coordinates the render cover pattern half blocks operation for the CLI UI runtime.
+ *
+ * @param grid Input value used by the render cover pattern half blocks operation.
+ * @param palette Input value used by the render cover pattern half blocks operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function renderCoverPatternHalfBlocks(grid, palette) {
+    const rows = [];
+    for (let y = 0; y < grid.length; y += 2) {
+        const upper = grid[y] ?? [];
+        const lower = grid[y + 1] ?? upper;
+        rows.push(upper.map((upperIndex, x) => ({
+            char: '▀',
+            foreground: palette[upperIndex] ?? '#ffffff',
+            background: palette[lower[x] ?? upperIndex] ?? '#000000',
+        })));
+    }
+    return rows;
+}

package/dist/cover-visual.js

@@ -0,0 +1,158 @@
+const FALLBACK_SEED = 0x5e9ec7;
+const BLOCK_ROWS = 8;
+const BLOCK_COLUMNS = 14;
+/**
+ * Coordinates the cover visual from source operation for the CLI UI runtime.
+ *
+ * @param source Input value used by the cover visual from source operation.
+ * @param failed Input value used by the cover visual from source operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function coverVisualFromSource(source, failed = false) {
+    const normalized = source?.trim() || '';
+    const seed = normalized && !failed ? hashSource(normalized) : FALLBACK_SEED;
+    const palette = paletteFromSeed(seed);
+    return {
+        status: normalized && !failed ? 'ready' : 'fallback',
+        seed,
+        ...palette,
+        blocks: buildBlockMatrix(seed, palette),
+    };
+}
+/**
+ * Coordinates the rhythm frame for playback operation for the CLI UI runtime.
+ *
+ * @param isPlaying Input value used by the rhythm frame for playback operation.
+ * @param progressMs Input value used by the rhythm frame for playback operation.
+ * @param seed Input value used by the rhythm frame for playback operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function rhythmFrameForPlayback(isPlaying, progressMs, seed) {
+    if (!isPlaying) {
+        return 0;
+    }
+    const phase = Math.floor(Math.max(0, progressMs) / 700);
+    return (phase + (seed % 4)) % 4;
+}
+/**
+ * Coordinates the hash source operation for the CLI UI runtime.
+ *
+ * @param source Input value used by the hash source operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function hashSource(source) {
+    let hash = 2166136261;
+    for (let index = 0; index < source.length; index += 1) {
+        hash ^= source.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}
+/**
+ * Coordinates the palette from seed operation for the CLI UI runtime.
+ *
+ * @param seed Input value used by the palette from seed operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function paletteFromSeed(seed) {
+    const hue = seed % 360;
+    const secondaryHue = (hue + 46 + ((seed >>> 8) % 64)) % 360;
+    const accentHue = (hue + 172 + ((seed >>> 16) % 38)) % 360;
+    return {
+        primary: hslToHex(hue, 62, 56),
+        secondary: hslToHex(secondaryHue, 56, 42),
+        accent: hslToHex(accentHue, 72, 66),
+        muted: hslToHex((hue + 24) % 360, 28, 24),
+    };
+}
+/**
+ * Coordinates the build block matrix operation for the CLI UI runtime.
+ *
+ * @param seed Input value used by the build block matrix operation.
+ * @param palette Input value used by the build block matrix operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function buildBlockMatrix(seed, palette) {
+    const colors = [palette.primary, palette.secondary, palette.accent, palette.muted];
+    return Array.from({ length: BLOCK_ROWS }, (_, row) => (Array.from({ length: BLOCK_COLUMNS }, (_, column) => {
+        const wave = Math.sin((row + 1) * 0.9 + (column + seed % 7) * 0.58);
+        const grain = seededUnit(seed + row * 97 + column * 53);
+        const index = Math.abs(Math.floor((wave + grain * 1.8 + row * 0.28) * colors.length)) % colors.length;
+        return colors[index] ?? palette.primary;
+    })));
+}
+/**
+ * Coordinates the seeded unit operation for the CLI UI runtime.
+ *
+ * @param seed Input value used by the seeded unit operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function seededUnit(seed) {
+    let value = seed >>> 0;
+    value ^= value << 13;
+    value ^= value >>> 17;
+    value ^= value << 5;
+    return (value >>> 0) / 4294967295;
+}
+/**
+ * Coordinates the hsl to hex operation for the CLI UI runtime.
+ *
+ * @param hue Input value used by the hsl to hex operation.
+ * @param saturation Input value used by the hsl to hex operation.
+ * @param lightness Input value used by the hsl to hex operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function hslToHex(hue, saturation, lightness) {
+    const normalizedHue = (((hue % 360) + 360) % 360) / 360;
+    const normalizedSaturation = clamp01(saturation / 100);
+    const normalizedLightness = clamp01(lightness / 100);
+    if (normalizedSaturation === 0) {
+        const gray = toHexChannel(normalizedLightness);
+        return `#${gray}${gray}${gray}`;
+    }
+    const q = normalizedLightness < 0.5
+        ? normalizedLightness * (1 + normalizedSaturation)
+        : normalizedLightness + normalizedSaturation - normalizedLightness * normalizedSaturation;
+    const p = 2 * normalizedLightness - q;
+    return `#${toHexChannel(hueToRgb(p, q, normalizedHue + 1 / 3))}${toHexChannel(hueToRgb(p, q, normalizedHue))}${toHexChannel(hueToRgb(p, q, normalizedHue - 1 / 3))}`;
+}
+/**
+ * Coordinates the hue to rgb operation for the CLI UI runtime.
+ *
+ * @param p Input value used by the hue to rgb operation.
+ * @param q Input value used by the hue to rgb operation.
+ * @param t Input value used by the hue to rgb operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function hueToRgb(p, q, t) {
+    let value = t;
+    if (value < 0)
+        value += 1;
+    if (value > 1)
+        value -= 1;
+    if (value < 1 / 6)
+        return p + (q - p) * 6 * value;
+    if (value < 1 / 2)
+        return q;
+    if (value < 2 / 3)
+        return p + (q - p) * (2 / 3 - value) * 6;
+    return p;
+}
+/**
+ * Coordinates the to hex channel operation for the CLI UI runtime.
+ *
+ * @param value Input value used by the to hex channel operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function toHexChannel(value) {
+    return Math.round(clamp01(value) * 255).toString(16).padStart(2, '0');
+}
+/**
+ * Coordinates the clamp01 operation for the CLI UI runtime.
+ *
+ * @param value Input value used by the clamp01 operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+function clamp01(value) {
+    return Math.min(1, Math.max(0, value));
+}

package/dist/extension-panel.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import stringWidth from "string-width";
+import TextInput from "ink-text-input";
+import { PanelChoiceList, PanelFrame, PanelRow, PANEL_PRIMARY, PANEL_SECONDARY } from "./panel-frame.js";
+const SIGNAL_COLORS = {
+    green: "#22c55e",
+    gray: "#808791",
+    red: "#ef4444",
+    yellow: "#facc15",
+    hollow: "#808791",
+};
+const STATUS_LABELS = {
+    enabled: "Enabled",
+    not_configured: "Not configured",
+    disabled: "Disabled",
+    unavailable: "Unavailable",
+    unapplied: "Unapplied",
+    unsupported: "Unsupported",
+    waiting: "Waiting for response…",
+};
+export const EXTENSION_NAME_WIDTH = 7;
+export const extensionSignal = (extension) => (extension.signal === "hollow" ? "◦" : "•");
+const extensionActionColor = (action) => {
+    if (action === "reset" || action === "prepare_reset")
+        return "#ef4444";
+    if (action === "repair" || action === "restart" || action === "prepare_restart")
+        return "#facc15";
+    return PANEL_PRIMARY;
+};
+const extensionActionBold = (action) => action === "restart" || action === "prepare_restart" || action === "prepare_reset";
+const statusLabel = (status) => STATUS_LABELS[status];
+const extensionActionLabel = (action) => ({
+    setup: "Setup",
+    enable: "Enable",
+    disable: "Disable",
+    repair: "Repair",
+    restart: "Restart",
+    prepare_restart: "Restart",
+    quick_check: "Quick Check",
+    prepare_reset: "Reset",
+    confirm_reset: "Insist",
+    confirm_restart: "Restart",
+}[action] || action);
+const DEPENDENCY_MARKER_WIDTH = Math.max(stringWidth("✔️"), stringWidth("❌"), stringWidth("□"));
+const DEPENDENCY_PROGRESS_WIDTH = 18;
+const dependencyGlyph = (state, spinnerFrame = 0) => (state === "installed" ? "✔️" : state === "failed" ? "❌" : state === "installing" ? ["⠦", "⠴", "⠧", "⠇", "⠏", "⠋", "⠙", "⠹", "⠸", "⠼"][spinnerFrame % 10] : "□");
+const dependencyColor = (state) => (state === "installed" ? "#22c55e" : state === "failed" ? "#ef4444" : state === "installing" ? "#808791" : "#808791");
+const dependencyProgressBar = (progress, spinnerFrame = 0) => {
+    if (progress == null) {
+        const position = spinnerFrame % DEPENDENCY_PROGRESS_WIDTH;
+        return `${"░".repeat(position)}█${"░".repeat(DEPENDENCY_PROGRESS_WIDTH - position - 1)}`;
+    }
+    const filled = Math.round(DEPENDENCY_PROGRESS_WIDTH * Math.min(1, Math.max(0, progress) / 100));
+    return `${"█".repeat(Math.max(1, filled))}${"░".repeat(Math.max(0, DEPENDENCY_PROGRESS_WIDTH - Math.max(1, filled)))}`;
+};
+export const dependencyLine = (dependency, labelWidth, spinnerFrame = 0) => {
+    const glyph = dependencyGlyph(dependency.state, spinnerFrame);
+    const marker = `${" ".repeat(Math.max(0, DEPENDENCY_MARKER_WIDTH - stringWidth(glyph)))}${glyph}`;
+    const paddedLabel = dependency.label + " ".repeat(Math.max(0, labelWidth - stringWidth(dependency.label) + 1));
+    const suffix = dependency.state === "installing"
+        ? dependencyProgressBar(dependency.progress, spinnerFrame)
+        : dependency.version || dependency.error || "";
+    return [
+        { text: `${marker} ${paddedLabel}`, color: dependencyColor(dependency.state), bold: dependency.state === "failed", preserveColorWhenSelected: true },
+        { text: suffix ? ` ${suffix}` : "", color: dependency.state === "failed" ? "#ef4444" : dependency.state === "installing" ? "#808791" : PANEL_PRIMARY },
+    ];
+};
+export const ExtensionPanelOverlay = ({ panel, selectedIndex, width, input = "", setInput = () => undefined, onSubmit = () => undefined, inputFocus = false, }) => {
+    if (!panel)
+        return null;
+    if (panel.view === "list") {
+        const items = panel.extensions.map((extension) => ({
+            key: extension.id,
+            segments: [
+                { text: `${extensionSignal(extension)} `, color: SIGNAL_COLORS[extension.signal], preserveColorWhenSelected: true },
+                { text: `${extension.name.padEnd(EXTENSION_NAME_WIDTH, " ")} `, color: PANEL_PRIMARY },
+                { text: extension.description, color: PANEL_SECONDARY },
+            ],
+        }));
+        return (_jsx(PanelFrame, { width: width, title: panel.title, hint: panel.hint || "↑/↓ select · Enter open · Esc close", children: _jsx(PanelChoiceList, { items: items, selectedIndex: selectedIndex, width: width }) }));
+    }
+    if (panel.view === "setup" && panel.setup) {
+        return _jsx(ExtensionSetupPanel, { setup: panel.setup, width: width, selectedIndex: selectedIndex, input: input, setInput: setInput, onSubmit: onSubmit, inputFocus: inputFocus });
+    }
+    const detail = panel.detail;
+    const extension = panel.extensions.find((item) => item.id === panel.selectedExtension) || panel.extensions[selectedIndex];
+    if (!detail || !extension)
+        return null;
+    const actions = (detail.actions ?? []).map((action) => {
+        if (action === "confirm_reset") {
+            return { key: action, segments: [
+                    { text: "Insist", color: "#ef4444", bold: true, preserveColorWhenSelected: true },
+                    { text: "  local credentials will be deleted", color: "#facc15", preserveColorWhenSelected: true },
+                ] };
+        }
+        if (action === "confirm_restart") {
+            return { key: action, segments: [
+                    { text: "Restart", color: "#facc15", bold: true, preserveColorWhenSelected: true },
+                    { text: "  configuration will be applied", color: PANEL_SECONDARY, preserveColorWhenSelected: true },
+                ] };
+        }
+        return {
+            key: action,
+            selectedColor: action === "prepare_reset" ? "#ef4444" : undefined,
+            segments: [{
+                    text: extensionActionLabel(action),
+                    color: extensionActionColor(action),
+                    bold: extensionActionBold(action),
+                    preserveColorWhenSelected: !["disable", "setup", "prepare_reset"].includes(action),
+                }],
+        };
+    });
+    const signalColor = SIGNAL_COLORS[extension.signal];
+    return (_jsxs(PanelFrame, { width: width, title: `${extensionSignal(extension)} ${extension.name}`, titleSegments: [
+            { text: extensionSignal(extension), color: signalColor, bold: true },
+            { text: ` ${extension.name}`, color: "#c8a6ff", bold: true },
+        ], hint: panel.hint || "↑/↓ select · Enter act · Esc back", children: [_jsx(PanelRow, { width: width, segments: [{ text: `Status       ${statusLabel(detail.status)}`, color: detail.status === "waiting" ? PANEL_SECONDARY : PANEL_PRIMARY }] }), _jsx(PanelRow, { width: width, segments: [
+                    { text: "Tag          ", color: PANEL_PRIMARY },
+                    { text: extension.tags.join(" · "), color: "#183b8c", italic: true },
+                ] }), _jsx(PanelChoiceList, { items: actions, selectedIndex: selectedIndex, width: width })] }));
+};
+const ExtensionSetupPanel = ({ setup, width, selectedIndex, input, setInput, onSubmit, inputFocus, }) => {
+    const [spinnerFrame, setSpinnerFrame] = React.useState(0);
+    React.useEffect(() => {
+        if (!setup.dependencies?.some((dependency) => dependency.state === "installing"))
+            return;
+        const timer = setInterval(() => setSpinnerFrame((frame) => frame + 1), 100);
+        return () => clearInterval(timer);
+    }, [setup.dependencies]);
+    return (_jsxs(PanelFrame, { width: width, title: setup.title, hint: "\u2190/\u2192 page \u00B7 Enter submit \u00B7 Esc back", children: [setup.body ? setup.body.split("\n").map((line, index) => (_jsx(PanelRow, { width: width, segments: [{ text: line, color: setup.dependencies ? PANEL_SECONDARY : PANEL_PRIMARY }] }, `${index}-${line}`))) : null, setup.dependencies ? (_jsx(_Fragment, { children: _jsx(PanelChoiceList, { items: setup.dependencies.map((dependency) => ({
+                        key: dependency.id,
+                        segments: dependencyLine(dependency, Math.max(...setup.dependencies.map((item) => stringWidth(item.label))), spinnerFrame),
+                    })), selectedIndex: selectedIndex, width: width }) })) : null, setup.error ? _jsx(PanelRow, { width: width, segments: [{ text: setup.error, color: "#ff6b6b" }] }) : null, setup.input ? (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: PANEL_PRIMARY, children: _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, focus: inputFocus, showCursor: false, placeholder: setup.input.placeholder, mask: setup.input.mask ? "*" : undefined }) }) })) : null, _jsx(PanelRow, { width: width, segments: [{ text: `${setup.page}/${setup.page_count}`, color: PANEL_SECONDARY }] })] }));
+};

package/dist/format.js

@@ -0,0 +1,99 @@
+import stringWidth from 'string-width';
+/**
+ * Coordinates the format duration operation for the CLI UI runtime.
+ *
+ * @param ms Input value used by the format duration operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function formatDuration(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = (totalSeconds % 60).toString().padStart(2, "0");
+    return `${minutes}:${seconds}`;
+}
+export function formatMiniTrackSubtitle(artist, album) {
+    return [artist, album]
+        .map((value) => value.trim())
+        .filter((value) => value && value !== '-')
+        .join('-');
+}
+const MUSIC_CANDIDATE_ARTIST_WIDTH = 24;
+const MUSIC_CANDIDATE_ALBUM_WIDTH = 32;
+const ELLIPSIS = "...";
+export function fitDisplayWidthWithEllipsis(value, width) {
+    const normalized = value.trim() || "-";
+    if (stringWidth(normalized) <= width) {
+        return normalized + " ".repeat(Math.max(0, width - stringWidth(normalized)));
+    }
+    const contentWidth = Math.max(0, width - stringWidth(ELLIPSIS));
+    let rendered = "";
+    let renderedWidth = 0;
+    for (const char of Array.from(normalized)) {
+        const charWidth = stringWidth(char);
+        if (renderedWidth + charWidth > contentWidth)
+            break;
+        rendered += char;
+        renderedWidth += charWidth;
+    }
+    const result = `${rendered}${ELLIPSIS}`;
+    return result + " ".repeat(Math.max(0, width - stringWidth(result)));
+}
+function truncateDisplayWidthWithEllipsis(value, width) {
+    const normalized = value.trim() || "-";
+    if (width <= 0)
+        return "";
+    if (stringWidth(normalized) <= width)
+        return normalized;
+    const contentWidth = Math.max(0, width - stringWidth(ELLIPSIS));
+    let rendered = "";
+    let renderedWidth = 0;
+    for (const char of Array.from(normalized)) {
+        const charWidth = stringWidth(char);
+        if (renderedWidth + charWidth > contentWidth)
+            break;
+        rendered += char;
+        renderedWidth += charWidth;
+    }
+    return `${rendered}${ELLIPSIS}`;
+}
+export function formatMusicCandidateDisplayLabel(display, rowWidth, trailingText) {
+    const prefix = [
+        fitDisplayWidthWithEllipsis(display.artist, MUSIC_CANDIDATE_ARTIST_WIDTH),
+        fitDisplayWidthWithEllipsis(display.album, MUSIC_CANDIDATE_ALBUM_WIDTH),
+    ].join(" ");
+    const title = display.title.trim() || "-";
+    if (typeof rowWidth !== "number") {
+        return `${prefix} ${title}`;
+    }
+    const providerText = trailingText?.trim() ?? "";
+    if (providerText) {
+        const titlePrefix = `${prefix} `;
+        const providerMaxWidth = Math.max(0, rowWidth - stringWidth(titlePrefix) - 1);
+        const provider = truncateDisplayWidthWithEllipsis(providerText, providerMaxWidth);
+        const titleWidth = Math.max(0, rowWidth - stringWidth(titlePrefix) - stringWidth(provider) - 1);
+        const renderedTitle = truncateDisplayWidthWithEllipsis(title, titleWidth);
+        const gapWidth = Math.max(1, rowWidth - stringWidth(titlePrefix) - stringWidth(renderedTitle) - stringWidth(provider));
+        return `${titlePrefix}${renderedTitle}${" ".repeat(gapWidth)}${provider}`;
+    }
+    const titleWidth = Math.max(0, rowWidth - stringWidth(prefix) - 1);
+    return `${prefix} ${truncateDisplayWidthWithEllipsis(title, titleWidth)}`;
+}
+/**
+ * Coordinates the build progress bar operation for the CLI UI runtime.
+ *
+ * @param progressMs Input value used by the build progress bar operation.
+ * @param durationMs Input value used by the build progress bar operation.
+ * @param width Input value used by the build progress bar operation.
+ * @returns The computed result for the surrounding CLI UI flow.
+ */
+export function buildProgressBar(progressMs, durationMs, width = 18) {
+    if (durationMs <= 0)
+        return "─".repeat(width);
+    const ratio = Math.min(1, Math.max(0, progressMs / durationMs));
+    const exact = ratio * width;
+    const filled = Math.floor(exact);
+    if (filled >= width)
+        return "━".repeat(width);
+    const partial = exact - filled >= 0.5 ? "╸" : "";
+    return "━".repeat(filled) + partial + "─".repeat(width - filled - partial.length);
+}