@banaxi/banana-code 1.0.5 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.0.5",
+    "version": "1.1.0",
     "description": "🍌 BananaCode",
     "type": "module",
     "license": "GPL-3.0-or-later",
@@ -21,6 +21,8 @@
         "chalk": "^5.4.1",
         "diff": "^8.0.4",
         "glob": "13.0.6",
+        "marked": "^15.0.12",
+        "marked-terminal": "^7.3.0",
         "open": "^11.0.0",
         "openai": "^4.79.1",
         "ora": "^8.1.1"

package/src/config.js

@@ -6,7 +6,7 @@ import { execSync } from 'child_process';
 import fsSync from 'fs';
 import chalk from 'chalk';
 
-import { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS } from './constants.js';
+import { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS } from './constants.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'banana-code');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -41,10 +41,31 @@ export async function setupProvider(provider, config = {}) {
             default: config.apiKey
         });
         config.model = await select({
-            message: 'Select a Gemini model:',
-            choices: GEMINI_MODELS
+            message: 'Select a model:',
+            choices: OPENAI_MODELS
         });
-    } else if (provider === 'claude') {
+        } else if (provider === 'ollama_cloud') {
+            config.apiKey = await input({
+                message: 'Enter your OLLAMA_API_KEY (from ollama.com):',
+                default: config.apiKey
+            });
+
+            const choices = [...OLLAMA_CLOUD_MODELS, { name: chalk.magenta('✎ Enter custom model ID...'), value: 'CUSTOM_ID' }];
+            let selectedModel = await select({
+                message: 'Select an Ollama Cloud model:',
+                choices,
+                loop: false,
+                pageSize: Math.max(choices.length, 15)
+            });
+
+            if (selectedModel === 'CUSTOM_ID') {
+                selectedModel = await input({
+                    message: 'Enter the exact model ID (e.g., gemma3:27b-cloud):',
+                    validate: (v) => v.trim().length > 0 || 'Model ID cannot be empty'
+                });
+            }
+            config.model = selectedModel;
+        } else if (provider === 'ollama') {
         config.apiKey = await input({
             message: 'Enter your ANTHROPIC_API_KEY:',
             default: config.apiKey
@@ -137,6 +158,7 @@ async function runSetupWizard() {
             { name: 'Google Gemini', value: 'gemini' },
             { name: 'Anthropic Claude', value: 'claude' },
             { name: 'OpenAI', value: 'openai' },
+            { name: 'Ollama Cloud', value: 'ollama_cloud' },
             { name: 'Ollama (Local)', value: 'ollama' }
         ]
     });

package/src/constants.js

@@ -19,6 +19,17 @@ export const OPENAI_MODELS = [
     { name: 'GPT-5.3 Instant', value: 'gpt-5.3-instant' }
 ];
 
+export const OLLAMA_CLOUD_MODELS = [
+    { name: 'Kimi K2 Thinking (Cloud)', value: 'kimi-k2-thinking:cloud' },
+    { name: 'Kimi K2.5 (Cloud)', value: 'kimi-k2.5:cloud' },
+    { name: 'Qwen 3.5 397B (Cloud)', value: 'qwen3.5:397b-cloud' },
+    { name: 'DeepSeek V3.2 (Cloud)', value: 'deepseek-v3.2:cloud' },
+    { name: 'GLM-5 (Cloud)', value: 'glm-5:cloud' },
+    { name: 'MiniMax M2.7 (Cloud)', value: 'minimax-m2.7:cloud' },
+    { name: 'Llama 3.3 70B (Cloud)', value: 'llama3.3:cloud' },
+    { name: 'Llama 3.1 405B (Cloud)', value: 'llama3.1:405b-cloud' }
+];
+
 export const CODEX_MODELS = [
     { name: 'GPT-5.4 (Newest)', value: 'gpt-5.4' },
     { name: 'GPT-5.3 Codex', value: 'gpt-5.3-codex' },

package/src/index.js

@@ -8,12 +8,17 @@ import { GeminiProvider } from './providers/gemini.js';
 import { ClaudeProvider } from './providers/claude.js';
 import { OpenAIProvider } from './providers/openai.js';
 import { OllamaProvider } from './providers/ollama.js';
+import { OllamaCloudProvider } from './providers/ollamaCloud.js';
 
 import { loadSession, saveSession, generateSessionId, getLatestSessionId, listSessions } from './sessions.js';
+import { printMarkdown } from './utils/markdown.js';
 
 let config;
 let providerInstance;
 let currentSessionId;
+const commandHistory = [];
+let historyIndex = -1;
+let currentInputSaved = '';
 
 function createProvider(overrideConfig = null) {
     const activeConfig = overrideConfig || config;
@@ -21,6 +26,7 @@ function createProvider(overrideConfig = null) {
         case 'gemini': return new GeminiProvider(activeConfig);
         case 'claude': return new ClaudeProvider(activeConfig);
         case 'openai': return new OpenAIProvider(activeConfig);
+        case 'ollama_cloud': return new OllamaCloudProvider(activeConfig);
         case 'ollama': return new OllamaProvider(activeConfig);
         default:
             console.log(chalk.red(`Unknown provider: ${activeConfig.provider}. Defaulting to Ollama.`));
@@ -43,12 +49,13 @@ async function handleSlashCommand(command) {
                         { name: 'Google Gemini', value: 'gemini' },
                         { name: 'Anthropic Claude', value: 'claude' },
                         { name: 'OpenAI', value: 'openai' },
+                        { name: 'Ollama Cloud', value: 'ollama_cloud' },
                         { name: 'Ollama (Local)', value: 'ollama' }
                     ]
                 });
             }
 
-            if (['gemini', 'claude', 'openai', 'ollama'].includes(newProv)) {
+            if (['gemini', 'claude', 'openai', 'ollama_cloud', 'ollama'].includes(newProv)) {
                 // Use the shared setup logic to get keys/models
                 config = await setupProvider(newProv, config);
                 await saveConfig(config);
@@ -63,13 +70,15 @@ async function handleSlashCommand(command) {
             if (!newModel) {
                 // Interactive selection
                 const { select } = await import('@inquirer/prompts');
-                const { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS } = await import('./constants.js');
+                const { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS } = await import('./constants.js');
 
                 let choices = [];
                 if (config.provider === 'gemini') choices = GEMINI_MODELS;
                 else if (config.provider === 'claude') choices = CLAUDE_MODELS;
                 else if (config.provider === 'openai') {
                     choices = config.authType === 'oauth' ? CODEX_MODELS : OPENAI_MODELS;
+                } else if (config.provider === 'ollama_cloud') {
+                    choices = OLLAMA_CLOUD_MODELS;
                 } else if (config.provider === 'ollama') {
                     try {
                         const response = await fetch('http://localhost:11434/api/tags');
@@ -82,10 +91,25 @@ async function handleSlashCommand(command) {
                 }
 
                 if (choices.length > 0) {
+                    const finalChoices = [...choices];
+                    if (config.provider === 'ollama_cloud') {
+                        finalChoices.push({ name: chalk.magenta('✎ Enter custom model ID...'), value: 'CUSTOM_ID' });
+                    }
+                    
                     newModel = await select({
                         message: 'Select a model:',
-                        choices
+                        choices: finalChoices,
+                        loop: false,
+                        pageSize: Math.max(finalChoices.length, 15)
                     });
+
+                    if (newModel === 'CUSTOM_ID') {
+                        const { input } = await import('@inquirer/prompts');
+                        newModel = await input({
+                            message: 'Enter the exact model ID (e.g., gemma3:27b-cloud):',
+                            validate: (v) => v.trim().length > 0 || 'Model ID cannot be empty'
+                        });
+                    }
                 }
             }
 
@@ -161,6 +185,30 @@ async function handleSlashCommand(command) {
             providerInstance = createProvider(); // Re-init to update tools
             console.log(chalk.green(`Beta tools updated: ${enabledBetaTools.join(', ') || 'none'}`));
             break;
+        case '/settings':
+            const { checkbox: settingsCheckbox } = await import('@inquirer/prompts');
+            const enabledSettings = await settingsCheckbox({
+                message: 'Select features to enable (Space to toggle, Enter to confirm):',
+                choices: [
+                    {
+                        name: 'Auto-feed workspace files to AI (uses .bananacodeignore / .gitignore)',
+                        value: 'autoFeedWorkspace',
+                        checked: config.autoFeedWorkspace || false
+                    },
+                    {
+                        name: 'Use syntax highlighting for AI output (requires waiting for full response)',
+                        value: 'useMarkedTerminal',
+                        checked: config.useMarkedTerminal || false
+                    }
+                ]
+            });
+            
+            config.autoFeedWorkspace = enabledSettings.includes('autoFeedWorkspace');
+            config.useMarkedTerminal = enabledSettings.includes('useMarkedTerminal');
+            await saveConfig(config);
+            providerInstance = createProvider(); // Re-init to update tools/config
+            console.log(chalk.green(`Settings updated.`));
+            break;
         case '/debug':
             config.debug = !config.debug;
             await saveConfig(config);
@@ -190,6 +238,7 @@ Available commands:
   /context         - Show current context window size
   /permissions     - List session-approved permissions
   /beta            - Manage beta features and tools
+  /settings        - Manage app settings (workspace auto-feed, etc)
   /debug           - Toggle debug mode (show tool results)
   /help            - Show all commands
   /exit            - Quit Banana Code
@@ -378,6 +427,10 @@ function promptUser() {
 
             if (str === '\r' || str === '\n') {                 // Enter
                 exitRequested = false;
+                if (inputBuffer.trim() && inputBuffer !== commandHistory[commandHistory.length - 1]) {
+                    commandHistory.push(inputBuffer);
+                }
+                historyIndex = -1;
                 resolve(inputBuffer);
                 return;
             }
@@ -411,6 +464,33 @@ function promptUser() {
                 return;
             }
 
+            if (str === '\x1b[A') {                             // Arrow Up
+                if (historyIndex === -1) {
+                    currentInputSaved = inputBuffer;
+                }
+                if (historyIndex < commandHistory.length - 1) {
+                    historyIndex++;
+                    inputBuffer = commandHistory[commandHistory.length - 1 - historyIndex];
+                    cursorPos = inputBuffer.length;
+                    drawPromptBox(inputBuffer, cursorPos);
+                }
+                return;
+            }
+
+            if (str === '\x1b[B') {                             // Arrow Down
+                if (historyIndex > -1) {
+                    historyIndex--;
+                    if (historyIndex === -1) {
+                        inputBuffer = currentInputSaved;
+                    } else {
+                        inputBuffer = commandHistory[commandHistory.length - 1 - historyIndex];
+                    }
+                    cursorPos = inputBuffer.length;
+                    drawPromptBox(inputBuffer, cursorPos);
+                }
+                return;
+            }
+
             if (str === '\x1b[H' || str === '\x01') {           // Home / Ctrl+A
                 cursorPos = 0; drawPromptBox(inputBuffer, cursorPos);
                 return;
@@ -462,20 +542,23 @@ async function main() {
                     for (const msg of session.messages) {
                         if (msg.role === 'system') continue;
 
-                        if (session.provider === 'gemini') {
+                        if (config.provider === 'gemini') {
                             if (msg.role === 'user') {
                                 if (msg.parts[0]?.text) console.log(`${chalk.yellow('🍌 >')} ${msg.parts[0].text}`);
                                 else if (msg.parts[0]?.functionResponse) {
-                                    console.log(chalk.yellow(`[Tool Result: ${msg.parts[0].functionResponse.name}]`));
+                                    console.log(chalk.yellow(`[Tool Result Received]`));
                                 }
                             } else if (msg.role === 'model') {
                                 msg.parts.forEach(p => {
-                                    if (p.text) process.stdout.write(chalk.cyan(p.text));
+                                    if (p.text) {
+                                        if (config.useMarkedTerminal) printMarkdown(p.text);
+                                        else process.stdout.write(chalk.cyan(p.text));
+                                    }
                                     if (p.functionCall) console.log(chalk.yellow(`\n[Banana Calling Tool: ${p.functionCall.name}]`));
                                 });
                                 console.log();
                             }
-                        } else if (session.provider === 'claude') {
+                        } else if (config.provider === 'claude') {
                             if (msg.role === 'user') {
                                 if (typeof msg.content === 'string') console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
                                 else {
@@ -484,26 +567,36 @@ async function main() {
                                     });
                                 }
                             } else if (msg.role === 'assistant') {
-                                if (typeof msg.content === 'string') console.log(chalk.cyan(msg.content));
-                                else {
+                                if (typeof msg.content === 'string') {
+                                    if (config.useMarkedTerminal) printMarkdown(msg.content);
+                                    else process.stdout.write(chalk.cyan(msg.content));
+                                } else {
                                     msg.content.forEach(c => {
-                                        if (c.type === 'text') process.stdout.write(chalk.cyan(c.text));
+                                        if (c.type === 'text') {
+                                            if (config.useMarkedTerminal) printMarkdown(c.text);
+                                            else process.stdout.write(chalk.cyan(c.text));
+                                        }
                                         if (c.type === 'tool_use') console.log(chalk.yellow(`\n[Banana Calling Tool: ${c.name}]`));
                                     });
-                                    console.log();
                                 }
+                                console.log();
                             }
                         } else {
                             // OpenAI, Ollama
                             if (msg.role === 'user') {
                                 console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
                             } else if (msg.role === 'assistant' || msg.role === 'output_text') {
-                                if (msg.content) console.log(chalk.cyan(msg.content));
+                                if (msg.content) {
+                                    if (config.useMarkedTerminal) printMarkdown(msg.content);
+                                    else process.stdout.write(chalk.cyan(msg.content));
+                                }
                                 if (msg.tool_calls) {
                                     msg.tool_calls.forEach(tc => {
-                                        console.log(chalk.yellow(`[Banana Calling Tool: ${tc.function.name}]`));
+                                        const name = tc.function ? tc.function.name : tc.name;
+                                        console.log(chalk.yellow(`\n[Banana Calling Tool: ${name}]`));
                                     });
                                 }
+                                console.log();
                             } else if (msg.role === 'tool') {
                                 console.log(chalk.yellow(`[Tool Result Received]`));
                             }
@@ -535,8 +628,49 @@ async function main() {
             if (trimmed.startsWith('/')) {
                 await handleSlashCommand(trimmed);
             } else {
+                let finalInput = trimmed;
+                const fileMentions = trimmed.match(/@@?([\w/.-]+)/g);
+                if (fileMentions) {
+                    let addedFiles = 0;
+                    const fsSync = await import('fs');
+                    const path = await import('path');
+                    for (const mention of fileMentions) {
+                        let filepath;
+                        if (mention.startsWith('@@')) {
+                            filepath = mention.substring(2);
+                        } else {
+                            filepath = path.join(process.cwd(), mention.substring(1));
+                        }
+                        
+                        try {
+                            const stat = fsSync.statSync(filepath);
+                            if (stat.isFile()) {
+                                const content = fsSync.readFileSync(filepath, 'utf8');
+                                finalInput += `\n\n--- File Context: ${filepath} ---\n${content}\n--- End of ${filepath} ---`;
+                                addedFiles++;
+                            }
+                        } catch (e) {
+                            console.log(chalk.yellow(`Warning: Could not read file for mention ${mention}`));
+                        }
+                    }
+                    if (addedFiles > 0) {
+                        console.log(chalk.gray(`(Attached ${addedFiles} file(s) to context)`));
+                    }
+                }
+
+                if (config.autoFeedWorkspace) {
+                    const { getWorkspaceTree } = await import('./utils/workspace.js');
+                    const tree = await getWorkspaceTree();
+                    const { getSystemPrompt } = await import('./prompt.js');
+                    let newSysPrompt = getSystemPrompt(config);
+                    newSysPrompt += `\n\n--- Workspace File Tree ---\n${tree}\n--- End of Tree ---`;
+                    if (typeof providerInstance.updateSystemPrompt === 'function') {
+                        providerInstance.updateSystemPrompt(newSysPrompt);
+                    }
+                }
+
                 process.stdout.write(chalk.cyan('✦ '));
-                await providerInstance.sendMessage(trimmed);
+                await providerInstance.sendMessage(finalInput);
                 console.log(); // Extra newline after AI response
                 // Save session after AI message
                 await saveSession(currentSessionId, {

package/src/providers/claude.js

@@ -3,9 +3,11 @@ import { getAvailableTools, executeTool } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
 
 export class ClaudeProvider {
     constructor(config) {
+        this.config = config;
         this.anthropic = new Anthropic({ apiKey: config.apiKey });
         this.modelName = config.model || 'claude-3-7-sonnet-20250219';
         this.messages = [];
@@ -17,6 +19,10 @@ export class ClaudeProvider {
         this.systemPrompt = getSystemPrompt(config);
     }
 
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+    }
+
     async sendMessage(message) {
         this.messages.push({ role: 'user', content: message });
 
@@ -47,8 +53,10 @@ export class ClaudeProvider {
 
                 for await (const event of stream) {
                     if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
-                        if (spinner.isSpinning) spinner.stop();
-                        process.stdout.write(chalk.cyan(event.delta.text));
+                        if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                        if (!this.config.useMarkedTerminal) {
+                            process.stdout.write(chalk.cyan(event.delta.text));
+                        }
                         chunkResponse += event.delta.text;
                         finalResponse += event.delta.text;
                     } else if (event.type === 'content_block_start' && event.content_block.type === 'tool_use') {
@@ -76,8 +84,11 @@ export class ClaudeProvider {
                     }
                 }
 
+                if (spinner.isSpinning) spinner.stop();
+
                 const newContent = [];
                 if (chunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(chunkResponse);
                     newContent.push({ type: 'text', text: chunkResponse });
                 }
 

package/src/providers/gemini.js

@@ -2,6 +2,7 @@ import { getAvailableTools, executeTool } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
 
 export class GeminiProvider {
     constructor(config) {
@@ -17,6 +18,10 @@ export class GeminiProvider {
         this.systemPrompt = getSystemPrompt(config);
     }
 
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+    }
+
     async sendMessage(message) {
         this.messages.push({ role: 'user', parts: [{ text: message }] });
 
@@ -25,6 +30,7 @@ export class GeminiProvider {
 
         try {
             while (true) {
+                let currentTurnText = '';
                 const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${this.modelName}:streamGenerateContent?alt=sse&key=${this.apiKey}`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -74,9 +80,12 @@ export class GeminiProvider {
                             if (content && content.parts) {
                                 for (const part of content.parts) {
                                     if (part.text) {
-                                        if (spinner && spinner.isSpinning) spinner.stop();
-                                        process.stdout.write(chalk.cyan(part.text));
+                                        if (spinner && spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                                        if (!this.config.useMarkedTerminal) {
+                                            process.stdout.write(chalk.cyan(part.text));
+                                        }
                                         responseText += part.text;
+                                        currentTurnText += part.text;
 
                                         // Aggregate sequential text parts
                                         let lastPart = aggregatedParts[aggregatedParts.length - 1];
@@ -109,6 +118,10 @@ export class GeminiProvider {
 
                 if (spinner && spinner.isSpinning) spinner.stop();
 
+                if (currentTurnText && this.config.useMarkedTerminal) {
+                    printMarkdown(currentTurnText);
+                }
+
                 if (aggregatedParts.length === 0) break;
 
                 // Push exact unmutated model response back to history

package/src/providers/ollama.js

@@ -2,6 +2,7 @@ import { getAvailableTools, executeTool } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
 
 export class OllamaProvider {
     constructor(config) {
@@ -20,6 +21,13 @@ export class OllamaProvider {
         this.URL = 'http://localhost:11434/api/chat';
     }
 
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
     async sendMessage(message) {
         this.messages.push({ role: 'user', content: message });
 
@@ -49,7 +57,11 @@ export class OllamaProvider {
                 const messageObj = data.message;
 
                 if (messageObj.content) {
-                    process.stdout.write(chalk.cyan(messageObj.content));
+                    if (this.config.useMarkedTerminal) {
+                        printMarkdown(messageObj.content);
+                    } else {
+                        process.stdout.write(chalk.cyan(messageObj.content));
+                    }
                     finalResponse += messageObj.content;
                 }
 

package/src/providers/ollamaCloud.js

@@ -0,0 +1,107 @@
+import { getAvailableTools, executeTool } from '../tools/registry.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
+
+export class OllamaCloudProvider {
+    constructor(config) {
+        this.config = config;
+        this.apiKey = config.apiKey;
+        this.modelName = config.model || 'llama3.3';
+        this.systemPrompt = getSystemPrompt(config);
+        this.messages = [{ role: 'system', content: this.systemPrompt }];
+        this.tools = getAvailableTools(config).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            }
+        }));
+        this.URL = 'https://ollama.com/api/chat';
+    }
+
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
+    async sendMessage(message) {
+        this.messages.push({ role: 'user', content: message });
+
+        let spinner = ora({ text: 'Thinking (Cloud)...', color: 'yellow', stream: process.stdout }).start();
+        let finalResponse = '';
+
+        try {
+            while (true) {
+                const response = await fetch(this.URL, {
+                    method: 'POST',
+                    headers: { 
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: this.modelName,
+                        messages: this.messages,
+                        tools: this.tools.length > 0 ? this.tools : undefined,
+                        stream: false // Cloud API sometimes prefers non-streaming or different SSE formats
+                    })
+                });
+
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    spinner.stop();
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+
+                const data = await response.json();
+                spinner.stop();
+
+                const messageObj = data.message;
+
+                if (messageObj.content) {
+                    if (this.config.useMarkedTerminal) {
+                        printMarkdown(messageObj.content);
+                    } else {
+                        process.stdout.write(chalk.cyan(messageObj.content));
+                    }
+                    finalResponse += messageObj.content;
+                }
+
+                this.messages.push(messageObj);
+
+                if (!messageObj.tool_calls || messageObj.tool_calls.length === 0) {
+                    console.log();
+                    break;
+                }
+
+                for (const call of messageObj.tool_calls) {
+                    const fn = call.function;
+                    console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
+
+                    let res = await executeTool(fn.name, fn.arguments);
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
+                    console.log(chalk.yellow(`[Tool Result Received]\n`));
+
+                    this.messages.push({
+                        role: 'tool',
+                        content: typeof res === 'string' ? res : JSON.stringify(res)
+                    });
+                }
+
+                spinner = ora({ text: 'Processing tool results...', color: 'yellow', stream: process.stdout }).start();
+            }
+
+            return finalResponse;
+        } catch (err) {
+            if (spinner.isSpinning) spinner.stop();
+            console.error(chalk.red(`Ollama Cloud Error: ${err.message}`));
+            return `Error: ${err.message}`;
+        }
+    }
+}

package/src/providers/openai.js

@@ -6,6 +6,7 @@ import os from 'os';
 import path from 'path';
 import fsSync from 'fs';
 import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
 
 export class OpenAIProvider {
     constructor(config) {
@@ -26,6 +27,13 @@ export class OpenAIProvider {
         }));
     }
 
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
     async sendMessage(message) {
         if (this.config.authType === 'oauth') {
             return await this.sendOauthMessage(message);
@@ -59,8 +67,10 @@ export class OpenAIProvider {
                     const delta = chunk.choices[0]?.delta;
 
                     if (delta?.content) {
-                        if (spinner.isSpinning) spinner.stop();
-                        process.stdout.write(chalk.cyan(delta.content));
+                        if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                        if (!this.config.useMarkedTerminal) {
+                            process.stdout.write(chalk.cyan(delta.content));
+                        }
                         chunkResponse += delta.content;
                         finalResponse += delta.content;
                     }
@@ -87,6 +97,7 @@ export class OpenAIProvider {
                 if (spinner.isSpinning) spinner.stop();
 
                 if (chunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(chunkResponse);
                     this.messages.push({ role: 'assistant', content: chunkResponse });
                 }
 
@@ -206,6 +217,18 @@ export class OpenAIProvider {
                 const backendInput = mapMessagesToBackend(this.messages);
                 const backendTools = mapToolsToBackend(this.tools);
 
+                const payload = {
+                    model: this.modelName || 'gpt-5.1-codex',
+                    instructions: this.systemPrompt,
+                    input: backendInput,
+                    tools: backendTools,
+                    store: false,
+                    stream: true,
+                    include: ["reasoning.encrypted_content"],
+                    reasoning: { effort: "medium", summary: "auto" },
+                    text: { verbosity: "medium" }
+                };
+
                 const response = await fetch('https://chatgpt.com/backend-api/codex/responses', {
                     method: 'POST',
                     headers: {
@@ -216,17 +239,7 @@ export class OpenAIProvider {
                         'originator': 'codex_cli_rs',
                         'Accept': 'text/event-stream'
                     },
-                    body: JSON.stringify({
-                        model: this.modelName || 'gpt-5.1-codex',
-                        instructions: this.systemPrompt,
-                        input: backendInput,
-                        tools: backendTools,
-                        store: false,
-                        stream: true,
-                        include: ["reasoning.encrypted_content"],
-                        reasoning: { effort: "medium", summary: "auto" },
-                        text: { verbosity: "medium" }
-                    })
+                    body: JSON.stringify(payload)
                 });
 
                 if (!response.ok) {
@@ -259,10 +272,17 @@ export class OpenAIProvider {
                                 try {
                                     const data = JSON.parse(currentDataBuffer);
                                     if (currentEvent === 'response.output_text.delta') {
-                                        if (spinner && spinner.isSpinning) spinner.stop();
-                                        process.stdout.write(chalk.cyan(data.delta));
+                                        if (spinner && spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                                        if (!this.config.useMarkedTerminal) {
+                                            process.stdout.write(chalk.cyan(data.delta));
+                                        }
                                         currentChunkResponse += data.delta;
                                         finalResponse += data.delta;
+                                    } else if (currentEvent === 'response.reasoning.delta' || currentEvent === 'response.reasoning_text.delta' || currentEvent.includes('reasoning.delta')) {
+                                        if (this.config.debug && data.delta) {
+                                            if (spinner && spinner.isSpinning) spinner.stop();
+                                            process.stdout.write(chalk.gray(data.delta));
+                                        }
                                     } else if (currentEvent === 'response.output_item.added' && data.item?.type === 'function_call') {
                                         if (spinner && spinner.isSpinning) spinner.stop();
                                         currentToolCall = {
@@ -276,7 +296,7 @@ export class OpenAIProvider {
                                         if (!spinner.isSpinning) {
                                             spinner = ora({ text: `Generating ${chalk.yellow(currentToolCall.name)} (${currentToolCall.arguments.length} bytes)...`, color: 'yellow', stream: process.stdout }).start();
                                         } else {
-                                            spinner.text = `Generating ${chalk.yellow(currentToolCall.name)} (${currentToolCall.arguments.length} bytes)...`;
+                                            spinner.text = `Generating ${chalk.yellow(currentToolCall.name)} arguments (${currentToolCall.arguments.length} bytes)...`;
                                         }
                                     } else if (currentEvent === 'response.output_item.done' && data.item?.type === 'function_call' && currentToolCall) {
                                         if (spinner && spinner.isSpinning) spinner.stop();
@@ -322,7 +342,6 @@ export class OpenAIProvider {
                                 currentChunkResponse += data.delta;
                                 finalResponse += data.delta;
                             }
-                            // Note: tool calls usually don't end exactly at stream end without \n\n
                         } catch (e) { }
                     }
                 }
@@ -330,6 +349,7 @@ export class OpenAIProvider {
                 if (spinner.isSpinning) spinner.stop();
 
                 if (currentChunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(currentChunkResponse);
                     this.messages.push({ role: 'assistant', content: currentChunkResponse });
                 }
 

package/src/tools/execCommand.js

@@ -29,12 +29,16 @@ export async function execCommand({ command, cwd = process.cwd() }) {
 
         child.on('close', (code) => {
             if (spinner.isSpinning) spinner.stop();
-            resolve(`Command exited with code ${code}.\nOutput:\n${output}`);
+            let result = `Command exited with code ${code}.\nOutput:\n${output}`;
+            if (code !== 0) {
+                result += `\n\n[System Note: The command failed with an error. Please analyze the output above and try to fix the issue if it is possible.]`;
+            }
+            resolve(result);
         });
 
         child.on('error', (err) => {
             if (spinner.isSpinning) spinner.stop();
-            resolve(`Error executing command: ${err.message}`);
+            resolve(`Error executing command: ${err.message}\n\n[System Note: The command failed to execute. Please analyze the error and try to fix the issue if it is possible.]`);
         });
     });
 }

package/src/utils/markdown.js

@@ -0,0 +1,21 @@
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import chalk from 'chalk';
+
+marked.use(markedTerminal({
+    // Prominent headings
+    firstHeading: chalk.magenta.bold.underline,
+    heading: chalk.magenta.bold,
+    
+    // Stronger emphasis for other elements
+    strong: chalk.yellow.bold,
+    em: chalk.italic,
+    codespan: chalk.bgRgb(40, 40, 40).yellow,
+    
+    // Custom tab/padding
+    tab: 4
+}));
+
+export function printMarkdown(text) {
+    process.stdout.write(marked.parse(text));
+}

package/src/utils/workspace.js

@@ -0,0 +1,30 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+export async function getWorkspaceTree() {
+    let ignores = ['node_modules/**', '.git/**'];
+    
+    try {
+        const gitignore = await fs.readFile(path.join(process.cwd(), '.gitignore'), 'utf8');
+        ignores = ignores.concat(gitignore.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')));
+    } catch (e) {}
+
+    try {
+        const bananacodeignore = await fs.readFile(path.join(process.cwd(), '.bananacodeignore'), 'utf8');
+        ignores = ignores.concat(bananacodeignore.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')));
+    } catch (e) {}
+
+    try {
+        const files = await glob('**/*', { 
+            cwd: process.cwd(),
+            ignore: ignores,
+            nodir: true,
+            dot: true
+        });
+        
+        return files.join('\n');
+    } catch (err) {
+        return `Error reading workspace: ${err.message}`;
+    }
+}