snow-ai 0.4.16 → 0.4.18

package/dist/ui/components/PendingMessages.js

@@ -1,29 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { useTheme } from '../contexts/ThemeContext.js';
-export default function PendingMessages({ pendingMessages }) {
-    const { theme } = useTheme();
-    if (pendingMessages.length === 0) {
-        return null;
-    }
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.colors.warning, paddingX: 1 },
-        React.createElement(Text, { color: theme.colors.warning, bold: true },
-            "\u2B11 Pending Messages (",
-            pendingMessages.length,
-            ")"),
-        pendingMessages.map((message, index) => (React.createElement(Box, { key: index, marginLeft: 1, marginY: 0, flexDirection: "column" },
-            React.createElement(Box, null,
-                React.createElement(Text, { color: "blue", bold: true },
-                    index + 1,
-                    "."),
-                React.createElement(Box, { marginLeft: 1 },
-                    React.createElement(Text, { color: theme.colors.menuSecondary }, message.text.length > 60 ? `${message.text.substring(0, 60)}...` : message.text))),
-            message.images && message.images.length > 0 && (React.createElement(Box, { marginLeft: 3 },
-                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                    "\u2514\u2500 ",
-                    message.images.length,
-                    " image",
-                    message.images.length > 1 ? 's' : '',
-                    " attached")))))),
-        React.createElement(Text, { color: theme.colors.warning, dimColor: true }, "Will be sent after tool execution completes")));
-}

package/dist/ui/components/PendingToolCalls.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { Message } from './MessageList.js';
-interface Props {
-    messages: Message[];
-}
-/**
- * 显示正在执行的工具调用(只显示耗时工具)
- * 这些消息有 toolPending: true 标记
- */
-export default function PendingToolCalls({ messages }: Props): React.JSX.Element | null;
-export {};

package/dist/ui/components/PendingToolCalls.js

@@ -1,35 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import Spinner from 'ink-spinner';
-/**
- * 显示正在执行的工具调用(只显示耗时工具)
- * 这些消息有 toolPending: true 标记
- */
-export default function PendingToolCalls({ messages }) {
-    // 筛选出正在执行的工具调用消息
-    const pendingTools = messages.filter(msg => msg.role === 'assistant' && msg.toolPending === true);
-    if (pendingTools.length === 0) {
-        return null;
-    }
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 },
-        React.createElement(Text, { color: "cyan", bold: true },
-            React.createElement(Spinner, { type: "dots" }),
-            " Executing Tools (",
-            pendingTools.length,
-            ")"),
-        pendingTools.map((tool, index) => (React.createElement(Box, { key: index, marginLeft: 1, marginY: 0 },
-            React.createElement(Text, { color: "yellow", bold: true },
-                index + 1,
-                "."),
-            React.createElement(Box, { marginLeft: 1 },
-                React.createElement(Text, { color: "gray" }, tool.content)),
-            tool.toolDisplay && tool.toolDisplay.args.length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
-                tool.toolDisplay.args.slice(0, 3).map((arg, argIndex) => (React.createElement(Text, { key: argIndex, color: "gray", dimColor: true },
-                    arg.key,
-                    ": ",
-                    arg.value.length > 50 ? `${arg.value.substring(0, 50)}...` : arg.value))),
-                tool.toolDisplay.args.length > 3 && (React.createElement(Text, { color: "gray", dimColor: true },
-                    "... and ",
-                    tool.toolDisplay.args.length - 3,
-                    " more args")))))))));
-}

package/dist/ui/components/ScrollableSelectInput.d.ts

