snow-ai 0.3.2 → 0.3.4

package/dist/mcp/todo.js

@@ -23,15 +23,42 @@ export class TodoService {
     async initialize() {
         await fs.mkdir(this.todoDir, { recursive: true });
     }
-    getTodoPath(sessionId) {
-        return path.join(this.todoDir, `${sessionId}.json`);
+    getTodoPath(sessionId, date) {
+        const sessionDate = date || new Date();
+        const dateFolder = this.formatDateForFolder(sessionDate);
+        const todoDir = path.join(this.todoDir, dateFolder);
+        return path.join(todoDir, `${sessionId}.json`);
+    }
+    formatDateForFolder(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+    async ensureTodoDir(date) {
+        try {
+            await fs.mkdir(this.todoDir, { recursive: true });
+            if (date) {
+                const dateFolder = this.formatDateForFolder(date);
+                const todoDir = path.join(this.todoDir, dateFolder);
+                await fs.mkdir(todoDir, { recursive: true });
+            }
+        }
+        catch (error) {
+            // Directory already exists or other error
+        }
     }
     /**
      * 创建或更新会话的 TODO List
      */
-    async saveTodoList(sessionId, todos) {
-        const todoPath = this.getTodoPath(sessionId);
-        let existingList;
+    async saveTodoList(sessionId, todos, existingList) {
+        // 使用现有TODO列表的createdAt信息，或者使用当前时间
+        const sessionCreatedAt = existingList?.createdAt
+            ? new Date(existingList.createdAt).getTime()
+            : Date.now();
+        const sessionDate = new Date(sessionCreatedAt);
+        await this.ensureTodoDir(sessionDate);
+        const todoPath = this.getTodoPath(sessionId, sessionDate);
         try {
             const content = await fs.readFile(todoPath, 'utf-8');
             existingList = JSON.parse(content);
@@ -53,14 +80,49 @@ export class TodoService {
      * 获取会话的 TODO List
      */
     async getTodoList(sessionId) {
-        const todoPath = this.getTodoPath(sessionId);
+        // 首先尝试从旧格式加载（向下兼容）
         try {
-            const content = await fs.readFile(todoPath, 'utf-8');
+            const oldTodoPath = path.join(this.todoDir, `${sessionId}.json`);
+            const content = await fs.readFile(oldTodoPath, 'utf-8');
             return JSON.parse(content);
         }
-        catch {
-            return null;
+        catch (error) {
+            // 旧格式不存在，搜索日期文件夹
         }
+        // 在日期文件夹中查找 TODO
+        try {
+            const todo = await this.findTodoInDateFolders(sessionId);
+            return todo;
+        }
+        catch (error) {
+            // 搜索失败
+        }
+        return null;
+    }
+    async findTodoInDateFolders(sessionId) {
+        try {
+            const files = await fs.readdir(this.todoDir);
+            for (const file of files) {
+                const filePath = path.join(this.todoDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(file)) {
+                    // 这是日期文件夹，查找 TODO 文件
+                    const todoPath = path.join(filePath, `${sessionId}.json`);
+                    try {
+                        const content = await fs.readFile(todoPath, 'utf-8');
+                        return JSON.parse(content);
+                    }
+                    catch (error) {
+                        // 文件不存在或读取失败，继续搜索
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // 目录读取失败
+        }
+        return null;
     }
     /**
      * 更新单个 TODO 项
@@ -80,7 +142,7 @@ export class TodoService {
             ...updates,
             updatedAt: new Date().toISOString(),
         };
-        return this.saveTodoList(sessionId, todoList.todos);
+        return this.saveTodoList(sessionId, todoList.todos, todoList);
     }
     /**
      * 添加 TODO 项
@@ -97,7 +159,7 @@ export class TodoService {
             parentId,
         };
         const todos = todoList ? [...todoList.todos, newTodo] : [newTodo];
-        return this.saveTodoList(sessionId, todos);
+        return this.saveTodoList(sessionId, todos, todoList);
     }
     /**
      * 删除 TODO 项
@@ -108,7 +170,45 @@ export class TodoService {
             return null;
         }
         const filteredTodos = todoList.todos.filter(t => t.id !== todoId && t.parentId !== todoId);
-        return this.saveTodoList(sessionId, filteredTodos);
+        return this.saveTodoList(sessionId, filteredTodos, todoList);
+    }
+    /**
+     * 删除整个会话的 TODO 列表
+     */
+    async deleteTodoList(sessionId) {
+        // 首先尝试删除旧格式（向下兼容）
+        try {
+            const oldTodoPath = path.join(this.todoDir, `${sessionId}.json`);
+            await fs.unlink(oldTodoPath);
+            return true;
+        }
+        catch (error) {
+            // 旧格式不存在，搜索日期文件夹
+        }
+        // 在日期文件夹中查找并删除 TODO
+        try {
+            const files = await fs.readdir(this.todoDir);
+            for (const file of files) {
+                const filePath = path.join(this.todoDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(file)) {
+                    // 这是日期文件夹，查找 TODO 文件
+                    const todoPath = path.join(filePath, `${sessionId}.json`);
+                    try {
+                        await fs.unlink(todoPath);
+                        return true;
+                    }
+                    catch (error) {
+                        // 文件不存在，继续搜索
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // 目录读取失败
+        }
+        return false;
     }
     /**
      * 获取所有工具定义
@@ -325,7 +425,9 @@ Deleting a parent task automatically deletes all its subtasks (parentId relation
                     const todoItems = todos.map(t => {
                         const now = new Date().toISOString();
                         return {
-                            id: `todo_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                            id: `todo_${Date.now()}_${Math.random()
+                                .toString(36)
+                                .slice(2, 9)}`,
                             content: t.content,
                             status: 'pending',
                             createdAt: now,
@@ -333,7 +435,8 @@ Deleting a parent task automatically deletes all its subtasks (parentId relation
                             parentId: t.parentId,
                         };
                     });
-                    const result = await this.saveTodoList(sessionId, todoItems);
+                    const existingList = await this.getTodoList(sessionId);
+                    const result = await this.saveTodoList(sessionId, todoItems, existingList);
                     return {
                         content: [
                             {
@@ -349,7 +452,9 @@ Deleting a parent task automatically deletes all its subtasks (parentId relation
                         content: [
                             {
                                 type: 'text',
-                                text: result ? JSON.stringify(result, null, 2) : 'No TODO list found',
+                                text: result
+                                    ? JSON.stringify(result, null, 2)
+                                    : 'No TODO list found',
                             },
                         ],
                     };
@@ -366,7 +471,9 @@ Deleting a parent task automatically deletes all its subtasks (parentId relation
                         content: [
                             {
                                 type: 'text',
-                                text: result ? JSON.stringify(result, null, 2) : 'TODO item not found',
+                                text: result
+                                    ? JSON.stringify(result, null, 2)
+                                    : 'TODO item not found',
                             },
                         ],
                     };
@@ -390,7 +497,9 @@ Deleting a parent task automatically deletes all its subtasks (parentId relation
                         content: [
                             {
                                 type: 'text',
-                                text: result ? JSON.stringify(result, null, 2) : 'TODO item not found',
+                                text: result
+                                    ? JSON.stringify(result, null, 2)
+                                    : 'TODO item not found',
                             },
                         ],
                     };

package/dist/ui/pages/ChatScreen.js

@@ -674,11 +674,18 @@ export default function ChatScreen({ skipWelcome }) {
             .filter(m => m.toolPending)
             .map((message, index) => (React.createElement(Box, { key: `pending-tool-${index}`, marginBottom: 1, paddingX: 1, width: terminalWidth },
             React.createElement(Text, { color: "yellowBright", bold: true }, "\u2746"),
-            React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "row" },
-                React.createElement(MarkdownRenderer, { content: message.content || ' ', color: "yellow" }),
-                React.createElement(Box, { marginLeft: 1 },
-                    React.createElement(Text, { color: "yellow" },
-                        React.createElement(Spinner, { type: "dots" }))))))),
+            React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" },
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(MarkdownRenderer, { content: message.content || ' ', color: "yellow" }),
+                    React.createElement(Box, { marginLeft: 1 },
+                        React.createElement(Text, { color: "yellow" },
+                            React.createElement(Spinner, { type: "dots" })))),
+                message.toolDisplay && message.toolDisplay.args.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 }, message.toolDisplay.args.map((arg, argIndex) => (React.createElement(Text, { key: argIndex, color: "gray", dimColor: true },
+                    arg.isLast ? '└─' : '├─',
+                    " ",
+                    arg.key,
+                    ": ",
+                    arg.value))))))))),
         (streamingState.isStreaming || isSaving) && !pendingToolConfirmation && (React.createElement(Box, { marginBottom: 1, paddingX: 1, width: terminalWidth },
             React.createElement(Text, { color: ['#FF6EBF', 'green', 'blue', 'cyan', '#B588F8'][streamingState.animationFrame], bold: true }, "\u2746"),
             React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" }, streamingState.isStreaming ? (React.createElement(React.Fragment, null, streamingState.retryStatus &&

package/dist/ui/pages/HeadlessModeScreen.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    prompt: string;
+    onComplete: () => void;
+};
+export default function HeadlessModeScreen({ prompt, onComplete }: Props): React.JSX.Element | null;
+export {};

package/dist/ui/pages/HeadlessModeScreen.js

@@ -0,0 +1,391 @@
+import React, { useState, useEffect } from 'react';
+import { useStdout } from 'ink';
+import ansiEscapes from 'ansi-escapes';
+import { highlight } from 'cli-highlight';
+import { handleConversationWithTools } from '../../hooks/useConversation.js';
+import { useStreamingState } from '../../hooks/useStreamingState.js';
+import { useToolConfirmation } from '../../hooks/useToolConfirmation.js';
+import { useVSCodeState } from '../../hooks/useVSCodeState.js';
+import { parseAndValidateFileReferences, createMessageWithFileInstructions, getSystemInfo, } from '../../utils/fileUtils.js';
+// Console-based markdown renderer functions
+function renderConsoleMarkdown(content) {
+    const blocks = parseConsoleMarkdown(content);
+    return blocks.map(block => renderConsoleBlock(block)).join('\n');
+}
+function parseConsoleMarkdown(content) {
+    const blocks = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        // Check for code block
+        const codeBlockMatch = line.match(/^```(.*)$/);
+        if (codeBlockMatch) {
+            const language = codeBlockMatch[1]?.trim() || '';
+            const codeLines = [];
+            i++;
+            // Collect code block lines
+            while (i < lines.length) {
+                const currentLine = lines[i] ?? '';
+                if (currentLine.trim().startsWith('```')) {
+                    break;
+                }
+                codeLines.push(currentLine);
+                i++;
+            }
+            blocks.push({
+                type: 'code',
+                language,
+                code: codeLines.join('\n'),
+            });
+            i++; // Skip closing ```
+            continue;
+        }
+        // Check for heading
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            blocks.push({
+                type: 'heading',
+                level: headingMatch[1].length,
+                content: headingMatch[2].trim(),
+            });
+            i++;
+            continue;
+        }
+        // Check for list item
+        const listMatch = line.match(/^[\s]*[*\-]\s+(.+)$/);
+        if (listMatch) {
+            const listItems = [listMatch[1].trim()];
+            i++;
+            // Collect consecutive list items
+            while (i < lines.length) {
+                const currentLine = lines[i] ?? '';
+                const nextListMatch = currentLine.match(/^[\s]*[*\-]\s+(.+)$/);
+                if (!nextListMatch) {
+                    break;
+                }
+                listItems.push(nextListMatch[1].trim());
+                i++;
+            }
+            blocks.push({
+                type: 'list',
+                items: listItems,
+            });
+            continue;
+        }
+        // Collect text lines
+        const textLines = [];
+        while (i < lines.length) {
+            const currentLine = lines[i] ?? '';
+            if (currentLine.trim().startsWith('```') ||
+                currentLine.match(/^#{1,6}\s+/) ||
+                currentLine.match(/^[\s]*[*\-]\s+/)) {
+                break;
+            }
+            textLines.push(currentLine);
+            i++;
+        }
+        if (textLines.length > 0) {
+            blocks.push({
+                type: 'text',
+                content: textLines.join('\n'),
+            });
+        }
+    }
+    return blocks;
+}
+function renderConsoleBlock(block) {
+    switch (block.type) {
+        case 'code': {
+            const highlightedCode = highlightConsoleCode(block.code, block.language);
+            const languageLabel = block.language
+                ? `\x1b[42m\x1b[30m ${block.language} \x1b[0m`
+                : '';
+            return (`\n\x1b[90m┌─ Code Block\x1b[0m\n` +
+                (languageLabel ? `\x1b[90m│\x1b[0m ${languageLabel}\n` : '') +
+                `\x1b[90m├─\x1b[0m\n` +
+                `${highlightedCode}\n` +
+                `\x1b[90m└─ End of Code\x1b[0m`);
+        }
+        case 'heading': {
+            const headingColors = ['\x1b[96m', '\x1b[94m', '\x1b[95m', '\x1b[93m'];
+            const headingColor = headingColors[block.level - 1] || '\x1b[97m';
+            const prefix = '#'.repeat(block.level);
+            return `\n${headingColor}${prefix} ${renderInlineFormatting(block.content)}\x1b[0m`;
+        }
+        case 'list': {
+            return ('\n' +
+                block.items
+                    .map((item) => `\x1b[93m•\x1b[0m ${renderInlineFormatting(item)}`)
+                    .join('\n'));
+        }
+        case 'text': {
+            return ('\n' +
+                block.content
+                    .split('\n')
+                    .map((line) => line === '' ? '' : renderInlineFormatting(line))
+                    .join('\n'));
+        }
+        default:
+            return '';
+    }
+}
+function highlightConsoleCode(code, language) {
+    try {
+        if (!language) {
+            return code
+                .split('\n')
+                .map(line => `\x1b[90m│ \x1b[37m${line}\x1b[0m`)
+                .join('\n');
+        }
+        // Map common language aliases
+        const languageMap = {
+            js: 'javascript',
+            ts: 'typescript',
+            py: 'python',
+            rb: 'ruby',
+            sh: 'bash',
+            shell: 'bash',
+            cs: 'csharp',
+            'c#': 'csharp',
+            cpp: 'cpp',
+            'c++': 'cpp',
+            yml: 'yaml',
+            md: 'markdown',
+            json: 'json',
+            xml: 'xml',
+            html: 'html',
+            css: 'css',
+            sql: 'sql',
+            java: 'java',
+            go: 'go',
+            rust: 'rust',
+            php: 'php',
+        };
+        const mappedLanguage = languageMap[language.toLowerCase()] || language.toLowerCase();
+        const highlighted = highlight(code, {
+            language: mappedLanguage,
+            ignoreIllegals: true,
+        });
+        return highlighted
+            .split('\n')
+            .map(line => `\x1b[90m│ \x1b[0m${line}`)
+            .join('\n');
+    }
+    catch {
+        // If highlighting fails, return plain code
+        return code
+            .split('\n')
+            .map(line => `\x1b[90m│ \x1b[37m${line}\x1b[0m`)
+            .join('\n');
+    }
+}
+function renderInlineFormatting(text) {
+    // Handle inline code `code`
+    text = text.replace(/`([^`]+)`/g, (_, code) => {
+        return `\x1b[36m${code}\x1b[0m`;
+    });
+    // Handle bold **text** or __text__
+    text = text.replace(/(\*\*|__)([^*_]+)\1/g, (_, __, content) => {
+        return `\x1b[1m\x1b[97m${content}\x1b[0m`;
+    });
+    // Handle italic *text* or _text_
+    text = text.replace(/(?<!\*)(\*)(?!\*)([^*]+)\1(?!\*)/g, (_, __, content) => {
+        return `\x1b[3m\x1b[97m${content}\x1b[0m`;
+    });
+    return text;
+}
+export default function HeadlessModeScreen({ prompt, onComplete }) {
+    const [messages, setMessages] = useState([]);
+    const [isComplete, setIsComplete] = useState(false);
+    const { stdout } = useStdout();
+    // Use custom hooks
+    const streamingState = useStreamingState();
+    const vscodeState = useVSCodeState();
+    // Use tool confirmation hook
+    const { requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, } = useToolConfirmation();
+    // Listen for message changes to display AI responses and tool calls
+    useEffect(() => {
+        const lastMessage = messages[messages.length - 1];
+        if (!lastMessage)
+            return;
+        if (lastMessage.role === 'assistant') {
+            if (lastMessage.toolPending) {
+                // Tool is being executed - use same icon as ChatScreen with colors
+                if (lastMessage.content.startsWith('⚡')) {
+                    console.log(`\n\x1b[93m⚡ ${lastMessage.content}\x1b[0m`);
+                }
+                else if (lastMessage.content.startsWith('✓')) {
+                    console.log(`\n\x1b[32m✓ ${lastMessage.content}\x1b[0m`);
+                }
+                else if (lastMessage.content.startsWith('✗')) {
+                    console.log(`\n\x1b[31m✗ ${lastMessage.content}\x1b[0m`);
+                }
+                else {
+                    console.log(`\n\x1b[96m❆ ${lastMessage.content}\x1b[0m`);
+                }
+            }
+            else if (lastMessage.content && !lastMessage.streaming) {
+                // Final response with markdown rendering and better formatting
+                console.log(renderConsoleMarkdown(lastMessage.content));
+                // Show tool results if available with better styling
+                if (lastMessage.toolCall &&
+                    lastMessage.toolCall.name === 'terminal-execute') {
+                    const args = lastMessage.toolCall.arguments;
+                    if (args.command) {
+                        console.log(`\n\x1b[90m┌─ Command\x1b[0m`);
+                        console.log(`\x1b[33m│  ${args.command}\x1b[0m`);
+                    }
+                    if (args.stdout && args.stdout.trim()) {
+                        console.log(`\x1b[90m├─ stdout\x1b[0m`);
+                        const stdoutLines = args.stdout.split('\n');
+                        stdoutLines.forEach((line) => {
+                            console.log(`\x1b[90m│  \x1b[32m${line}\x1b[0m`);
+                        });
+                    }
+                    if (args.stderr && args.stderr.trim()) {
+                        console.log(`\x1b[90m├─ stderr\x1b[0m`);
+                        const stderrLines = args.stderr.split('\n');
+                        stderrLines.forEach((line) => {
+                            console.log(`\x1b[90m│  \x1b[31m${line}\x1b[0m`);
+                        });
+                    }
+                    if (args.command || args.stdout || args.stderr) {
+                        console.log(`\x1b[90m└─ Execution complete\x1b[0m`);
+                    }
+                }
+            }
+        }
+    }, [messages]);
+    // Listen for streaming state to show loading status
+    useEffect(() => {
+        if (streamingState.isStreaming) {
+            if (streamingState.retryStatus && streamingState.retryStatus.isRetrying) {
+                // Show retry status with colors
+                if (streamingState.retryStatus.errorMessage) {
+                    console.log(`\n\x1b[31m✗ Error: ${streamingState.retryStatus.errorMessage}\x1b[0m`);
+                }
+                if (streamingState.retryStatus.remainingSeconds !== undefined &&
+                    streamingState.retryStatus.remainingSeconds > 0) {
+                    console.log(`\n\x1b[93m⟳ Retry \x1b[33m${streamingState.retryStatus.attempt}/5\x1b[93m in \x1b[32m${streamingState.retryStatus.remainingSeconds}s\x1b[93m...\x1b[0m`);
+                }
+                else {
+                    console.log(`\n\x1b[93m⟳ Resending... \x1b[33m(Attempt ${streamingState.retryStatus.attempt}/5)\x1b[0m`);
+                }
+            }
+            else {
+                // Show normal thinking status with colors
+                const thinkingText = streamingState.isReasoning
+                    ? 'Deep thinking...'
+                    : 'Thinking...';
+                process.stdout.write(`\r\x1b[96m❆\x1b[90m ${thinkingText} \x1b[37m(\x1b[33m${streamingState.elapsedSeconds}s\x1b[37m · \x1b[32m↓ ${streamingState.streamTokenCount} tokens\x1b[37m)\x1b[0m`);
+            }
+        }
+    }, [
+        streamingState.isStreaming,
+        streamingState.isReasoning,
+        streamingState.elapsedSeconds,
+        streamingState.streamTokenCount,
+        streamingState.retryStatus,
+    ]);
+    const processMessage = async () => {
+        try {
+            // Parse and validate file references
+            const { cleanContent, validFiles } = await parseAndValidateFileReferences(prompt);
+            const regularFiles = validFiles.filter(f => !f.isImage);
+            // Get system information
+            const systemInfo = getSystemInfo();
+            // Add user message to UI
+            const userMessage = {
+                role: 'user',
+                content: cleanContent,
+                files: validFiles.length > 0 ? validFiles : undefined,
+                systemInfo,
+            };
+            setMessages([userMessage]);
+            streamingState.setIsStreaming(true);
+            // Create new abort controller for this request
+            const controller = new AbortController();
+            streamingState.setAbortController(controller);
+            // Clear terminal and start headless output
+            stdout.write(ansiEscapes.clearTerminal);
+            // Print colorful banner
+            console.log(`\x1b[94m╭─────────────────────────────────────────────────────────╮\x1b[0m`);
+            console.log(`\x1b[94m│\x1b[96m                ❆ Snow AI CLI - Headless Mode ❆          \x1b[94m│\x1b[0m`);
+            console.log(`\x1b[94m╰─────────────────────────────────────────────────────────╯\x1b[0m`);
+            // Print user prompt with styling
+            console.log(`\n\x1b[36m┌─ User Query\x1b[0m`);
+            console.log(`\x1b[97m│  ${cleanContent}\x1b[0m`);
+            if (validFiles.length > 0) {
+                console.log(`\x1b[36m├─ Files\x1b[0m`);
+                validFiles.forEach(file => {
+                    const statusColor = file.exists ? '\x1b[32m' : '\x1b[31m';
+                    const statusText = file.exists ? '✓' : '✗';
+                    console.log(`\x1b[90m│  └─ ${statusColor}${statusText}\x1b[90m ${file.path}${file.exists
+                        ? `\x1b[33m (${file.lineCount} lines)\x1b[90m`
+                        : '\x1b[31m (not found)\x1b[90m'}\x1b[0m`);
+                });
+            }
+            if (systemInfo) {
+                console.log(`\x1b[36m├─ System Context\x1b[0m`);
+                console.log(`\x1b[90m│  └─ Platform: \x1b[33m${systemInfo.platform}\x1b[0m`);
+                console.log(`\x1b[90m│  └─ Shell: \x1b[33m${systemInfo.shell}\x1b[0m`);
+                console.log(`\x1b[90m│  └─ Working Directory: \x1b[33m${systemInfo.workingDirectory}\x1b[0m`);
+            }
+            console.log(`\x1b[36m└─ Assistant Response\x1b[0m`);
+            // Create message for AI
+            const messageForAI = createMessageWithFileInstructions(cleanContent, regularFiles, systemInfo, vscodeState.vscodeConnected ? vscodeState.editorContext : undefined);
+            // Custom save message function for headless mode
+            const saveMessage = async () => {
+                // In headless mode, we don't need to save messages
+            };
+            // Start conversation with tool support
+            await handleConversationWithTools({
+                userContent: messageForAI,
+                imageContents: [],
+                controller,
+                messages,
+                saveMessage,
+                setMessages,
+                setStreamTokenCount: streamingState.setStreamTokenCount,
+                setCurrentTodos: () => { }, // No-op in headless mode
+                requestToolConfirmation,
+                isToolAutoApproved,
+                addMultipleToAlwaysApproved,
+                yoloMode: true, // Always use YOLO mode in headless
+                setContextUsage: streamingState.setContextUsage,
+                useBasicModel: false,
+                getPendingMessages: () => [],
+                clearPendingMessages: () => { },
+                setIsStreaming: streamingState.setIsStreaming,
+                setIsReasoning: streamingState.setIsReasoning,
+                setRetryStatus: streamingState.setRetryStatus,
+            });
+        }
+        catch (error) {
+            console.error(`\n\x1b[31m✗ Error:\x1b[0m`, error instanceof Error
+                ? `\x1b[91m${error.message}\x1b[0m`
+                : '\x1b[91mUnknown error occurred\x1b[0m');
+        }
+        finally {
+            // End streaming
+            streamingState.setIsStreaming(false);
+            streamingState.setAbortController(null);
+            streamingState.setStreamTokenCount(0);
+            setIsComplete(true);
+            // Wait a moment then call onComplete
+            setTimeout(() => {
+                onComplete();
+            }, 1000);
+        }
+    };
+    useEffect(() => {
+        processMessage();
+    }, []);
+    // Simple console output mode - don't render anything
+    if (isComplete) {
+        return null;
+    }
+    // Return empty fragment - we're using console.log for output
+    return React.createElement(React.Fragment, null);
+}

package/dist/utils/sessionManager.d.ts

@@ -22,13 +22,23 @@ export interface SessionListItem {
 declare class SessionManager {
     private readonly sessionsDir;
     private currentSession;
+    private summaryAbortController;
+    private summaryTimeoutId;
     constructor();
     private ensureSessionsDir;
     private getSessionPath;
+    private formatDateForFolder;
+    /**
+     * Cancel any ongoing summary generation
+     * This prevents wasted resources and race conditions
+     */
+    private cancelOngoingSummaryGeneration;
     createNewSession(): Promise<Session>;
     saveSession(session: Session): Promise<void>;
     loadSession(sessionId: string): Promise<Session | null>;
+    private findSessionInDateFolders;
     listSessions(): Promise<SessionListItem[]>;
+    private readSessionsFromDir;
     addMessage(message: ChatMessage): Promise<void>;
     getCurrentSession(): Session | null;
     setCurrentSession(session: Session): void;