snow-ai 0.2.15 → 0.2.16

package/dist/ui/components/DiffViewer.js

@@ -2,10 +2,24 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import * as Diff from 'diff';
 export default function DiffViewer({ oldContent = '', newContent, filename }) {
+    // Strip line numbers if present (format: "123→content")
+    const stripLineNumbers = (content) => {
+        return content
+            .split('\n')
+            .map(line => {
+            // Match line number prefix pattern: "  123→"
+            const match = line.match(/^\s*\d+→(.*)$/);
+            return match ? match[1] : line;
+        })
+            .join('\n');
+    };
+    // Clean the content from filesystem line numbers
+    const cleanOldContent = stripLineNumbers(oldContent);
+    const cleanNewContent = stripLineNumbers(newContent);
     // If no old content, show as new file creation
-    const isNewFile = !oldContent || oldContent.trim() === '';
+    const isNewFile = !cleanOldContent || cleanOldContent.trim() === '';
     if (isNewFile) {
-        const allLines = newContent.split('\n');
+        const allLines = cleanNewContent.split('\n');
         const totalLines = allLines.length;
         const lineNumberWidth = String(totalLines).length;
         return (React.createElement(Box, { flexDirection: "column" },
@@ -18,19 +32,19 @@ export default function DiffViewer({ oldContent = '', newContent, filename }) {
                 React.createElement(Text, { color: "gray", dimColor: true },
                     String(index + 1).padStart(lineNumberWidth, ' '),
                     " \u2502"),
-                React.createElement(Text, { color: "white", backgroundColor: "green" },
+                React.createElement(Text, { color: "white", backgroundColor: "#006400" },
                     "+ ",
                     line)))))));
     }
-    // Generate diff
-    const diffResult = Diff.diffLines(oldContent, newContent);
-    // Calculate line numbers and build display lines
+    // Generate diff using a unified diff format
+    const diffResult = Diff.diffLines(cleanOldContent, cleanNewContent);
+    // Calculate line numbers
+    const totalOldLines = cleanOldContent.split('\n').length;
+    const totalNewLines = cleanNewContent.split('\n').length;
+    const lineNumberWidth = Math.max(String(totalOldLines).length, String(totalNewLines).length, 2);
+    const displayLines = [];
     let oldLineNum = 1;
     let newLineNum = 1;
-    const totalOldLines = oldContent.split('\n').length;
-    const totalNewLines = newContent.split('\n').length;
-    const lineNumberWidth = Math.max(String(totalOldLines).length, String(totalNewLines).length);
-    const displayLines = [];
     diffResult.forEach((part) => {
         const lines = part.value.replace(/\n$/, '').split('\n');
         lines.forEach((line) => {
@@ -38,6 +52,7 @@ export default function DiffViewer({ oldContent = '', newContent, filename }) {
                 displayLines.push({
                     type: 'added',
                     content: line,
+                    oldLineNum: null,
                     newLineNum: newLineNum++
                 });
             }
@@ -45,7 +60,8 @@ export default function DiffViewer({ oldContent = '', newContent, filename }) {
                 displayLines.push({
                     type: 'removed',
                     content: line,
-                    oldLineNum: oldLineNum++
+                    oldLineNum: oldLineNum++,
+                    newLineNum: null
                 });
             }
             else {
@@ -65,29 +81,40 @@ export default function DiffViewer({ oldContent = '', newContent, filename }) {
                 ' ',
                 filename))),
         React.createElement(Box, { flexDirection: "column" }, displayLines.map((displayLine, index) => {
+            const oldNum = displayLine.oldLineNum !== null
+                ? String(displayLine.oldLineNum).padStart(lineNumberWidth, ' ')
+                : ' '.repeat(lineNumberWidth);
+            const newNum = displayLine.newLineNum !== null
+                ? String(displayLine.newLineNum).padStart(lineNumberWidth, ' ')
+                : ' '.repeat(lineNumberWidth);
             if (displayLine.type === 'added') {
-                return (React.createElement(Box, { key: index },
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        String(displayLine.newLineNum).padStart(lineNumberWidth, ' '),
-                        " \u2502"),
-                    React.createElement(Text, { color: "white", backgroundColor: "green" },
-                        "+ ",
-                        displayLine.content)));
+                return (React.createElement(Box, { key: index, flexDirection: "row" },
+                    React.createElement(Box, { flexShrink: 0 },
+                        React.createElement(Text, { color: "gray", dimColor: true }, oldNum),
+                        React.createElement(Text, { color: "green", dimColor: true }, ' + '),
+                        React.createElement(Text, { color: "gray", dimColor: true }, newNum),
+                        React.createElement(Text, { dimColor: true }, " \u2502 ")),
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: "white", backgroundColor: "#006400", wrap: "truncate-end" }, ' ' + displayLine.content))));
             }
             if (displayLine.type === 'removed') {
-                return (React.createElement(Box, { key: index },
-                    React.createElement(Text, { color: "gray", dimColor: true },
-                        String(displayLine.oldLineNum).padStart(lineNumberWidth, ' '),
-                        " \u2502"),
-                    React.createElement(Text, { color: "white", backgroundColor: "red" },
-                        "- ",
-                        displayLine.content)));
+                return (React.createElement(Box, { key: index, flexDirection: "row" },
+                    React.createElement(Box, { flexShrink: 0 },
+                        React.createElement(Text, { color: "gray", dimColor: true }, oldNum),
+                        React.createElement(Text, { color: "red", dimColor: true }, ' - '),
+                        React.createElement(Text, { color: "gray", dimColor: true }, newNum),
+                        React.createElement(Text, { dimColor: true }, " \u2502 ")),
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: "white", backgroundColor: "#8B0000", wrap: "truncate-end" }, ' ' + displayLine.content))));
             }
             // Unchanged lines