@@ -1,29 +0,0 @@
-import React from 'react';
-type SelectItem = {
-    label: string;
-    value: string;
-    key?: string;
-    [index: string]: unknown;
-};
-type IndicatorProps = {
-    isSelected: boolean;
-};
-type RenderItemProps<T extends SelectItem> = T & {
-    isSelected: boolean;
-    isMarked: boolean;
-};
-type Props<T extends SelectItem> = {
-    items: readonly T[];
-    limit?: number;
-    initialIndex?: number;
-    isFocused?: boolean;
-    indicator?: (props: IndicatorProps) => React.ReactNode;
-    renderItem?: (props: RenderItemProps<T>) => React.ReactNode;
-    onSelect?: (item: T) => void;
-    onHighlight?: (item: T) => void;
-    selectedValues?: ReadonlySet<string> | readonly string[];
-    onToggleItem?: (item: T) => void;
-    onDeleteSelection?: () => void;
-};
-export default function ScrollableSelectInput<T extends SelectItem>({ items, limit, initialIndex, isFocused, indicator, renderItem, onSelect, onHighlight, selectedValues, onToggleItem, onDeleteSelection }: Props<T>): React.JSX.Element | null;
-export {};

package/dist/ui/components/ScrollableSelectInput.js

@@ -1,157 +0,0 @@
-import React, { useState, useMemo, useEffect, useCallback } from 'react';
-import { Box, Text, useInput } from 'ink';
-function DefaultIndicator({ isSelected }) {
-    return (React.createElement(Box, { marginRight: 1 },
-        React.createElement(Text, { color: isSelected ? 'cyan' : 'gray' }, isSelected ? '>' : ' ')));
-}
-function DefaultItem({ label, isSelected }) {
-    return React.createElement(Text, { color: isSelected ? 'cyan' : 'white' }, label);
-}
-export default function ScrollableSelectInput({ items, limit, initialIndex = 0, isFocused = true, indicator = DefaultIndicator, renderItem, onSelect, onHighlight, selectedValues, onToggleItem, onDeleteSelection }) {
-    const totalItems = items.length;
-    const windowSize = totalItems === 0 ? 0 : Math.min(Math.max(limit ?? totalItems, 1), totalItems);
-    const selectedValueSet = useMemo(() => {
-        if (!selectedValues) {
-            return new Set();
-        }
-        if (selectedValues instanceof Set) {
-            return selectedValues;
-        }
-        return new Set(selectedValues);
-    }, [selectedValues]);
-    const clampCursor = useCallback((value) => {
-        if (totalItems === 0) {
-            return 0;
-        }
-        if (value < 0) {
-            return 0;
-        }
-        if (value > totalItems - 1) {
-            return totalItems - 1;
-        }
-        return value;
-    }, [totalItems]);
-    const computeOffset = useCallback((currentOffset, targetCursor) => {
-        if (totalItems === 0 || windowSize === 0) {
-            return 0;
-        }
-        const maxOffset = Math.max(0, totalItems - windowSize);
-        let nextOffset = Math.min(Math.max(currentOffset, 0), maxOffset);
-        if (targetCursor < nextOffset) {
-            nextOffset = targetCursor;
-        }
-        else if (targetCursor >= nextOffset + windowSize) {
-            nextOffset = targetCursor - windowSize + 1;
-        }
-        return Math.min(Math.max(nextOffset, 0), maxOffset);
-    }, [totalItems, windowSize]);
-    const [cursor, setCursor] = useState(() => clampCursor(initialIndex));
-    const [offset, setOffset] = useState(() => computeOffset(clampCursor(initialIndex), clampCursor(initialIndex)));
-    useEffect(() => {
-        if (totalItems === 0) {
-            if (cursor !== 0) {
-                setCursor(0);
-            }
-            if (offset !== 0) {
-                setOffset(0);
-            }
-            return;
-        }
-        const clampedCursor = clampCursor(cursor);
-        if (clampedCursor !== cursor) {
-            setCursor(clampedCursor);
-            return;
-        }
-        const clampedOffset = computeOffset(offset, clampedCursor);
-        if (clampedOffset !== offset) {
-            setOffset(clampedOffset);
-        }
-    }, [clampCursor, computeOffset, cursor, offset, totalItems]);
-    const visibleItems = useMemo(() => {
-        if (windowSize === 0) {
-            return [];
-        }
-        return items.slice(offset, offset + windowSize);
-    }, [items, offset, windowSize]);
-    const selectedItem = totalItems === 0 ? undefined : items[cursor];
-    useEffect(() => {
-        if (selectedItem && onHighlight) {
-            onHighlight(selectedItem);
-        }
-    }, [onHighlight, selectedItem]);
-    const moveCursor = useCallback((direction) => {
-        if (totalItems === 0) {
-            return;
-        }
-        setCursor(previousCursor => {
-            const nextCursor = clampCursor(previousCursor + direction);
-            if (nextCursor === previousCursor) {
-                return previousCursor;
-            }
-            setOffset(previousOffset => computeOffset(previousOffset, nextCursor));
-            return nextCursor;
-        });
-    }, [clampCursor, computeOffset, totalItems]);
-    const selectIndex = useCallback((targetIndex) => {
-        if (totalItems === 0) {
-            return;
-        }
-        const boundedIndex = clampCursor(targetIndex);
-        setCursor(boundedIndex);
-        setOffset(previousOffset => computeOffset(previousOffset, boundedIndex));
-        const item = items[boundedIndex];
-        if (item) {
-            onSelect?.(item);
-        }
-    }, [clampCursor, computeOffset, items, onSelect, totalItems]);
-    const handleInput = useCallback((input, key) => {
-        if (!isFocused || totalItems === 0) {
-            return;
-        }
-        if (key['upArrow']) {
-            moveCursor(-1);
-            return;
-        }
-        if (key['downArrow']) {
-            moveCursor(1);
-            return;
-        }
-        if (key['return'] && selectedItem) {
-            onSelect?.(selectedItem);
-            return;
-        }
-        if (input === ' ' && selectedItem) {
-            onToggleItem?.(selectedItem);
-            return;
-        }
-        if ((input === 'd' || input === 'D') && onDeleteSelection) {
-            onDeleteSelection();
-            return;
-        }
-        if (/^[1-9]$/.test(input) && windowSize > 0) {
-            const target = Number.parseInt(input, 10) - 1;
-            if (target >= 0 && target < visibleItems.length) {
-                selectIndex(offset + target);
-            }
-        }
-    }, [isFocused, moveCursor, offset, onDeleteSelection, onSelect, onToggleItem, selectIndex, selectedItem, totalItems, visibleItems.length, windowSize]);
-    useInput(handleInput, { isActive: isFocused });
-    if (windowSize === 0) {
-        return null;
-    }
-    const renderRow = useCallback((row) => {
-        if (renderItem) {
-            return renderItem(row);
-        }
-        return DefaultItem(row);
-    }, [renderItem]);
-    return (React.createElement(Box, { flexDirection: "column" }, visibleItems.map((item, index) => {
-        const absoluteIndex = offset + index;
-        const isSelected = absoluteIndex === cursor;
-        const isMarked = selectedValueSet.has(item.value);
-        const key = (item.key ?? item.value);
-        return (React.createElement(Box, { key: key },
-            indicator({ isSelected }),
-            renderRow({ ...item, isSelected, isMarked })));
-    })));
-}

