snow-ai 0.4.16 → 0.4.18

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

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

package/dist/ui/components/SessionListScreenWrapper.js

@@ -1,14 +0,0 @@
-import React, { useEffect } from 'react';
-import SessionListScreen from './SessionListScreen.js';
-export default function SessionListScreenWrapper({ onBack, onSelectSession }) {
-    useEffect(() => {
-        process.stdout.write('\x1B[?1049h');
-        process.stdout.write('\x1B[2J');
-        process.stdout.write('\x1B[H');
-        return () => {
-            process.stdout.write('\x1B[2J');
-            process.stdout.write('\x1B[?1049l');
-        };
-    }, []);
-    return (React.createElement(SessionListScreen, { onBack: onBack, onSelectSession: onSelectSession }));
-}

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

@@ -1,9 +0,0 @@
-import React from 'react';
-interface ShimmerTextProps {
-    text: string;
-}
-/**
- * ShimmerText component that displays text with a white shimmer effect flowing through yellow text
- */
-export default function ShimmerText({ text }: ShimmerTextProps): React.JSX.Element;
-export {};

package/dist/ui/components/ShimmerText.js

@@ -1,30 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Text } from 'ink';
-import chalk from 'chalk';
-/**
- * ShimmerText component that displays text with a white shimmer effect flowing through yellow text
- */
-export default function ShimmerText({ text }) {
-    const [frame, setFrame] = useState(0);
-    useEffect(() => {
-        const interval = setInterval(() => {
-            setFrame(prev => (prev + 1) % (text.length + 5));
-        }, 100); // Update every 100ms for smooth animation
-        return () => clearInterval(interval);
-    }, [text.length]);
-    // Build the colored text with shimmer effect
-    let output = '';
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        const distance = Math.abs(i - frame);
-        // Bright cyan shimmer in the center (distance 0-1)
-        if (distance <= 1) {
-            output += chalk.hex('#00FFFF')(char); // Bright cyan/aqua
-        }
-        // Deep blue for the rest (base color)
-        else {
-            output += chalk.hex('#1ACEB0')(char); // Steel blue
-        }
-    }
-    return React.createElement(Text, null, output);
-}

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

@@ -1,14 +0,0 @@
-import React from 'react';
-import type { TodoItem } from '../../utils/todoScanner.js';
-interface Props {
-    todos: TodoItem[];
-    selectedIndex: number;
-    selectedTodos: Set<string>;
-    visible: boolean;
-    maxHeight?: number;
-    isLoading?: boolean;
-    searchQuery?: string;
-    totalCount?: number;
-}
-declare const TodoPickerPanel: React.MemoExoticComponent<({ todos, selectedIndex, selectedTodos, visible, maxHeight, isLoading, searchQuery, totalCount, }: Props) => React.JSX.Element | null>;
-export default TodoPickerPanel;

package/dist/ui/components/TodoPickerPanel.js