-            return (React.createElement(Box, { key: index },
-                React.createElement(Text, { color: "gray", dimColor: true },
-                    String(displayLine.oldLineNum).padStart(lineNumberWidth, ' '),
-                    " \u2502"),
-                React.createElement(Text, { dimColor: true }, displayLine.content)));
+            return (React.createElement(Box, { key: index, flexDirection: "row" },
+                React.createElement(Box, { flexShrink: 0 },
+                    React.createElement(Text, { color: "gray", dimColor: true }, oldNum),
+                    React.createElement(Text, { dimColor: true }, '   '),
+                    React.createElement(Text, { color: "gray", dimColor: true }, newNum),
+                    React.createElement(Text, { dimColor: true }, " \u2502 ")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { dimColor: true, wrap: "truncate-end" }, displayLine.content))));
         }))));
 }

package/dist/ui/components/FileList.js

@@ -1,49 +1,84 @@
-import React, { useState, useEffect, useMemo, useCallback, forwardRef, useImperativeHandle, memo } from 'react';
+import React, { useState, useEffect, useMemo, useCallback, forwardRef, useImperativeHandle, memo, } from 'react';
 import { Box, Text } from 'ink';
 import fs from 'fs';
 import path from 'path';
-const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10, rootPath = process.cwd(), onFilteredCountChange }, ref) => {
+const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10, rootPath = process.cwd(), onFilteredCountChange, }, ref) => {
     const [files, setFiles] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     // Fixed maximum display items to prevent rendering issues
     const MAX_DISPLAY_ITEMS = 5;
     const effectiveMaxItems = useMemo(() => {
-        return maxItems ? Math.min(maxItems, MAX_DISPLAY_ITEMS) : MAX_DISPLAY_ITEMS;
+        return maxItems
+            ? Math.min(maxItems, MAX_DISPLAY_ITEMS)
+            : MAX_DISPLAY_ITEMS;
     }, [maxItems]);
-    // Get files from directory - optimized to batch updates
+    // Get files from directory - optimized for performance with no depth limit
     const loadFiles = useCallback(async () => {
-        const getFilesRecursively = async (dir, depth = 0, maxDepth = 3) => {
-            if (depth > maxDepth)
-                return [];
+        const getFilesRecursively = async (dir, depth = 0) => {
             try {
-                const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+                const entries = await fs.promises.readdir(dir, {
+                    withFileTypes: true,
+                });
                 let result = [];
+                // Common ignore patterns for better performance
+                const ignorePatterns = [
+                    'node_modules',
+                    'dist',
+                    'build',
+                    'coverage',
+                    '.git',
+                    '.vscode',
+                    '.idea',
+                    'out',
+                    'target',
+                    'bin',
+                    'obj',
+                    '.next',
+                    '.nuxt',
+                    'vendor',
+                    '__pycache__',
+                    '.pytest_cache',
+                    '.mypy_cache',
+                    'venv',
+                    '.venv',
+                    'env',
+                    '.env',
+                ];
                 for (const entry of entries) {
-                    // Skip hidden files and common ignore patterns
+                    // Skip hidden files and ignore patterns
                     if (entry.name.startsWith('.') ||
-                        entry.name === 'node_modules' ||
-                        entry.name === 'dist' ||
-                        entry.name === 'build') {
+                        ignorePatterns.includes(entry.name)) {
                         continue;
                     }
                     const fullPath = path.join(dir, entry.name);
+                    // Skip if file is too large (> 10MB) for performance
+                    try {
+                        const stats = await fs.promises.stat(fullPath);
+                        if (!entry.isDirectory() && stats.size > 10 * 1024 * 1024) {
+                            continue;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
                     let relativePath = path.relative(rootPath, fullPath);
                     // Ensure relative paths start with ./ for consistency
-                    if (!relativePath.startsWith('.') && !path.isAbsolute(relativePath)) {
+                    if (!relativePath.startsWith('.') &&
+                        !path.isAbsolute(relativePath)) {
                         relativePath = './' + relativePath;
                     }
                     result.push({
                         name: entry.name,
                         path: relativePath,
-                        isDirectory: entry.isDirectory()
+                        isDirectory: entry.isDirectory(),
                     });
-                    // Recursively get files from subdirectories
-                    if (entry.isDirectory() && depth < maxDepth) {
-                        const subFiles = await getFilesRecursively(fullPath, depth + 1, maxDepth);
+                    // Recursively get files from subdirectories (no depth limit)
+                    if (entry.isDirectory()) {
+                        const subFiles = await getFilesRecursively(fullPath, depth + 1);
                         result = result.concat(subFiles);
                     }
-                    // Limit total files for performance
-                    if (result.length > 500) {
+                    // Limit total files for performance (increased from 500 to 2000)
+                    if (result.length > 2000) {
                         break;
                     }
                 }
@@ -112,16 +147,18 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
     // Expose methods to parent
     useImperativeHandle(ref, () => ({
         getSelectedFile: () => {
-            if (allFilteredFiles.length > 0 && selectedIndex < allFilteredFiles.length && allFilteredFiles[selectedIndex]) {
+            if (allFilteredFiles.length > 0 &&
+                selectedIndex < allFilteredFiles.length &&
+                allFilteredFiles[selectedIndex]) {
                 return allFilteredFiles[selectedIndex].path;
             }
             return null;
-        }
+        },
     }), [allFilteredFiles, selectedIndex]);
     // Calculate display index for the scrolling window
     // MUST be before early returns to avoid hook order issues
     const displaySelectedIndex = useMemo(() => {
-        return filteredFiles.findIndex((file) => {
+        return filteredFiles.findIndex(file => {
             const originalIndex = allFilteredFiles.indexOf(file);
             return originalIndex === selectedIndex;
         });
@@ -140,15 +177,22 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
     return (React.createElement(Box, { paddingX: 1, marginTop: 1, flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { color: "blue", bold: true },
-                "\uD83D\uDDD0 Files ",
-                allFilteredFiles.length > effectiveMaxItems && `(${selectedIndex + 1}/${allFilteredFiles.length})`)),
+                "\uD83D\uDDD0 Files",
+                ' ',
+                allFilteredFiles.length > effectiveMaxItems &&
+                    `(${selectedIndex + 1}/${allFilteredFiles.length})`)),
         filteredFiles.map((file, index) => (React.createElement(Box, { key: file.path },
-            React.createElement(Text, { backgroundColor: index === displaySelectedIndex ? "blue" : undefined, color: index === displaySelectedIndex ? "white" : file.isDirectory ? "cyan" : "white" }, file.path)))),
+            React.createElement(Text, { backgroundColor: index === displaySelectedIndex ? '#1E3A8A' : undefined, color: index === displaySelectedIndex
+                    ? '#FFFFFF'
+                    : file.isDirectory
+                        ? 'cyan'
+                        : 'white' }, file.path)))),
         allFilteredFiles.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { color: "gray", dimColor: true },
                 "\u2191\u2193 to scroll \u00B7 ",
                 allFilteredFiles.length - effectiveMaxItems,
-                " more hidden")))));
+                ' ',
+                "more hidden")))));
 }));
 FileList.displayName = 'FileList';
 export default FileList;

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