package/dist/ui/components/SessionListPanel.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-type Props = {
-    onSelectSession: (sessionId: string) => void;
-    onClose: () => void;
-};
-export default function SessionListPanel({ onSelectSession, onClose }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/SessionListPanel.js

@@ -1,175 +0,0 @@
-import React, { useState, useEffect, useCallback } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { sessionManager, } from '../../utils/sessionManager.js';
-export default function SessionListPanel({ onSelectSession, onClose }) {
-    const [sessions, setSessions] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [scrollOffset, setScrollOffset] = useState(0);
-    const [markedSessions, setMarkedSessions] = useState(new Set());
-    const VISIBLE_ITEMS = 5; // Number of items to show at once
-    // Load sessions on mount
-    useEffect(() => {
-        const loadSessions = async () => {
-            setLoading(true);
-            try {
-                const sessionList = await sessionManager.listSessions();
-                setSessions(sessionList);
-            }
-            catch (error) {
-                console.error('Failed to load sessions:', error);
-                setSessions([]);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        void loadSessions();
-    }, []);
-    // Format date to relative time
-    const formatDate = useCallback((timestamp) => {
-        const date = new Date(timestamp);
-        const now = new Date();
-        const diffMs = now.getTime() - date.getTime();
-        const diffMinutes = Math.floor(diffMs / (1000 * 60));
-        const diffHours = Math.floor(diffMinutes / 60);
-        const diffDays = Math.floor(diffHours / 24);
-        if (diffMinutes < 1)
-            return 'now';
-        if (diffMinutes < 60)
-            return `${diffMinutes}m`;
-        if (diffHours < 24)
-            return `${diffHours}h`;
-        if (diffDays < 7)
-            return `${diffDays}d`;
-        return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
-    }, []);
-    // Handle keyboard input
-    useInput((input, key) => {
-        if (loading)
-            return;
-        if (key.escape) {
-            onClose();
-            return;
-        }
-        if (key.upArrow) {
-            setSelectedIndex(prev => {
-                const newIndex = Math.max(0, prev - 1);
-                // Adjust scroll offset if needed
-                if (newIndex < scrollOffset) {
-                    setScrollOffset(newIndex);
-                }
-                return newIndex;
-            });
-            return;
-        }
-        if (key.downArrow) {
-            setSelectedIndex(prev => {
-                const newIndex = Math.min(sessions.length - 1, prev + 1);
-                // Adjust scroll offset if needed
-                if (newIndex >= scrollOffset + VISIBLE_ITEMS) {
-                    setScrollOffset(newIndex - VISIBLE_ITEMS + 1);
-                }
-                return newIndex;
-            });
-            return;
-        }
-        // Space to toggle mark
-        if (input === ' ') {
-            const currentSession = sessions[selectedIndex];
-            if (currentSession) {
-                setMarkedSessions(prev => {
-                    const next = new Set(prev);
-                    if (next.has(currentSession.id)) {
-                        next.delete(currentSession.id);
-                    }
-                    else {
-                        next.add(currentSession.id);
-                    }
-                    return next;
-                });
-            }
-            return;
-        }
-        // D to delete marked sessions
-        if (input === 'd' || input === 'D') {
-            if (markedSessions.size > 0) {
-                const deleteMarked = async () => {
-                    const ids = Array.from(markedSessions);
-                    await Promise.all(ids.map(id => sessionManager.deleteSession(id)));
-                    // Reload sessions
-                    const sessionList = await sessionManager.listSessions();
-                    setSessions(sessionList);
-                    setMarkedSessions(new Set());
-                    // Reset selection if needed
-                    if (selectedIndex >= sessionList.length && sessionList.length > 0) {
-                        setSelectedIndex(sessionList.length - 1);
-                    }
-                };
-                void deleteMarked();
-            }
-            return;
-        }
-        if (key.return && sessions.length > 0) {
-            const selectedSession = sessions[selectedIndex];
-            if (selectedSession) {
-                onSelectSession(selectedSession.id);
-            }
-            return;
-        }
-    });
-    if (loading) {
-        return (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
-            React.createElement(Text, { color: "gray", dimColor: true }, "Loading sessions...")));
-    }
-    if (sessions.length === 0) {
-        return (React.createElement(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1 },
-            React.createElement(Text, { color: "gray", dimColor: true }, "No conversations found \u2022 Press ESC to close")));
-    }
-    // Calculate visible sessions based on scroll offset
-    const visibleSessions = sessions.slice(scrollOffset, scrollOffset + VISIBLE_ITEMS);
-    const hasMore = sessions.length > scrollOffset + VISIBLE_ITEMS;
-    const hasPrevious = scrollOffset > 0;
-    const currentSession = sessions[selectedIndex];
-    return (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column" },
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "cyan", dimColor: true },
-                "Resume (",
-                selectedIndex + 1,
-                "/",
-                sessions.length,
-                ")",
-                currentSession && ` • ${currentSession.messageCount} msgs`,
-                markedSessions.size > 0 && (React.createElement(Text, { color: "yellow" },
-                    " \u2022 ",
-                    markedSessions.size,
-                    " marked"))),
-            React.createElement(Text, { color: "gray", dimColor: true }, "\u2191\u2193 navigate \u2022 Space mark \u2022 D delete \u2022 Enter select \u2022 ESC close")),
-        hasPrevious && (React.createElement(Text, { color: "gray", dimColor: true },
-            ' ',
-            "\u2191 ",
-            scrollOffset,
-            " more above")),
-        visibleSessions.map((session, index) => {
-            const actualIndex = scrollOffset + index;
-            const isSelected = actualIndex === selectedIndex;
-            const isMarked = markedSessions.has(session.id);
-            // Remove newlines and other whitespace characters from title
-            const cleanTitle = (session.title || 'Untitled').replace(/[\r\n\t]+/g, ' ');
-            const timeStr = formatDate(session.updatedAt);
-            const truncatedLabel = cleanTitle.length > 50 ? cleanTitle.slice(0, 47) + '...' : cleanTitle;
-            return (React.createElement(Box, { key: session.id },
-                React.createElement(Text, { color: isMarked ? 'green' : 'gray' }, isMarked ? '✔ ' : '  '),
-                React.createElement(Text, { color: isSelected ? 'green' : 'gray' }, isSelected ? '❯ ' : '  '),
-                React.createElement(Text, { color: isSelected ? 'cyan' : isMarked ? 'green' : 'white' }, truncatedLabel),
-                React.createElement(Text, { color: "gray", dimColor: true },
-                    ' ',
-                    "\u2022 ",
-                    timeStr)));
-        }),
-        hasMore && (React.createElement(Text, { color: "gray", dimColor: true },
-            ' ',
-            "\u2193 ",
-            sessions.length - scrollOffset - VISIBLE_ITEMS,
-            " more below"))));
-}