@@ -1,119 +0,0 @@
-import React, { memo, useMemo } from 'react';
-import { Box, Text } from 'ink';
-import { Alert } from '@inkjs/ui';
-import { useTheme } from '../contexts/ThemeContext.js';
-const TodoPickerPanel = memo(({ todos, selectedIndex, selectedTodos, visible, maxHeight, isLoading = false, searchQuery = '', totalCount = 0, }) => {
-    const { theme } = useTheme();
-    // Fixed maximum display items to prevent rendering issues
-    const MAX_DISPLAY_ITEMS = 5;
-    const effectiveMaxItems = maxHeight
-        ? Math.min(maxHeight, MAX_DISPLAY_ITEMS)
-        : MAX_DISPLAY_ITEMS;
-    // Limit displayed todos
-    const displayedTodos = useMemo(() => {
-        if (todos.length <= effectiveMaxItems) {
-            return todos;
-        }
-        // Show todos around the selected index
-        const halfWindow = Math.floor(effectiveMaxItems / 2);
-        let startIndex = Math.max(0, selectedIndex - halfWindow);
-        let endIndex = Math.min(todos.length, startIndex + effectiveMaxItems);
-        // Adjust if we're near the end
-        if (endIndex - startIndex < effectiveMaxItems) {
-            startIndex = Math.max(0, endIndex - effectiveMaxItems);
-        }
-        return todos.slice(startIndex, endIndex);
-    }, [todos, selectedIndex, effectiveMaxItems]);
-    // Calculate actual selected index in the displayed subset
-    const displayedSelectedIndex = useMemo(() => {
-        return displayedTodos.findIndex(todo => {
-            const originalIndex = todos.indexOf(todo);
-            return originalIndex === selectedIndex;
-        });
-    }, [displayedTodos, todos, selectedIndex]);
-    // Don't show panel if not visible
-    if (!visible) {
-        return null;
-    }
-    // Show loading state
-    if (isLoading) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { width: "100%" },
-                React.createElement(Box, { flexDirection: "column", width: "100%" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: theme.colors.warning, bold: true }, "TODO Selection")),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Alert, { variant: "info" }, "Scanning project for TODO comments..."))))));
-    }
-    // Show message if no todos found
-    if (todos.length === 0 && !searchQuery) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { width: "100%" },
-                React.createElement(Box, { flexDirection: "column", width: "100%" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: theme.colors.warning, bold: true }, "TODO Selection")),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Alert, { variant: "info" }, "No TODO comments found in the project"))))));
-    }
-    // Show message if search has no results
-    if (todos.length === 0 && searchQuery) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { width: "100%" },
-                React.createElement(Box, { flexDirection: "column", width: "100%" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: theme.colors.warning, bold: true }, "TODO Selection")),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Alert, { variant: "warning" },
-                            "No TODOs match \"",
-                            searchQuery,
-                            "\" (Total: ",
-                            totalCount,
-                            ")")),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, "Type to filter \u00B7 Backspace to clear search"))))));
-    }
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { width: "100%" },
-            React.createElement(Box, { flexDirection: "column", width: "100%" },
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: theme.colors.warning, bold: true },
-                        "Select TODOs",
-                        ' ',
-                        todos.length > effectiveMaxItems &&
-                            `(${selectedIndex + 1}/${todos.length})`,
-                        searchQuery && ` - Filtering: "${searchQuery}"`,
-                        searchQuery &&
-                            totalCount > todos.length &&
-                            ` (${todos.length}/${totalCount})`)),
-                React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, searchQuery
-                        ? 'Type to filter · Backspace to clear · Space: toggle · Enter: confirm'
-                        : 'Type to search · Space: toggle · Enter: confirm · Esc: cancel')),
-                displayedTodos.map((todo, index) => {
-                    const isSelected = index === displayedSelectedIndex;
-                    const isChecked = selectedTodos.has(todo.id);
-                    return (React.createElement(Box, { key: todo.id, flexDirection: "column", width: "100%" },
-                        React.createElement(Text, { color: isSelected ? theme.colors.success : theme.colors.menuSecondary, bold: true },
-                            isSelected ? '❯ ' : '  ',
-                            isChecked ? '[✓]' : '[ ]',
-                            " ",
-                            todo.file,
-                            ":",
-                            todo.line),
-                        React.createElement(Box, { marginLeft: 5 },
-                            React.createElement(Text, { color: isSelected ? theme.colors.success : theme.colors.menuSecondary, dimColor: !isSelected },
-                                "\u2514\u2500 ",
-                                todo.content))));
-                }),
-                todos.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                        "\u2191\u2193 to scroll \u00B7 ",
-                        todos.length - effectiveMaxItems,
-                        " more hidden"))),
-                selectedTodos.size > 0 && (React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { color: theme.colors.menuInfo },
-                        selectedTodos.size,
-                        " TODO(s) selected")))))));
-});
-TodoPickerPanel.displayName = 'TodoPickerPanel';
-export default TodoPickerPanel;

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