@@ -33,6 +33,12 @@ export interface Message {
     toolResult?: string;
     toolCallId?: string;
     toolPending?: boolean;
+    terminalResult?: {
+        stdout?: string;
+        stderr?: string;
+        exitCode?: number;
+        command?: string;
+    };
 }
 interface Props {
     messages: Message[];

package/dist/ui/components/MessageList.js

@@ -15,12 +15,18 @@ const MessageList = memo(({ messages, animationFrame, maxMessages = 6 }) => {
                     ? STREAM_COLORS[animationFrame]
                     : 'cyan';
         return (React.createElement(Box, { key: index },
-            React.createElement(Text, { color: iconColor, bold: true }, message.role === 'user' ? '⛇' : message.role === 'command' ? '⌘' : '❆'),
+            React.createElement(Text, { color: iconColor, bold: true }, message.role === 'user'
+                ? '⛇'
+                : message.role === 'command'
+                    ? '⌘'
+                    : '❆'),
             React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" }, message.role === 'command' ? (React.createElement(Text, { color: "gray" },
                 "\u2514\u2500 ",
                 message.commandName)) : (React.createElement(React.Fragment, null,
                 React.createElement(MarkdownRenderer, { content: message.content || ' ', color: message.role === 'user' ? 'gray' : undefined }),
-                (message.systemInfo || message.files || message.images) && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                (message.systemInfo ||
+                    message.files ||
+                    message.images) && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
                     message.systemInfo && (React.createElement(React.Fragment, null,
                         React.createElement(Text, { color: "gray", dimColor: true },
                             "\u2514\u2500 Platform: ",
@@ -29,38 +35,64 @@ const MessageList = memo(({ messages, animationFrame, maxMessages = 6 }) => {
                             "\u2514\u2500 Shell: ",
                             message.systemInfo.shell),
                         React.createElement(Text, { color: "gray", dimColor: true },
-                            "\u2514\u2500 Working Directory: ",
+                            "\u2514\u2500 Working Directory:",
+                            ' ',
                             message.systemInfo.workingDirectory))),
                     message.files && message.files.length > 0 && (React.createElement(React.Fragment, null, message.files.map((file, fileIndex) => (React.createElement(Text, { key: fileIndex, color: "gray", dimColor: true }, file.isImage
                         ? `└─ [image #{fileIndex + 1}] ${file.path}`
-                        : `└─ Read \`${file.path}\`${file.exists ? ` (total line ${file.lineCount})` : ' (file not found)'}`))))),
+                        : `└─ Read \`${file.path}\`${file.exists
+                            ? ` (total line ${file.lineCount})`
+                            : ' (file not found)'}`))))),
                     message.images && message.images.length > 0 && (React.createElement(React.Fragment, null, message.images.map((_image, imageIndex) => (React.createElement(Text, { key: imageIndex, color: "gray", dimColor: true },
                         "\u2514\u2500 [image #",
                         imageIndex + 1,
                         "]"))))))),