package/dist/ui/components/SessionListScreen.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-type Props = {
-    onBack: () => void;
-    onSelectSession: (sessionId: string) => void;
-};
-export default function SessionListScreen({ onBack, onSelectSession }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/SessionListScreen.js

@@ -1,217 +0,0 @@
-import React, { useState, useEffect, useMemo, useCallback } from 'react';
-import { Box, Text, useInput, useStdout } from 'ink';
-import Gradient from 'ink-gradient';
-import { Alert } from '@inkjs/ui';
-import ScrollableSelectInput from './ScrollableSelectInput.js';
-import { sessionManager, } from '../../utils/sessionManager.js';
-export default function SessionListScreen({ onBack, onSelectSession }) {
-    const [sessions, setSessions] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState('');
-    const [selectedSessions, setSelectedSessions] = useState(new Set());
-    const [actionMessage, setActionMessage] = useState(null);
-    const { stdout } = useStdout();
-    const loadSessions = useCallback(async () => {
-        setLoading(true);
-        setError('');
-        try {
-            const sessionList = await sessionManager.listSessions();
-            setSessions(sessionList);
-            setSelectedSessions(new Set());
-            setActionMessage(null);
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to load sessions');
-        }
-        finally {
-            setLoading(false);
-        }
-    }, []);
-    useEffect(() => {
-        void loadSessions();
-    }, [loadSessions]);
-    const formatDate = useCallback((timestamp) => {
-        const date = new Date(timestamp);
-        const now = new Date();
-        const diffMs = now.getTime() - date.getTime();
-        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-        const diffDays = Math.floor(diffHours / 24);
-        if (diffHours < 1) {
-            const diffMinutes = Math.floor(diffMs / (1000 * 60));
-            return diffMinutes < 1 ? 'Just now' : `${diffMinutes}m ago`;
-        }
-        else if (diffHours < 24) {
-            return `${diffHours}h ago`;
-        }
-        else if (diffDays < 7) {
-            return `${diffDays}d ago`;
-        }
-        else {
-            return date.toLocaleDateString();
-        }
-    }, []);
-    // Create select items with truncated labels
-    const selectItems = useMemo(() => {
-        const terminalWidth = stdout?.columns || 80;
-        // Reserve space for indicators (✔ + ❯ + spacing) and margins
-        const reservedSpace = 30;
-        const maxLabelWidth = Math.max(30, terminalWidth - reservedSpace);
-        return sessions.map(session => {
-            const timeString = formatDate(session.updatedAt);
-            // Remove newlines and other whitespace characters from title
-            const title = (session.title || 'Untitled').replace(/[\r\n\t]+/g, ' ');
-            // Format: "Title • 5 msgs • 2h ago"
-            const messageInfo = `${session.messageCount} msg${session.messageCount !== 1 ? 's' : ''}`;
-            const fullLabel = `${title} • ${messageInfo} • ${timeString}`;
-            // Truncate if too long - prioritize showing the title
-            let truncatedLabel = fullLabel;
-            if (fullLabel.length > maxLabelWidth) {
-                const ellipsis = '...';
-                const suffixLength = messageInfo.length + timeString.length + 6; // " • " x2 + "..."
-                const availableForTitle = maxLabelWidth - suffixLength - ellipsis.length;
-                if (availableForTitle > 10) {
-                    const truncatedTitle = title.substring(0, availableForTitle);
-                    truncatedLabel = `${truncatedTitle}${ellipsis} • ${messageInfo} • ${timeString}`;
-                }
-                else {
-                    // If terminal is too narrow, just truncate the whole thing
-                    truncatedLabel =
-                        fullLabel.substring(0, maxLabelWidth - ellipsis.length) + ellipsis;
-                }
-            }
-            return {
-                label: truncatedLabel,
-                value: session.id,
-                isMarked: selectedSessions.has(session.id),
-            };
-        });
-    }, [sessions, formatDate, stdout?.columns, selectedSessions]);
-    const handleSelect = useCallback((item) => {
-        onSelectSession(item.value);
-    }, [onSelectSession]);
-    const handleToggleItem = useCallback((item) => {
-        setSelectedSessions(previous => {
-            const next = new Set(previous);
-            if (next.has(item.value)) {
-                next.delete(item.value);
-            }
-            else {
-                next.add(item.value);
-            }
-            return next;
-        });
-        setActionMessage(null);
-    }, []);
-    const handleDeleteSelected = useCallback(async () => {
-        if (selectedSessions.size === 0) {
-            setActionMessage({ type: 'info', text: 'No conversations selected.' });
-            return;
-        }
-        const ids = Array.from(selectedSessions);
-        const deletionResults = await Promise.all(ids.map(async (id) => ({
-            id,
-            success: await sessionManager.deleteSession(id),
-        })));
-        const succeededIds = deletionResults
-            .filter(result => result.success)
-            .map(result => result.id);
-        const failedIds = deletionResults
-            .filter(result => !result.success)
-            .map(result => result.id);
-        if (succeededIds.length > 0) {
-            setSessions(previous => previous.filter(session => !succeededIds.includes(session.id)));
-            setSelectedSessions(previous => {
-                const next = new Set(previous);
-                for (const id of succeededIds) {
-                    next.delete(id);
-                }
-                return next;
-            });
-        }
-        if (failedIds.length > 0) {
-            setActionMessage({
-                type: 'error',
-                text: `Failed to delete ${failedIds.length} conversation${failedIds.length > 1 ? 's' : ''}.`,
-            });
-        }
-        else if (succeededIds.length > 0) {
-            setActionMessage({
-                type: 'info',
-                text: `Deleted ${succeededIds.length} conversation${succeededIds.length > 1 ? 's' : ''}.`,
-            });
-        }
-        else {
-            setActionMessage({ type: 'info', text: 'No conversations deleted.' });
-        }
-    }, [selectedSessions]);
-    const handleInput = useCallback((input, key) => {
-        if (key.escape) {
-            onBack();
-            return;
-        }
-        if (input === 'r' || input === 'R') {
-            void loadSessions();
-        }
-    }, [loadSessions, onBack]);
-    useInput(handleInput);
-    if (loading) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Gradient, { name: "rainbow" }, "Resume Conversation"),
-                    React.createElement(Text, { color: "gray", dimColor: true }, "Loading your conversation history...")))));
-    }
-    if (error) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "red", paddingX: 2, paddingY: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Gradient, { name: "rainbow" }, "Resume Conversation"),
-                    React.createElement(Text, { color: "gray", dimColor: true }, "Select a conversation to resume"))),
-            React.createElement(Box, { marginBottom: 2 },
-                React.createElement(Alert, { variant: "error" }, error)),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Alert, { variant: "info" }, "Press Esc to return, or R to retry"))));
-    }
-    if (sessions.length === 0) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Gradient, { name: "rainbow" }, "Resume Conversation"),
-                    React.createElement(Text, { color: "gray", dimColor: true }, "No conversations found"))),
-            React.createElement(Box, { marginBottom: 2 },
-                React.createElement(Alert, { variant: "info" }, "No previous conversations found. Start a new conversation to create your first session.")),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Alert, { variant: "info" }, "Press Esc to return to chat"))));
-    }
-    // Calculate available height for the list with safer bounds
-    const terminalHeight = stdout?.rows || 24;
-    const headerHeight = 7; // Header box height (including borders and padding)
-    const footerHeight = 4; // Footer info height (including margins)
-    const availableHeight = Math.max(5, terminalHeight - headerHeight - footerHeight);
-    const maxVisibleSessions = 10;
-    const desiredListSize = Math.max(3, Math.min(maxVisibleSessions, availableHeight));
-    const listLimit = Math.min(selectItems.length, desiredListSize);
-    const containerHeight = terminalHeight > 2 ? terminalHeight - 2 : undefined;
-    return (React.createElement(Box, { flexDirection: "column", padding: 1, height: containerHeight },
-        React.createElement(Box, { marginBottom: 1, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Gradient, { name: "rainbow" }, "Resume Conversation"),
-                React.createElement(Text, { color: "gray", dimColor: true },
-                    sessions.length,
-                    " conversation",
-                    sessions.length !== 1 ? 's' : '',
-                    ' ',
-                    "available"))),
-        React.createElement(Box, { marginBottom: 1, flexShrink: 0 },
-            React.createElement(ScrollableSelectInput, { items: selectItems, limit: listLimit, onSelect: handleSelect, onToggleItem: handleToggleItem, onDeleteSelection: handleDeleteSelected, selectedValues: selectedSessions, indicator: ({ isSelected }) => (React.createElement(Text, { color: isSelected ? 'green' : 'gray' }, isSelected ? '❯ ' : '  ')), renderItem: ({ isSelected, isMarked, label }) => (React.createElement(Text, null,
-                    React.createElement(Text, { color: isMarked ? 'green' : 'gray' }, isMarked ? '✔ ' : '  '),
-                    React.createElement(Text, { color: isMarked ? 'green' : isSelected ? 'cyan' : 'white' }, label))) })),
-        React.createElement(Box, { flexDirection: "column", flexShrink: 0 },
-            actionMessage ? (React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Alert, { variant: actionMessage.type }, actionMessage.text))) : null,
-            React.createElement(Alert, { variant: "info" },
-                "\u2191\u2193 navigate \u2022 Space mark \u2022 D delete \u2022 Enter select \u2022 Esc return \u2022 R refresh",
-                selectedSessions.size > 0
-                    ? ` • ${selectedSessions.size} selected`
-                    : ''))));
-}