@@ -1,15 +0,0 @@
-import React from 'react';
-interface TodoItem {
-    id: string;
-    content: string;
-    status: 'pending' | 'completed';
-    parentId?: string;
-}
-interface TodoTreeProps {
-    todos: TodoItem[];
-}
-/**
- * TODO Tree 组件 - 显示带复选框的任务树
- */
-export default function TodoTree({ todos }: TodoTreeProps): React.JSX.Element | null;
-export {};

package/dist/ui/components/TodoTree.js

@@ -1,60 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { useTheme } from '../contexts/ThemeContext.js';
-/**
- * TODO Tree 组件 - 显示带复选框的任务树
- */
-export default function TodoTree({ todos }) {
-    const { theme } = useTheme();
-    if (todos.length === 0) {
-        return null;
-    }
-    // 按照层级关系组织 TODO
-    const rootTodos = todos.filter(t => !t.parentId);
-    const childTodosMap = new Map();
-    todos.forEach(todo => {
-        if (todo.parentId) {
-            const children = childTodosMap.get(todo.parentId) || [];
-            children.push(todo);
-            childTodosMap.set(todo.parentId, children);
-        }
-    });
-    const getStatusIcon = (status) => {
-        switch (status) {
-            case 'completed':
-                return '[✓]';
-            case 'pending':
-                return '[ ]';
-            default:
-                return '[ ]';
-        }
-    };
-    const getStatusColor = (status) => {
-        switch (status) {
-            case 'completed':
-                return theme.colors.success;
-            case 'pending':
-                return theme.colors.menuSecondary;
-        }
-    };
-    const renderTodo = (todo, depth = 0) => {
-        const children = childTodosMap.get(todo.id) || [];
-        const indent = '  '.repeat(depth);
-        const statusIcon = getStatusIcon(todo.status);
-        const statusColor = getStatusColor(todo.status);
-        return (React.createElement(Box, { key: todo.id, flexDirection: "column" },
-            React.createElement(Box, null,
-                React.createElement(Text, { color: statusColor },
-                    indent,
-                    statusIcon,
-                    " ",
-                    todo.content)),
-            children.map(child => renderTodo(child, depth + 1))));
-    };
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.colors.menuInfo, paddingX: 1, marginBottom: 1 },
-        React.createElement(Box, { marginBottom: 0 },
-            React.createElement(Text, { bold: true, color: theme.colors.menuInfo }, "TODO List")),
-        rootTodos.map(todo => renderTodo(todo)),
-        React.createElement(Box, { marginTop: 0 },
-            React.createElement(Text, { dimColor: true, color: theme.colors.menuSecondary }, "[ ] Pending \u00B7 [\u2713] Completed"))));
-}

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

@@ -1,21 +0,0 @@
-import React from 'react';
-export type ConfirmationResult = 'approve' | 'approve_always' | 'reject' | {
-    type: 'reject_with_reply';
-    reason: string;
-};
-export interface ToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-interface Props {
-    toolName: string;
-    toolArguments?: string;
-    allTools?: ToolCall[];
-    onConfirm: (result: ConfirmationResult) => void;
-}
-export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm, }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/ToolConfirmation.js