-                message.toolCall && message.toolCall.name === 'terminal-execute' && message.toolCall.arguments.command && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                message.toolCall &&
+                    message.toolCall.name === 'terminal-execute' &&
+                    message.toolCall.arguments.command && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
                     React.createElement(Text, { color: "gray", dimColor: true },
-                        "\u2514\u2500 Command: ",
+                        "\u2514\u2500 Command:",
+                        ' ',
                         React.createElement(Text, { color: "white" }, message.toolCall.arguments.command)),
                     React.createElement(Text, { color: "gray", dimColor: true },
-                        "\u2514\u2500 Exit Code: ",
-                        React.createElement(Text, { color: message.toolCall.arguments.exitCode === 0 ? 'green' : 'red' }, message.toolCall.arguments.exitCode)),
-                    message.toolCall.arguments.stdout && message.toolCall.arguments.stdout.trim().length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                        "\u2514\u2500 Exit Code:",
+                        ' ',
+                        React.createElement(Text, { color: message.toolCall.arguments.exitCode === 0
+                                ? 'green'
+                                : 'red' }, message.toolCall.arguments.exitCode)),
+                    message.toolCall.arguments.stdout &&
+                        message.toolCall.arguments.stdout.trim().length >
+                            0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
                         React.createElement(Text, { color: "green", dimColor: true }, "\u2514\u2500 stdout:"),
                         React.createElement(Box, { paddingLeft: 2 },
-                            React.createElement(Text, { color: "white" }, message.toolCall.arguments.stdout.trim().split('\n').slice(0, 20).join('\n')),
-                            message.toolCall.arguments.stdout.trim().split('\n').length > 20 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))),
-                    message.toolCall.arguments.stderr && message.toolCall.arguments.stderr.trim().length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                            React.createElement(Text, { color: "white" }, message.toolCall.arguments.stdout
+                                .trim()
+                                .split('\n')
+                                .slice(0, 20)
+                                .join('\n')),
+                            message.toolCall.arguments.stdout
+                                .trim()
+                                .split('\n').length > 20 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))),
+                    message.toolCall.arguments.stderr &&
+                        message.toolCall.arguments.stderr.trim().length >
+                            0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
                         React.createElement(Text, { color: "red", dimColor: true }, "\u2514\u2500 stderr:"),
                         React.createElement(Box, { paddingLeft: 2 },
-                            React.createElement(Text, { color: "red" }, message.toolCall.arguments.stderr.trim().split('\n').slice(0, 10).join('\n')),
-                            message.toolCall.arguments.stderr.trim().split('\n').length > 10 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))))),
+                            React.createElement(Text, { color: "red" }, message.toolCall.arguments.stderr
+                                .trim()
+                                .split('\n')
+                                .slice(0, 10)
+                                .join('\n')),
+                            message.toolCall.arguments.stderr
+                                .trim()
+                                .split('\n').length > 10 && (React.createElement(Text, { color: "gray", dimColor: true }, "... (output truncated)"))))))),
                 message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue")))))));
     })));
 }, (prevProps, nextProps) => {
     const hasStreamingMessage = nextProps.messages.some(m => m.streaming);
     if (hasStreamingMessage) {
-        return prevProps.messages === nextProps.messages && prevProps.animationFrame === nextProps.animationFrame;
+        return (prevProps.messages === nextProps.messages &&
+            prevProps.animationFrame === nextProps.animationFrame);
     }
     return prevProps.messages === nextProps.messages;
 });

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,30 @@
+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/TodoTree.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 interface TodoItem {
     id: string;
     content: string;
-    status: 'pending' | 'in_progress' | 'completed';
+    status: 'pending' | 'completed';
     parentId?: string;
 }
 interface TodoTreeProps {

package/dist/ui/components/TodoTree.js

@@ -21,8 +21,6 @@ export default function TodoTree({ todos }) {
         switch (status) {
             case 'completed':
                 return '[x]';
-            case 'in_progress':
-                return '[~]';
             case 'pending':
                 return '[ ]';
         }
@@ -31,8 +29,6 @@ export default function TodoTree({ todos }) {
         switch (status) {
             case 'completed':
                 return 'green';
-            case 'in_progress':
-                return 'yellow';
             case 'pending':
                 return 'gray';
         }

package/dist/ui/components/ToolConfirmation.js

@@ -13,8 +13,16 @@ function formatArgumentValue(value, maxLength = 100) {
     return stringValue.substring(0, maxLength) + '...';
 }
 // Helper function to convert parsed arguments to tree display format
-function formatArgumentsAsTree(args) {
-    const keys = Object.keys(args);
+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');
+    }
+    const keys = Object.keys(args).filter(key => !excludeFields.has(key));
     return keys.map((key, index) => ({
         key,
         value: formatArgumentValue(args[key]),
@@ -29,12 +37,12 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
             return null;
         try {
             const parsed = JSON.parse(toolArguments);
-            return formatArgumentsAsTree(parsed);
+            return formatArgumentsAsTree(parsed, toolName);
         }
         catch {
             return null;
         }
-    }, [toolArguments]);
+    }, [toolArguments, toolName]);
     // Parse and format all tools arguments for display (multiple tools)
     const formattedAllTools = useMemo(() => {
         if (!allTools || allTools.length === 0)
@@ -44,7 +52,7 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
                 const parsed = JSON.parse(tool.function.arguments);
                 return {
                     name: tool.function.name,
-                    args: formatArgumentsAsTree(parsed)
+                    args: formatArgumentsAsTree(parsed, tool.function.name)
                 };
             }
             catch {
@@ -75,7 +83,7 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
             onConfirm(item.value);
         }
     };
-    return (React.createElement(Box, { flexDirection: "column", marginX: 1, marginY: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1 },
+    return (React.createElement(Box, { flexDirection: "column", marginX: 1, marginY: 1, paddingX: 1 },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "yellow" }, "[Tool Confirmation]")),
         !formattedAllTools && (React.createElement(React.Fragment, null,