@blackbox_ai/blackbox-cli 0.8.2 → 0.8.3

package/dist/src/ui/commands/chatCommand.js

@@ -8,9 +8,229 @@ import React from 'react';
 import { Text } from 'ink';
 import { Colors } from '../colors.js';
 import { CommandKind } from './types.js';
-import { decodeTagName, CheckpointApiService } from '@blackbox_ai/blackbox-cli-core';
+import { decodeTagName, CheckpointApiService, formatThinkContent, detectModelType, createEncryptedToolParser, } from '@blackbox_ai/blackbox-cli-core';
 import path from 'node:path';
-import { MessageType } from '../types.js';
+import { MessageType, ToolCallStatus } from '../types.js';
+/**
+ * Check if text contains encrypted provider tool call markup
+ * This includes MiniMax, DeepSeek, Qwen formats and think tags
+ */
+function hasEncryptedProviderMarkup(text) {
+    // Check for various encrypted provider tool call formats
+    const patterns = [
+        /<minimax:tool_call>/,
+        /<invoke name=/,
+        /<｜tool▁calls▁begin｜>/,
+        /<｜tool▁call▁begin｜>/,
+        /<｜tool▁sep｜>/,
+        /<tool_call>/,
+        /<think>/,
+        // Bare tool call patterns
+        /<read_file[\s>]/,
+        /<glob[\s>]/,
+        /<search_files[\s>]/,
+        /<list_files[\s>]/,
+        /<create_file[\s>]/,
+        /<edit_file[\s>]/,
+        /<execute_command[\s>]/,
+        /<browser_action[\s>]/,
+        /<ask_followup_question[\s>]/,
+        /<attempt_completion[\s>]/,
+        /<new_task[\s>]/,
+        /<retrieve_knowledge[\s>]/,
+        /<web_fetch[\s>]/,
+        // Pipe-delimited patterns
+        /<\|read_file\|>/,
+        /<\|glob\|>/,
+        /<\|search_files\|>/,
+        /<\|list_files\|>/,
+        /<\|create_file\|>/,
+        /<\|edit_file\|>/,
+        /<\|execute_command\|>/,
+        /<\|browser_action\|>/,
+        /<\|ask_followup_question\|>/,
+        /<\|attempt_completion\|>/,
+        /<\|new_task\|>/,
+        /<\|retrieve_knowledge\|>/,
+        /<\|web_fetch\|>/,
+    ];
+    return patterns.some(pattern => pattern.test(text));
+}
+/**
+ * Extract think content from text and return formatted think content and remaining text
+ */
+function extractAndFormatThinkContent(text) {
+    const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+    let thinkContent = null;
+    let remainingText = text;
+    const matches = text.match(thinkRegex);
+    if (matches && matches.length > 0) {
+        // Extract all think content
+        const thinkParts = [];
+        let match;
+        while ((match = thinkRegex.exec(text)) !== null) {
+            thinkParts.push(match[1].trim());
+        }
+        if (thinkParts.length > 0) {
+            thinkContent = formatThinkContent(thinkParts.join('\n\n'));
+        }
+        // Remove think tags from remaining text
+        remainingText = text.replace(thinkRegex, '').trim();
+    }
+    return { thinkContent, remainingText };
+}
+/**
+ * Default tool declarations for parsing encrypted provider tool calls
+ * These are the common tools used in the CLI
+ */
+const DEFAULT_TOOL_DECLARATIONS = [
+    { name: 'read_file' },
+    { name: 'glob' },
+    { name: 'search_files' },
+    { name: 'list_files' },
+    { name: 'create_file' },
+    { name: 'edit_file' },
+    { name: 'execute_command' },
+    { name: 'browser_action' },
+    { name: 'ask_followup_question' },
+    { name: 'attempt_completion' },
+    { name: 'new_task' },
+    { name: 'retrieve_knowledge' },
+    { name: 'web_search' },
+    { name: 'web_fetch' },
+    { name: 'shell' },
+    { name: 'write_file' },
+    { name: 'edit' },
+    { name: 'todo_write' },
+    { name: 'skill' },
+];
+/**
+ * Extract tool result from encrypted provider user message
+ * Format: "Function <tool_name> returned: {...}"
+ */
+function extractToolResultFromUserMessage(text) {
+    const results = new Map();
+    // Pattern to match "Function <tool_name> returned: {...}"
+    // The result can be JSON or plain text
+    const functionReturnPattern = /Function\s+(\w+)\s+returned:\s*(\{[\s\S]*?\}(?=\s*(?:Function\s+\w+\s+returned:|$))|[^\n]+)/gi;
+    let match;
+    while ((match = functionReturnPattern.exec(text)) !== null) {
+        const toolName = match[1];
+        let resultText = match[2].trim();
+        let isError = false;
+        // Try to parse as JSON to extract the actual output
+        try {
+            const parsed = JSON.parse(resultText);
+            if (parsed.output) {
+                resultText = parsed.output;
+            }
+            else if (parsed.error) {
+                resultText = parsed.error;
+                isError = true;
+            }
+            else if (parsed.result) {
+                resultText = parsed.result;
+            }
+        }
+        catch {
+            // Not JSON, use as-is
+        }
+        // Check for error indicators
+        if (resultText.toLowerCase().includes('error:') || resultText.toLowerCase().includes('failed')) {
+            isError = true;
+        }
+        results.set(toolName, { output: resultText, isError });
+    }
+    return results;
+}
+/**
+ * Parse encrypted provider text for tool calls and create tool_group UI items
+ * Returns the parsed tool calls as IndividualToolCallDisplay items and the remaining text
+ */
+function parseEncryptedProviderToolCalls(text, toolResults) {
+    const toolDisplays = [];
+    // First extract think content
+    const { thinkContent, remainingText: textAfterThink } = extractAndFormatThinkContent(text);
+    // Detect model type and parse tool calls
+    const modelType = detectModelType(textAfterThink);
+    const parser = createEncryptedToolParser();
+    const parseResult = parser.parseComplete(textAfterThink, DEFAULT_TOOL_DECLARATIONS, modelType);
+    if (parseResult.success && parseResult.toolCalls.length > 0) {
+        for (const toolCall of parseResult.toolCalls) {
+            const toolName = toolCall.name;
+            const args = toolCall.arguments;
+            // Create a description based on tool name and args
+            let description = toolName;
+            if (toolName === 'web_search' && args['query']) {
+                description = `Searching the web for: "${args['query']}"`;
+            }
+            else if (toolName === 'web_fetch' && args['url']) {
+                description = `Fetching URL: ${args['url']}`;
+            }
+            else if (toolName === 'read_file' && (args['file_path'] || args['path'])) {
+                description = `Reading file: ${args['file_path'] || args['path']}`;
+            }
+            else if ((toolName === 'write_file' || toolName === 'create_file') && (args['file_path'] || args['path'])) {
+                description = `Writing to file: ${args['file_path'] || args['path']}`;
+            }
+            else if ((toolName === 'shell' || toolName === 'execute_command') && args['command']) {
+                description = `Running command: ${args['command']}`;
+            }
+            else if (toolName === 'edit' && (args['file_path'] || args['path'])) {
+                description = `Editing file: ${args['file_path'] || args['path']}`;
+            }
+            else if (toolName === 'edit_file' && (args['file_path'] || args['path'])) {
+                description = `Editing file: ${args['file_path'] || args['path']}`;
+            }
+            else if (toolName === 'glob' && args['pattern']) {
+                description = `Finding files matching: ${args['pattern']}`;
+            }
+            else if (toolName === 'search_files' && args['regex']) {
+                description = `Searching for: ${args['regex']}`;
+            }
+            else if (toolName === 'list_files' && args['path']) {
+                description = `Listing files in: ${args['path']}`;
+            }
+            else if (toolName === 'ask_followup_question' && args['question']) {
+                description = `Asking: ${args['question'].substring(0, 50)}...`;
+            }
+            else if (toolName === 'attempt_completion' && args['result']) {
+                description = `Completing task`;
+            }
+            else if (toolName === 'browser_action' && args['action']) {
+                description = `Browser: ${args['action']}`;
+            }
+            else if (toolName === 'todo_write') {
+                description = 'Update todos';
+            }
+            else if (toolName === 'skill' && args['skill_name']) {
+                description = `Using skill: ${args['skill_name']}`;
+            }
+            // Get the tool result if available
+            let resultDisplay = '(Tool call from resumed session - result not available)';
+            let isError = false;
+            if (toolResults && toolResults.has(toolName)) {
+                const result = toolResults.get(toolName);
+                resultDisplay = result.output;
+                isError = result.isError;
+            }
+            toolDisplays.push({
+                callId: toolCall.id || `restored-${toolName}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                name: toolName,
+                description,
+                resultDisplay,
+                status: isError ? ToolCallStatus.Error : ToolCallStatus.Success,
+                confirmationDetails: undefined,
+                renderOutputAsMarkdown: true, // Enable markdown rendering for tool results
+            });
+        }
+    }
+    return {
+        toolDisplays,
+        remainingText: parseResult.normalText,
+        thinkContent,
+    };
+}
 /**
  * Formats a date into a human-readable relative time or date string.
  */
@@ -42,7 +262,7 @@ function formatRelativeTime(date) {
 /**
  * Formats a tag name into a human-readable display name.
  * Converts ISO timestamps to readable dates and extracts meaningful names.
- * Format: "message preview (time ago)" or "Auto-save (time ago)"
+ * Format: "message preview (time ago)" or "Session (time ago)"
  */
 function formatTagForDisplay(tag, firstMessagePreview, mtime) {
     const timeStr = mtime ? ` (${formatRelativeTime(mtime)})` : '';
@@ -60,15 +280,13 @@ function formatTagForDisplay(tag, firstMessagePreview, mtime) {
         }
         return `${preview}${timeStr}`;
     }
-    // Check for auto-save-YYYY-MM-DDTHH-MM-SS format
-    const autoSaveMatch = tag.match(/^auto-save-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})$/);
-    if (autoSaveMatch) {
-        return `Auto-save${timeStr}`;
+    // Check for session-* format (progressive save)
+    if (tag.startsWith('session-')) {
+        return `Session${timeStr}`;
     }
-    // Check for auto-save chat YYYY-MM-DDTHH-MM-SS format (with space)
-    const autoSaveChatMatch = tag.match(/^auto-save chat (\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})$/);
-    if (autoSaveChatMatch) {
-        return `Auto-save${timeStr}`;
+    // Check for cloud-task-* format
+    if (tag.startsWith('cloud-task-')) {
+        return `Cloud Task${timeStr}`;
     }
     // Check for timestamp format like "2025-11-24T18-34-38-727Z"
     const timestampMatch = tag.match(/(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})/);
@@ -352,8 +570,10 @@ function formatCloudTaskStatusCard(taskInfo, commandPrefix = '/chat resume') {
  */
 function looksLikeCloudTaskId(tag) {
     // Cloud task IDs are typically alphanumeric with dashes/underscores, 10-30 chars
-    // They don't look like timestamps or auto-save tags
-    if (tag.startsWith('auto-save'))
+    // They don't look like timestamps or session tags
+    if (tag.startsWith('session-'))
+        return false;
+    if (tag.startsWith('cloud-task-'))
         return false;
     if (tag.match(/^\d{4}-\d{2}-\d{2}/))
         return false; // Timestamp format
@@ -364,16 +584,29 @@ function looksLikeCloudTaskId(tag) {
 const resumeCommand = {
     name: 'resume',
     altNames: ['load'],
-    description: 'Resume a conversation checkpoint. Usage: /chat resume <tag-or-task-id>',
+    description: 'Resume a conversation checkpoint. Usage: /chat resume [tag-or-task-id]. Without arguments, resumes the most recent session.',
     kind: CommandKind.BUILT_IN,
     action: async (context, args) => {
         let tag = args.trim();
+        // If no tag provided, try to find the most recent session checkpoint
         if (!tag) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Missing tag or task ID. Usage: /chat resume <tag-or-task-id>',
-            };
+            const savedChats = await getSavedChatTags(context, true); // sorted by mtime desc (newest first)
+            if (savedChats.length === 0) {
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: 'No saved conversation checkpoints found. Use /chat resume <tag> to resume a specific checkpoint.',
+                };
+            }
+            // Find the most recent session checkpoint (session-*)
+            const sessionCheckpoint = savedChats.find(chat => chat.name.startsWith('session-'));
+            if (sessionCheckpoint) {
+                tag = sessionCheckpoint.name;
+            }
+            else {
+                // Fall back to the most recent checkpoint of any type
+                tag = savedChats[0].name;
+            }
         }
         // Normalize cloud-task prefix if present
         const originalTag = tag;
@@ -460,23 +693,271 @@ const resumeCommand = {
         const uiHistory = [];
         let hasSystemPrompt = false;
         let i = 0;
+        // Track pending function calls to match with their responses
+        const pendingFunctionCalls = new Map();
         for (const item of conversation) {
             i += 1;
-            const text = item.parts
-                ?.filter((m) => !!m.text)
-                .map((m) => m.text)
-                .join('') || '';
-            if (!text) {
-                continue;
-            }
+            // Check for system prompt in first message
+            const textParts = item.parts?.filter((m) => !!m.text) || [];
+            const text = textParts.map((m) => m.text).join('') || '';
             if (i === 1 && text.match(/context for our chat/)) {
                 hasSystemPrompt = true;
+                continue;
             }
-            if (i > 2 || !hasSystemPrompt) {
-                uiHistory.push({
-                    type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
-                    text,
-                });
+            // Skip the model acknowledgment of system prompt
+            if (i === 2 && hasSystemPrompt) {
+                continue;
+            }
+            // Process function calls from model responses
+            const functionCallParts = item.parts?.filter((m) => !!m.functionCall) || [];
+            // Process function responses from user messages
+            const functionResponseParts = item.parts?.filter((m) => !!m.functionResponse) || [];
+            // Handle function calls (from model)
+            if (functionCallParts.length > 0 && item.role === 'model') {
+                for (const part of functionCallParts) {
+                    const fc = part.functionCall;
+                    if (fc) {
+                        // Store the function call for later matching with its response
+                        pendingFunctionCalls.set(fc.name, { name: fc.name, args: fc.args || {} });
+                    }
+                }
+                // If there's also text content, add it as a gemini message
+                if (text) {
+                    uiHistory.push({
+                        type: MessageType.GEMINI,
+                        text,
+                    });
+                }
+                continue;
+            }
+            // Handle function responses (from user) - create tool_group display
+            if (functionResponseParts.length > 0 && item.role === 'user') {
+                const toolDisplays = [];
+                for (const part of functionResponseParts) {
+                    const fr = part.functionResponse;
+                    if (fr) {
+                        const toolName = fr.name;
+                        const response = fr.response;
+                        // Extract the result text - check for common response formats
+                        // Tools may return: { result: "..." }, { output: "..." }, { error: "..." }, or other formats
+                        let resultText = '';
+                        let isError = false;
+                        if (response) {
+                            if (typeof response === 'string') {
+                                resultText = response;
+                            }
+                            else if (response.result) {
+                                resultText = response.result;
+                            }
+                            else if (response.output) {
+                                resultText = response.output;
+                            }
+                            else if (response.error) {
+                                resultText = response.error;
+                                isError = true;
+                            }
+                            else {
+                                // For other formats, try to extract meaningful content
+                                const responseObj = response;
+                                // Check for common field names
+                                const commonFields = ['content', 'data', 'text', 'message', 'value'];
+                                for (const field of commonFields) {
+                                    if (responseObj[field] && typeof responseObj[field] === 'string') {
+                                        resultText = responseObj[field];
+                                        break;
+                                    }
+                                }
+                                // If still no result, stringify but try to make it readable
+                                if (!resultText) {
+                                    resultText = JSON.stringify(response, null, 2);
+                                }
+                            }
+                        }
+                        // Get the original args from pending calls if available
+                        const pendingCall = pendingFunctionCalls.get(toolName);
+                        const args = pendingCall?.args || {};
+                        // Create a description based on tool name and args
+                        let description = toolName;
+                        // Use ToolResultDisplay type which includes FileDiff and TodoResultDisplay
+                        let resultDisplayValue = resultText;
+                        if (toolName === 'web_search' && args['query']) {
+                            description = `Searching the web for: "${args['query']}"`;
+                        }
+                        else if (toolName === 'web_fetch' && (args['url'] || args['urls'])) {
+                            const url = args['url'] || (Array.isArray(args['urls']) ? args['urls'][0] : args['urls']);
+                            description = `Fetching URL: ${url}`;
+                        }
+                        else if (toolName === 'read_file' && args['file_path']) {
+                            description = `Reading file: ${args['file_path']}`;
+                        }
+                        else if (toolName === 'write_file' && args['file_path']) {
+                            const filePath = args['file_path'];
+                            const content = args['content'];
+                            description = `Writing to file: ${filePath}`;
+                            // Generate a diff display for write_file
+                            if (content) {
+                                const fileName = filePath.split('/').pop() || filePath;
+                                // Create a unified diff showing the new content
+                                const diffLines = [
+                                    `--- /dev/null`,
+                                    `+++ ${fileName}`,
+                                    `@@ -0,0 +1,${content.split('\n').length} @@`,
+                                    ...content.split('\n').map(line => `+${line}`),
+                                ];
+                                resultDisplayValue = {
+                                    fileDiff: diffLines.join('\n'),
+                                    fileName,
+                                    originalContent: null,
+                                    newContent: content,
+                                };
+                            }
+                        }
+                        else if ((toolName === 'shell' || toolName === 'execute_command') && args['command']) {
+                            description = `Running command: ${args['command']}`;
+                        }
+                        else if (toolName === 'edit' && args['file_path']) {
+                            const filePath = args['file_path'];
+                            const oldString = args['old_string'];
+                            const newString = args['new_string'];
+                            description = `Editing file: ${filePath}`;
+                            // Generate a diff from old_string and new_string for display
+                            if (oldString !== undefined && newString !== undefined) {
+                                const fileName = filePath.split('/').pop() || filePath;
+                                // Create a simple unified diff format
+                                const oldLines = (oldString || '').split('\n');
+                                const newLines = (newString || '').split('\n');
+                                const diffLines = [
+                                    `--- a/${fileName}`,
+                                    `+++ b/${fileName}`,
+                                    `@@ -1,${oldLines.length} +1,${newLines.length} @@`,
+                                    ...oldLines.map(line => `-${line}`),
+                                    ...newLines.map(line => `+${line}`),
+                                ];
+                                resultDisplayValue = {
+                                    fileDiff: diffLines.join('\n'),
+                                    fileName,
+                                    originalContent: oldString,
+                                    newContent: newString,
+                                };
+                            }
+                        }
+                        else if (toolName === 'todo_write') {
+                            description = 'Update todos';
+                            // Parse the todo_write response to create a TodoResultDisplay
+                            try {
+                                // The response could be the object directly or a string that needs parsing
+                                let todoResponse = null;
+                                // First try to parse from resultText (which may be the JSON string)
+                                if (typeof resultText === 'string' && resultText.trim().startsWith('{')) {
+                                    try {
+                                        todoResponse = JSON.parse(resultText);
+                                    }
+                                    catch {
+                                        // Ignore parse errors
+                                    }
+                                }
+                                // If that didn't work, try the response object directly
+                                if (!todoResponse && typeof response === 'object' && response !== null) {
+                                    // Check if response has todos property (it might be nested differently)
+                                    const responseAny = response;
+                                    if ('todos' in responseAny && Array.isArray(responseAny['todos'])) {
+                                        todoResponse = responseAny;
+                                    }
+                                }
+                                if (todoResponse && todoResponse.todos && Array.isArray(todoResponse.todos)) {
+                                    // Return a TodoResultDisplay object
+                                    resultDisplayValue = {
+                                        type: 'todo_list',
+                                        todos: todoResponse.todos.map((todo) => ({
+                                            id: todo.id || '',
+                                            content: todo.content || '',
+                                            status: todo.status || 'pending',
+                                        })),
+                                    };
+                                }
+                            }
+                            catch {
+                                // If parsing fails, keep the original resultText
+                            }
+                        }
+                        toolDisplays.push({
+                            callId: `restored-${toolName}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+                            name: toolName,
+                            description,
+                            resultDisplay: resultDisplayValue,
+                            status: isError ? ToolCallStatus.Error : ToolCallStatus.Success,
+                            confirmationDetails: undefined,
+                            renderOutputAsMarkdown: typeof resultDisplayValue === 'string',
+                        });
+                        // Remove from pending
+                        pendingFunctionCalls.delete(toolName);
+                    }
+                }
+                if (toolDisplays.length > 0) {
+                    uiHistory.push({
+                        type: 'tool_group',
+                        tools: toolDisplays,
+                    });
+                }
+                continue;
+            }
+            // Handle regular text messages
+            if (text) {
+                // Check if this is model content with encrypted provider markup
+                // (MiniMax, DeepSeek, Qwen tool call formats or think tags)
+                if (item.role === 'model' && hasEncryptedProviderMarkup(text)) {
+                    // Look ahead to find tool results in the next user message
+                    // For encrypted providers, tool results are in user messages like:
+                    // "Function <tool_name> returned: {...}"
+                    let toolResults;
+                    // Find the next user message in the conversation
+                    const currentIndex = conversation.indexOf(item);
+                    if (currentIndex >= 0 && currentIndex < conversation.length - 1) {
+                        const nextItem = conversation[currentIndex + 1];
+                        if (nextItem && nextItem.role === 'user') {
+                            const nextTextParts = nextItem.parts?.filter((m) => !!m.text) || [];
+                            const nextText = nextTextParts.map((m) => m.text).join('') || '';
+                            if (nextText && nextText.includes('Function') && nextText.includes('returned:')) {
+                                toolResults = extractToolResultFromUserMessage(nextText);
+                            }
+                        }
+                    }
+                    // Parse tool calls and create tool_group UI items
+                    const { toolDisplays, remainingText, thinkContent } = parseEncryptedProviderToolCalls(text, toolResults);
+                    // Add think content as a separate message if present
+                    if (thinkContent && thinkContent.trim()) {
+                        uiHistory.push({
+                            type: MessageType.GEMINI,
+                            text: thinkContent,
+                        });
+                    }
+                    // Add tool_group if there are tool calls
+                    if (toolDisplays.length > 0) {
+                        uiHistory.push({
+                            type: 'tool_group',
+                            tools: toolDisplays,
+                        });
+                    }
+                    // Add remaining text as a gemini message if present
+                    if (remainingText && remainingText.trim()) {
+                        uiHistory.push({
+                            type: MessageType.GEMINI,
+                            text: remainingText,
+                        });
+                    }
+                }
+                else if (item.role === 'user' && text.includes('Function') && text.includes('returned:')) {
+                    // Skip user messages that contain tool results - they were already processed
+                    // when we looked ahead from the model message
+                    continue;
+                }
+                else {
+                    // Regular text message without encrypted provider markup
+                    uiHistory.push({
+                        type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
+                        text,
+                    });
+                }
             }
         }
         return {