@@ -1,204 +0,0 @@
-import React, { useState, useMemo } from 'react';
-import { Box, Text } from 'ink';
-import TextInput from 'ink-text-input';
-import SelectInput from 'ink-select-input';
-import { isSensitiveCommand } from '../../utils/sensitiveCommandManager.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-// Helper function to format argument values with truncation
-function formatArgumentValue(value, maxLength = 100) {
-    if (value === null || value === undefined) {
-        return String(value);
-    }
-    const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-    if (stringValue.length <= maxLength) {
-        return stringValue;
-    }
-    return stringValue.substring(0, maxLength) + '...';
-}
-// Helper function to convert parsed arguments to tree display format
-function formatArgumentsAsTree(args, toolName) {
-    // For filesystem-create and filesystem-edit, exclude content fields
-    const excludeFields = new Set();
-    if (toolName === 'filesystem-create') {
-        excludeFields.add('content');
-    }
-    if (toolName === 'filesystem-edit') {
-        excludeFields.add('newContent');
-    }
-    if (toolName === 'filesystem-edit_search') {
-        excludeFields.add('searchContent');
-        excludeFields.add('replaceContent');
-    }
-    // For ACE tools, exclude large result fields that may contain extensive code
-    if (toolName?.startsWith('ace-')) {
-        excludeFields.add('context'); // ACE tools may return large context strings
-        excludeFields.add('signature'); // Function signatures can be verbose
-    }
-    const keys = Object.keys(args).filter(key => !excludeFields.has(key));
-    return keys.map((key, index) => ({
-        key,
-        value: formatArgumentValue(args[key]),
-        isLast: index === keys.length - 1,
-    }));
-}
-export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm, }) {
-    const { theme } = useTheme();
-    const [hasSelected, setHasSelected] = useState(false);
-    const [showRejectInput, setShowRejectInput] = useState(false);
-    const [rejectReason, setRejectReason] = useState('');
-    // Check if this is a sensitive command (for terminal-execute)
-    const sensitiveCommandCheck = useMemo(() => {
-        if (toolName !== 'terminal-execute' || !toolArguments) {
-            return { isSensitive: false };
-        }
-        try {
-            const parsed = JSON.parse(toolArguments);
-            const command = parsed.command;
-            if (command && typeof command === 'string') {
-                return isSensitiveCommand(command);
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-        return { isSensitive: false };
-    }, [toolName, toolArguments]);
-    // Parse and format tool arguments for display (single tool)
-    const formattedArgs = useMemo(() => {
-        if (!toolArguments)
-            return null;
-        try {
-            const parsed = JSON.parse(toolArguments);
-            return formatArgumentsAsTree(parsed, toolName);
-        }
-        catch {
-            return null;
-        }
-    }, [toolArguments, toolName]);
-    // Parse and format all tools arguments for display (multiple tools)
-    const formattedAllTools = useMemo(() => {
-        if (!allTools || allTools.length === 0)
-            return null;
-        return allTools.map(tool => {
-            try {
-                const parsed = JSON.parse(tool.function.arguments);
-                return {
-                    name: tool.function.name,
-                    args: formatArgumentsAsTree(parsed, tool.function.name),
-                };
-            }
-            catch {
-                return {
-                    name: tool.function.name,
-                    args: [],
-                };
-            }
-        });
-    }, [allTools]);
-    // Conditionally show "Always approve" based on sensitive command check
-    const items = useMemo(() => {
-        const baseItems = [
-            {
-                label: 'Approve (once)',
-                value: 'approve',
-            },
-        ];
-        // Only show "Always approve" if NOT a sensitive command
-        if (!sensitiveCommandCheck.isSensitive) {
-            baseItems.push({
-                label: 'Always approve this tool',
-                value: 'approve_always',
-            });
-        }
-        baseItems.push({
-            label: 'Reject with reply',
-            value: 'reject_with_reply',
-        });
-        baseItems.push({
-            label: 'Reject (end session)',
-            value: 'reject',
-        });
-        return baseItems;
-    }, [sensitiveCommandCheck.isSensitive]);
-    const handleSelect = (item) => {
-        if (!hasSelected) {
-            if (item.value === 'reject_with_reply') {
-                setShowRejectInput(true);
-            }
-            else {
-                setHasSelected(true);
-                onConfirm(item.value);
-            }
-        }
-    };
-    const handleRejectReasonSubmit = () => {
-        if (!hasSelected && rejectReason.trim()) {
-            setHasSelected(true);
-            onConfirm({ type: 'reject_with_reply', reason: rejectReason.trim() });
-        }
-    };
-    return (React.createElement(Box, { flexDirection: "column", marginX: 1, marginY: 1, borderStyle: 'round', borderColor: theme.colors.warning, paddingX: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: theme.colors.warning }, "[Tool Confirmation]")),
-        !formattedAllTools && (React.createElement(React.Fragment, null,
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null,
-                    "Tool:",
-                    ' ',
-                    React.createElement(Text, { bold: true, color: theme.colors.menuInfo }, toolName))),
-            sensitiveCommandCheck.isSensitive && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-                React.createElement(Box, { marginBottom: 1 },
-                    React.createElement(Text, { bold: true, color: theme.colors.error }, "SENSITIVE COMMAND DETECTED")),
-                React.createElement(Box, { flexDirection: "column", gap: 0 },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { dimColor: true }, "Pattern: "),
-                        React.createElement(Text, { color: "magenta", bold: true }, sensitiveCommandCheck.matchedCommand?.pattern)),
-                    React.createElement(Box, { marginTop: 0 },
-                        React.createElement(Text, { dimColor: true }, "Reason: "),
-                        React.createElement(Text, { color: "white" }, sensitiveCommandCheck.matchedCommand?.description))),
-                React.createElement(Box, { marginTop: 1, paddingX: 1, paddingY: 0 },
-                    React.createElement(Text, { color: theme.colors.warning, italic: true }, "This command requires confirmation even in YOLO/Always-Approved mode")))),
-            formattedArgs && formattedArgs.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-                React.createElement(Text, { dimColor: true }, "Arguments:"),
-                formattedArgs.map((arg, index) => (React.createElement(Box, { key: index, flexDirection: "column" },
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                        arg.isLast ? '└─' : '├─',
-                        " ",
-                        arg.key,
-                        ":",
-                        ' ',
-                        React.createElement(Text, { color: "white" }, arg.value))))))))),
-        formattedAllTools && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null,
-                    "Tools:",
-                    ' ',
-                    React.createElement(Text, { bold: true, color: theme.colors.menuInfo },
-                        formattedAllTools.length,
-                        " tools in parallel"))),
-            formattedAllTools.map((tool, toolIndex) => (React.createElement(Box, { key: toolIndex, flexDirection: "column", marginBottom: toolIndex < formattedAllTools.length - 1 ? 1 : 0 },
-                React.createElement(Text, { color: theme.colors.menuInfo, bold: true },
-                    toolIndex + 1,
-                    ". ",
-                    tool.name),
-                tool.args.length > 0 && (React.createElement(Box, { flexDirection: "column", paddingLeft: 2 }, tool.args.map((arg, argIndex) => (React.createElement(Text, { key: argIndex, color: theme.colors.menuSecondary, dimColor: true },
-                    arg.isLast ? '└─' : '├─',
-                    " ",
-                    arg.key,
-                    ":",
-                    ' ',
-                    React.createElement(Text, { color: "white" }, arg.value))))))))))),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Select action:")),
-        !hasSelected && !showRejectInput && (React.createElement(SelectInput, { items: items, onSelect: handleSelect })),
-        showRejectInput && !hasSelected && (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: theme.colors.warning }, "Enter rejection reason:")),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: theme.colors.menuInfo }, "> "),
-                React.createElement(TextInput, { value: rejectReason, onChange: setRejectReason, onSubmit: handleRejectReasonSubmit })),
-            React.createElement(Box, null,
-                React.createElement(Text, { dimColor: true }, "Press Enter to submit")))),
-        hasSelected && (React.createElement(Box, null,
-            React.createElement(Text, { color: theme.colors.success }, "Confirmed")))));
-}

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

@@ -1,13 +0,0 @@
-import React from 'react';
-interface ToolResultPreviewProps {
-    toolName: string;
-    result: string;
-    maxLines?: number;
-    isSubAgentInternal?: boolean;
-}
-/**
- * Display a compact preview of tool execution results
- * Shows a tree-like structure with limited content
- */
-export default function ToolResultPreview({ toolName, result, maxLines, isSubAgentInternal, }: ToolResultPreviewProps): React.JSX.Element | null;
-export {};