@banaxi/banana-code 1.5.1 → 1.7.0

package/README.md

@@ -62,12 +62,14 @@ While tools like Cursor provide great GUI experiences, Banana Code is built for
 
 ## 🚀 Installation
 
-Install Banana Code globally via npm:
+Install Banana Code globally via npm using the scoped package name:
 
 ```bash
 npm install -g @banaxi/banana-code
 ```
 
+> **⚠️ Important Notice:** Please ensure you install `@banaxi/banana-code`. The unscoped `banana-code` package on npm is NOT affiliated with this project.
+
 ## 🛠️ Setup
 
 On your first run, Banana Code will walk you through a quick setup to configure your preferred AI providers:
@@ -97,6 +99,8 @@ While in a chat, use these special commands:
 - `/model`: Switch the active AI model on the fly.
 - `/chats`: Open an interactive menu to view and resume past auto-titled chat sessions.
 - `/clean`: Compress your current chat history into a dense summary to save tokens.
+- `/memory`: Manage your global AI memories (facts the AI remembers across all projects).
+- `/init`: Analyze the current project and generate a `BANANA.md` summary for instant context.
 - `/context`: View your current message count and estimated token usage.
 - `/settings`: Toggle UI features like syntax highlighting and auto-workspace feeding.
 - `/plan` & `/agent`: Toggle between Plan & Execute mode and standard Agent mode.
@@ -155,6 +159,69 @@ Banana Code supports the open standard [Model Context Protocol](https://modelcon
 
 Restart Banana Code, and the AI will instantly know how to use these new tools natively!
 
+### 🧠 Global AI Memory
+Banana Code features a persistent "brain" that remembers your preferences across every project you work on.
+
+1. Enable **Enable Global AI Memory** in the `/settings` menu.
+2. Tell the AI facts about yourself or your coding style (e.g., "My name is Max" or "I prefer using Python for data scripts").
+3. Use the `/memory` command to view, manually add, or delete saved facts.
+4. The AI will now automatically adhere to these preferences in every future session!
+
+### 🍌 Project Initialization (`/init`)
+Stop repeating yourself! When you start working in a new folder, type `/init`. 
+
+Banana Code will analyze your entire project structure and generate a **`BANANA.md`** file. This file acts as a high-level architectural summary. Every time you start `banana` in that folder, the AI silently reads this file, giving it instant context about your project's goals and technologies from the very first message.
+
+## 📡 Headless API Mode (`--api`)
+Banana Code can be run as a background engine, exposing its powerful tool-calling and provider-switching logic via a local HTTP and WebSocket server. This allows you to build custom GUIs (Electron, Tauri, React) on top of the Banana Code engine without rewriting any AI logic.
+
+Start the server:
+```bash
+banana --api 4000
+```
+
+### HTTP Endpoints
+- `GET /api/status`: Returns engine status, active provider, and model.
+- `GET /api/sessions`: Returns a JSON array of all saved chat sessions.
+- `GET /api/config`: Returns the current `config.json` preferences.
+
+### WebSocket Streaming & Chat
+Connect a WebSocket client (like `wscat` or your GUI frontend) to `ws://localhost:4000`.
+
+**Send a chat message:**
+```json
+{ "type": "chat", "text": "Run the sensors command" }
+```
+
+**Streamed Response Format:**
+Banana Code streams data back to the client in real-time chunks:
+- `{"type": "chunk", "content": "The output of the command is..."}`
+- `{"type": "tool_start", "tool": "execute_command"}`
+- `{"type": "done", "finalResponse": "..."}`
+
+### Remote Tool Approval (Security)
+If the AI decides to run a shell command or patch a file, Banana Code pauses execution and sends a permission ticket to your GUI:
+
+```json
+{
+  "type": "permission_requested",
+  "ticketId": "5c9b2a...",
+  "action": "Execute Command",
+  "details": "sensors"
+}
+```
+
+Your GUI must present a dialog to the user and respond with the same `ticketId` to resume execution:
+```json
+{
+  "type": "permission_response",
+  "ticketId": "5c9b2a...",
+  "allowed": true,
+  "session": true
+}
+```
+If an invalid `ticketId` is provided, Banana Code automatically blocks the tool execution to ensure safety.
+
 ## 🔐 Privacy & Security
 
 Banana Code is built with transparency in mind:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.5.1",
+    "version": "1.7.0",
     "description": "🍌 BananaCode",
     "keywords": [
         "banana",
@@ -32,12 +32,15 @@
         "@modelcontextprotocol/sdk": "^1.28.0",
         "@openai/codex": "^0.117.0",
         "chalk": "^5.4.1",
+        "cors": "^2.8.6",
         "diff": "^8.0.4",
+        "express": "^5.2.1",
         "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"
+        "ora": "^8.1.1",
+        "ws": "^8.20.0"
     }
 }

package/src/config.js

@@ -186,6 +186,7 @@ async function runSetupWizard() {
     });
 
     const config = await setupProvider(provider);
+    config.useMemory = true;
 
     await saveConfig(config);
     console.log(chalk.yellow.bold("\nYou're all peeled and ready. Type your first message!\n"));

package/src/constants.js

@@ -24,10 +24,11 @@ export const OLLAMA_CLOUD_MODELS = [
     { 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: 'GLM-5.1 (Cloud)', value: 'glm-5.1: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' }
+    { name: 'Llama 3.1 405B (Cloud)', value: 'llama3.1:405b-cloud' },
+    { name: 'Gemma 4 31B (Cheapest, Very Good Code)', value: 'gemma4:31b-cloud' }
 ];
 
 export const MISTRAL_MODELS = [

package/src/index.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { loadConfig, saveConfig, setupProvider } from './config.js';
 import { runStartup } from './startup.js';
-import { getSessionPermissions } from './permissions.js';
+import { getSessionPermissions, setYoloMode } from './permissions.js';
 
 import { GeminiProvider } from './providers/gemini.js';
 import { ClaudeProvider } from './providers/claude.js';
@@ -16,6 +16,7 @@ import { loadSession, saveSession, generateSessionId, getLatestSessionId, listSe
 import { printMarkdown } from './utils/markdown.js';
 import { estimateConversationTokens } from './utils/tokens.js';
 import { mcpManager } from './utils/mcp.js';
+import { startApiServer } from './server.js';
 
 let config;
 let providerInstance;
@@ -311,17 +312,29 @@ async function handleSlashCommand(command) {
                         value: 'useMarkedTerminal',
                         checked: config.useMarkedTerminal || false
                     },
+                    {
+                        name: 'Enable Surgical File Patching (patch_file tool)',
+                        value: 'usePatchFile',
+                        checked: config.usePatchFile !== false
+                    },
                     {
                         name: 'Always show current token count in status bar',
                         value: 'showTokenCount',
                         checked: config.showTokenCount || false
+                    },
+                    {
+                        name: 'Enable Global AI Memory (Allows AI to save facts persistently)',
+                        value: 'useMemory',
+                        checked: config.useMemory !== false
                     }
                 ]
             });
             
             config.autoFeedWorkspace = enabledSettings.includes('autoFeedWorkspace');
             config.useMarkedTerminal = enabledSettings.includes('useMarkedTerminal');
+            config.usePatchFile = enabledSettings.includes('usePatchFile');
             config.showTokenCount = enabledSettings.includes('showTokenCount');
+            config.useMemory = enabledSettings.includes('useMemory');
             await saveConfig(config);
             if (providerInstance) {
                 const savedMessages = providerInstance.messages;
@@ -362,6 +375,8 @@ async function handleSlashCommand(command) {
             break;
         case '/plan':
             config.planMode = true;
+            config.askMode = false;
+            config.securityMode = false;
             await saveConfig(config);
             if (providerInstance) {
                 const savedMessages = providerInstance.messages;
@@ -372,8 +387,52 @@ async function handleSlashCommand(command) {
             }
             console.log(chalk.magenta(`Plan mode enabled. For significant changes, the AI will now propose an implementation plan before writing code.`));
             break;
+        case '/ask':
+            config.askMode = true;
+            config.planMode = false;
+            config.securityMode = false;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.blue(`Ask mode enabled. The AI will only answer questions and cannot edit files.`));
+            break;
+        case '/security':
+            config.securityMode = true;
+            config.askMode = false;
+            config.planMode = false;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.red(`Security mode enabled. The AI will look for and help fix vulnerabilities.`));
+            console.log(chalk.yellow(`Disclaimer: Please only use this mode for defensive purposes to secure your own code, and do not use the identified vulnerabilities maliciously.`));
+            break;
+        case '/yolo':
+            config.yolo = !config.yolo;
+            setYoloMode(config.yolo);
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(config.yolo ? chalk.bgRed.white.bold('\n ⚠️ YOLO MODE ENABLED - All permission requests will be auto-accepted! \n') : chalk.green('\nYOLO mode disabled.\n'));
+            break;
         case '/agent':
             config.planMode = false;
+            config.askMode = false;
+            config.securityMode = false;
             await saveConfig(config);
             if (providerInstance) {
                 const savedMessages = providerInstance.messages;
@@ -424,6 +483,91 @@ async function handleSlashCommand(command) {
                 }
             }
             break;
+        case '/memory':
+            if (config.useMemory === false) {
+                console.log(chalk.yellow("Global AI Memory is disabled. Enable it in /settings first."));
+                break;
+            }
+            const { select: memSelect, input: memInput } = await import('@inquirer/prompts');
+            const { loadMemory, removeMemory, addMemory } = await import('./utils/memory.js');
+            let memAction = await memSelect({
+                message: 'Manage Global AI Memory:',
+                choices: [
+                    { name: 'View all memories', value: 'view' },
+                    { name: 'Add a new memory manually', value: 'add' },
+                    { name: 'Delete a memory', value: 'delete' }
+                ],
+                loop: false
+            });
+
+            if (memAction === 'view') {
+                const mems = await loadMemory();
+                if (mems.length === 0) {
+                    console.log(chalk.yellow("No global memories saved yet."));
+                } else {
+                    console.log(chalk.cyan.bold("\nGlobal Memories:"));
+                    mems.forEach(m => {
+                        console.log(chalk.gray(`[${m.id}] `) + chalk.green(m.fact));
+                    });
+                }
+            } else if (memAction === 'add') {
+                const newFact = await memInput({
+                    message: 'Enter the fact you want the AI to remember globally:',
+                    validate: (v) => v.trim().length > 0 || 'Memory cannot be empty'
+                });
+                const id = await addMemory(newFact);
+                console.log(chalk.green(`Memory saved with ID: ${id}`));
+                providerInstance = createProvider(); // Reload provider to inject new memory
+            } else if (memAction === 'delete') {
+                const mems = await loadMemory();
+                if (mems.length === 0) {
+                    console.log(chalk.yellow("No memories to delete."));
+                } else {
+                    const idToDelete = await memSelect({
+                        message: 'Select a memory to delete:',
+                        choices: mems.map(m => ({ name: m.fact, value: m.id })),
+                        loop: false,
+                        pageSize: 10
+                    });
+                    const success = await removeMemory(idToDelete);
+                    if (success) {
+                        console.log(chalk.green(`Memory deleted.`));
+                        providerInstance = createProvider(); // Reload provider
+                    }
+                }
+            }
+            break;
+        case '/init':
+            console.log(chalk.cyan("Generating project summary for BANANA.md..."));
+            const initSpinner = ora({ text: 'Analyzing project...', color: 'yellow', stream: process.stdout }).start();
+            try {
+                const { getWorkspaceTree } = await import('./utils/workspace.js');
+                const tree = await getWorkspaceTree();
+                
+                const initProvider = createProvider();
+                // We use a completely blank slate for this so it doesn't get confused
+                initProvider.messages = []; 
+                
+                let initPrompt = "SYSTEM: You are a project summarizer. Review the following project file tree and briefly describe what this project is, what technologies it uses, and any obvious conventions. Keep it under 2 paragraphs. Output ONLY the summary text.";
+                initPrompt += `\n\n--- Project Tree ---\n${tree}`;
+                
+                const summary = await initProvider.sendMessage(initPrompt);
+                
+                const fs = await import('fs/promises');
+                const path = await import('path');
+                const bananaPath = path.join(process.cwd(), 'BANANA.md');
+                await fs.writeFile(bananaPath, summary, 'utf8');
+                
+                initSpinner.stop();
+                console.log(chalk.green(`Successfully created BANANA.md!`));
+                
+                // Re-init current provider so it picks up the new BANANA.md
+                providerInstance = createProvider();
+            } catch (err) {
+                initSpinner.stop();
+                console.log(chalk.red(`Failed to initialize project: ${err.message}`));
+            }
+            break;
         case '/help':
             console.log(chalk.yellow(`
 Available commands:
@@ -437,8 +581,11 @@ Available commands:
   /beta            - Manage beta features and tools
   /settings        - Manage app settings (workspace auto-feed, etc)
   /skills          - List loaded agent skills
+  /memory          - Manage global AI memories
+  /init            - Generate a BANANA.md project summary file
   /plan            - Enable Plan Mode (AI proposes a plan for big changes)
   /agent           - Enable Agent Mode (default, AI edits directly)
+  /yolo            - Toggle YOLO mode (skip all permission requests)
   /debug           - Toggle debug mode (show tool results)
   /help            - Show all commands
   /exit            - Quit Banana Code
@@ -567,7 +714,10 @@ function drawPromptBox(inputText, cursorPos) {
     // Redraw status bar and separator (they are always below the prompt)
     const modelDisplay = providerInstance ? providerInstance.modelName : (config.model || 'unknown');
     const providerDisplay = config.provider.toUpperCase();
-    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    let modeDisplay = chalk.green('AGENT MODE');
+    if (config.askMode) modeDisplay = chalk.blue('ASK MODE');
+    else if (config.securityMode) modeDisplay = chalk.red('SECURITY MODE');
+    else if (config.planMode) modeDisplay = chalk.magenta('PLAN MODE');
     
     let tokenDisplay = '';
     if (config.showTokenCount && providerInstance) {
@@ -585,7 +735,8 @@ function drawPromptBox(inputText, cursorPos) {
         tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
     }
     
-    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const yoloDisplay = config.yolo ? chalk.bgRed.white.bold(' ⚠️ YOLO ') : '';
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}${yoloDisplay ? ' / ' + yoloDisplay : ''}`;
     const rightText = '/help for shortcuts ';
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
     const midPad = Math.max(0, width - leftStripped.length - rightText.length);
@@ -628,7 +779,10 @@ function drawPromptBoxInitial(inputText) {
     // Status bar: Current Provider / Model + right-aligned "/help for shortcuts"
     const modelDisplay = providerInstance ? providerInstance.modelName : (config.model || 'unknown');
     const providerDisplay = config.provider.toUpperCase();
-    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    let modeDisplay = chalk.green('AGENT MODE');
+    if (config.askMode) modeDisplay = chalk.blue('ASK MODE');
+    else if (config.securityMode) modeDisplay = chalk.red('SECURITY MODE');
+    else if (config.planMode) modeDisplay = chalk.magenta('PLAN MODE');
     
     let tokenDisplay = '';
     if (config.showTokenCount && providerInstance) {
@@ -646,7 +800,8 @@ function drawPromptBoxInitial(inputText) {
         tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
     }
     
-    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const yoloDisplay = config.yolo ? chalk.bgRed.white.bold(' ⚠️ YOLO ') : '';
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}${yoloDisplay ? ' / ' + yoloDisplay : ''}`;
     const rightText = '/help for shortcuts ';
 
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
@@ -823,12 +978,35 @@ function promptUser() {
 async function main() {
     try {
         config = await loadConfig();
+
+        if (process.argv.includes('--yolo')) {
+            config.yolo = true;
+        }
+        setYoloMode(config.yolo);
+
         await runStartup();
 
         if (config.betaTools && config.betaTools.includes('mcp_support')) {
             await mcpManager.init();
         }
 
+        const apiIdx = process.argv.indexOf('--api');
+        if (apiIdx !== -1) {
+            const portStr = process.argv[apiIdx + 1];
+            const port = portStr && !portStr.startsWith('-') ? parseInt(portStr) : 3000;
+
+            let host = '127.0.0.1';
+            const hostIdx = process.argv.indexOf('--host');
+            if (hostIdx !== -1 && process.argv[hostIdx + 1] && !process.argv[hostIdx + 1].startsWith('-')) {
+                host = process.argv[hostIdx + 1];
+            } else if (process.argv.includes('--expose')) {
+                host = '0.0.0.0';
+            }
+
+            await startApiServer(port, createProvider, host);
+            return;
+        }
+
         const resumeIdx = process.argv.indexOf('--resume');
         if (resumeIdx !== -1) {
             let resumeId = process.argv[resumeIdx + 1];

package/src/permissions.js

@@ -1,8 +1,13 @@
 import { select } from '@inquirer/prompts';
 import chalk from 'chalk';
+import crypto from 'crypto';
 
 const sessionPermissions = new Set();
 
+export function setYoloMode(enabled) {
+    global.bananaYoloMode = !!enabled;
+}
+
 function wrapText(text, width) {
     const lines = [];
     for (let i = 0; i < text.length; i += width) {
@@ -12,12 +17,25 @@ function wrapText(text, width) {
 }
 
 export async function requestPermission(actionType, details) {
+    if (global.bananaYoloMode || process.argv.includes('--yolo')) {
+        return { allowed: true };
+    }
+
     const permKey = `allow_session_${actionType}`;
 
     if (sessionPermissions.has(permKey)) {
         return { allowed: true };
     }
 
+    if (typeof global.apiPermissionHandler === 'function') {
+        const ticketId = crypto.randomUUID();
+        const result = await global.apiPermissionHandler(ticketId, actionType, details);
+        if (result.remember) {
+            sessionPermissions.add(permKey);
+        }
+        return { allowed: result.allowed };
+    }
+
     const boxWidth = 41; // Internal width
 
     const actionLabel = ` Action: ${actionType}`;

package/src/prompt.js

@@ -1,4 +1,6 @@
 import os from 'os';
+import fs from 'fs';
+import path from 'path';
 import { getAvailableTools } from './tools/registry.js';
 import { getAvailableSkills } from './utils/skills.js';
 
@@ -29,6 +31,34 @@ SAFETY RULES:
 
 Always use tools when they would help. Be concise but thorough. `;
 
+    // Load Project Context (BANANA.md)
+    try {
+        const bananaPath = path.join(process.cwd(), 'BANANA.md');
+        if (fs.existsSync(bananaPath)) {
+            const projectContext = fs.readFileSync(bananaPath, 'utf8');
+            prompt += `\n\n# Project Context (BANANA.md)\nThe following is the summary of the current project. You already know this; DO NOT use tools to read BANANA.md manually:\n${projectContext}\n`;
+        }
+    } catch (e) {}
+
+    // Load Global Memory
+    if (config.useMemory !== false) {
+        prompt += `\n\n# Global AI Memory\nYou have the ability to remember facts across ALL sessions and projects using the \`save_memory\` tool. If the user tells you their name, personal preferences, coding rules, or other information they might want to persist, feel free to use the \`save_memory\` tool so you can remember it in the future.\n`;
+        
+        try {
+            const memPath = path.join(os.homedir(), '.config', 'banana-code', 'memory.json');
+            if (fs.existsSync(memPath)) {
+                const memData = fs.readFileSync(memPath, 'utf8');
+                const memories = JSON.parse(memData);
+                if (memories.length > 0) {
+                    prompt += `You have persistently saved the following facts and preferences across ALL projects. Always adhere to these preferences:\n`;
+                    for (const m of memories) {
+                        prompt += `- ${m.fact}\n`;
+                    }
+                }
+            }
+        } catch (e) {}
+    }
+
     if (skills && skills.length > 0) {
         prompt += `\n\n# Available Agent Skills\n\nYou have access to the following specialized skills. To activate a skill and receive its detailed instructions, call the \`activate_skill\` tool with the skill's name.\n\n<available_skills>\n`;
         for (const skill of skills) {
@@ -62,6 +92,26 @@ The user is operating in "Plan Mode".
 `;
     }
 
+    if (config.askMode) {
+        prompt += `
+[ASK MODE ENABLED]
+The user is operating in "Ask Mode".
+- You are strictly restricted to answering questions, explaining code, and providing information.
+- You MUST NOT make any changes to the codebase. Do NOT use tools that modify files or execute shell commands that change state (e.g. creating/deleting files, installing packages).
+- Use read-only tools like search_files, list_directory, read_file, and read-only execute_command (like running a test or git status) to gather information to answer the user's questions.
+`;
+    }
+
+    if (config.securityMode) {
+        prompt += `
+[SECURITY MODE ENABLED]
+The user is operating in "Security Mode".
+- Your primary objective is to find security vulnerabilities, misconfigurations, and bad practices in the codebase.
+- Act as a red-team auditor. Search for OWASP Top 10 vulnerabilities, leaked API keys, unsafe inputs, injection flaws, etc.
+- Provide detailed reports of any vulnerabilities found, including the file path, the affected lines, and suggestions for remediation.
+`;
+    }
+
     if (hasPatchTool) {
         prompt += `
 When editing existing files, PREFER using the 'patch_file' tool for surgical, targeted changes instead of 'write_file', especially for large files. This prevents accidental truncation and is much more efficient. Only use 'write_file' when creating new files or when making very extensive changes to a small file.`;

package/src/providers/claude.js

@@ -113,8 +113,14 @@ export class ClaudeProvider {
 
                 const toolResultContent = [];
                 for (const call of toolCalls) {
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(call.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.name}]`));
                     const res = await executeTool(call.name, call.input, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/providers/gemini.js

@@ -80,11 +80,16 @@ export class GeminiProvider {
                             if (content && content.parts) {
                                 for (const part of content.parts) {
                                     if (part.text) {
-                                        if (spinner && spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                                        if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
                                         if (!this.config.useMarkedTerminal) {
-                                            process.stdout.write(chalk.cyan(part.text));
+                                            if (this.config.isApiMode && this.onChunk) {
+                                                this.onChunk(part.text);
+                                            } else {
+                                                process.stdout.write(chalk.cyan(part.text));
+                                            }
                                         }
                                         responseText += part.text;
+
                                         currentTurnText += part.text;
 
                                         // Aggregate sequential text parts
@@ -134,8 +139,14 @@ export class GeminiProvider {
                     if (part.functionCall) {
                         hasToolCalls = true;
                         const call = part.functionCall;
+                        if (this.config.isApiMode && this.onToolStart) {
+                            this.onToolStart(call.name);
+                        }
                         console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.name}]`));
                         const res = await executeTool(call.name, call.args, this.config);
+                        if (this.config.isApiMode && this.onToolEnd) {
+                            this.onToolEnd(res);
+                        }
                         if (this.config.debug) {
                             console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                         }

package/src/providers/mistral.js

@@ -109,6 +109,9 @@ export class MistralProvider {
                 });
 
                 for (const call of toolCalls) {
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(call.function.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.function.name}]`));
                     let args = {};
                     try {
@@ -116,6 +119,9 @@ export class MistralProvider {
                     } catch (e) { }
 
                     const res = await executeTool(call.function.name, args, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/providers/ollama.js

@@ -75,9 +75,15 @@ export class OllamaProvider {
 
                 for (const call of messageObj.tool_calls) {
                     const fn = call.function;
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(fn.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
 
                     let res = await executeTool(fn.name, fn.arguments, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/providers/ollamaCloud.js

@@ -84,7 +84,11 @@ export class OllamaCloudProvider {
                                     const content = data.message.content;
                                     if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
                                     if (!this.config.useMarkedTerminal) {
-                                        process.stdout.write(chalk.cyan(content));
+                                        if (this.config.isApiMode && this.onChunk) {
+                                            this.onChunk(content);
+                                        } else {
+                                            process.stdout.write(chalk.cyan(content));
+                                        }
                                     }
                                     currentChunkResponse += content;
                                     finalResponse += content;
@@ -130,9 +134,15 @@ export class OllamaCloudProvider {
 
                 for (const call of lastMessageObj.tool_calls) {
                     const fn = call.function;
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(fn.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
 
                     let res = await executeTool(fn.name, fn.arguments, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/providers/openai.js

@@ -74,7 +74,11 @@ export class OpenAIProvider {
                     if (delta?.content) {
                         if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
                         if (!this.config.useMarkedTerminal) {
-                            process.stdout.write(chalk.cyan(delta.content));
+                            if (this.config.isApiMode && this.onChunk) {
+                                this.onChunk(delta.content);
+                            } else {
+                                process.stdout.write(chalk.cyan(delta.content));
+                            }
                         }
                         chunkResponse += delta.content;
                         finalResponse += delta.content;
@@ -119,7 +123,10 @@ export class OpenAIProvider {
                     content: chunkResponse || null
                 });
 
-                for (const call of toolCalls) {
+                for (const call of activeToolCalls || toolCalls) {
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(call.function.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.function.name}]`));
                     let args = {};
                     try {
@@ -127,6 +134,9 @@ export class OpenAIProvider {
                     } catch (e) { }
 
                     const res = await executeTool(call.function.name, args, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }
@@ -370,6 +380,9 @@ export class OpenAIProvider {
                 });
 
                 for (const call of activeToolCalls) {
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(call.function.name);
+                    }
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.function.name}]`));
                     let args = {};
                     try {
@@ -377,6 +390,9 @@ export class OpenAIProvider {
                     } catch (e) { }
 
                     const res = await executeTool(call.function.name, args, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/server.js

@@ -0,0 +1,147 @@
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import cors from 'cors';
+import http from 'http';
+import chalk from 'chalk';
+import { loadConfig } from './config.js';
+import { listSessions, loadSession } from './sessions.js';
+
+export async function startApiServer(port = 3000, createProvider, host = '127.0.0.1') {
+    const app = express();
+    const server = http.createServer(app);
+    const wss = new WebSocketServer({ server });
+
+    app.use(cors());
+    app.use(express.json());
+
+    let config = await loadConfig();
+    let providerInstance = null;
+
+    // WebSocket connection handling
+    wss.on('connection', (ws) => {
+        console.log(chalk.cyan(`[API] GUI Client connected via WebSocket`));
+
+        const activeTickets = new Set();
+
+        // Setup global permission handler for API mode
+        global.apiPermissionHandler = (ticketId, actionType, details) => {
+            return new Promise((resolve) => {
+                const requestPayload = JSON.stringify({
+                    type: 'permission_requested',
+                    ticketId,
+                    action: actionType,
+                    details
+                });
+                
+                if (ws.readyState === ws.OPEN) {
+                    activeTickets.add(ticketId);
+                    ws.send(requestPayload);
+                    console.log(chalk.gray(`[API] Sent permission request: ${ticketId}`));
+                } else {
+                    console.log(chalk.red(`[API] WebSocket closed, denying permission automatically.`));
+                    resolve({ allowed: false });
+                    return;
+                }
+
+                // Temporary listener to catch the GUI's response for this specific ticket
+                const responseHandler = (message) => {
+                    try {
+                        const data = JSON.parse(message);
+                        if (data.type === 'permission_response' && data.ticketId === ticketId) {
+                            console.log(chalk.gray(`[API] Received permission response for ${ticketId}: ${data.allowed}`));
+                            activeTickets.delete(ticketId);
+                            ws.removeListener('message', responseHandler); // clean up
+                            resolve({ allowed: data.allowed, remember: data.session });
+                        }
+                    } catch (e) {}
+                };
+                
+                ws.on('message', responseHandler);
+            });
+        };
+
+        ws.on('message', async (message) => {
+            console.log(chalk.gray(`[API] Received message: ${message}`));
+            try {
+                const data = JSON.parse(message);
+                
+                // Ignore valid permission responses here, they are handled by the specific ticket listeners
+                if (data.type === 'permission_response') {
+                    if (!activeTickets.has(data.ticketId)) {
+                        console.log(chalk.red(`[API] Invalid ticket ID received: ${data.ticketId}`));
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send(JSON.stringify({ 
+                                type: 'error', 
+                                message: `Permission Denied: Ticket ID '${data.ticketId}' does not match any active requests.` 
+                            }));
+                        }
+                    }
+                    return;
+                }
+                
+                if (data.type === 'chat') {
+                    if (!providerInstance) {
+                        console.log(chalk.gray(`[API] Creating provider instance...`));
+                        providerInstance = createProvider(config);
+                    }
+
+                    // Attach a temporary listener for this specific request
+                    // We modify the provider config locally for this mode
+                    providerInstance.config.isApiMode = true;
+                    providerInstance.onChunk = (chunk) => {
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send(JSON.stringify({ type: 'chunk', content: chunk }));
+                        }
+                    };
+                    providerInstance.onToolStart = (tool) => {
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send(JSON.stringify({ type: 'tool_start', tool }));
+                        }
+                    };
+                    providerInstance.onToolEnd = (result) => {
+                        if (ws.readyState === ws.OPEN) {
+                            ws.send(JSON.stringify({ type: 'tool_end', result }));
+                        }
+                    };
+
+                    console.log(chalk.gray(`[API] Sending message to AI...`));
+                    const response = await providerInstance.sendMessage(data.text);
+                    console.log(chalk.gray(`[API] AI response complete.`));
+                    
+                    if (ws.readyState === ws.OPEN) {
+                        ws.send(JSON.stringify({ type: 'done', finalResponse: response }));
+                    }
+                }
+            } catch (err) {
+                console.error(chalk.red(`[API] Error: ${err.message}`));
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(JSON.stringify({ type: 'error', message: err.message }));
+                }
+            }
+        });
+
+        ws.on('close', () => {
+            console.log(chalk.gray(`[API] GUI Client disconnected`));
+        });
+
+    });
+
+    // HTTP Endpoints
+    app.get('/api/sessions', async (req, res) => {
+        const sessions = await listSessions();
+        res.json(sessions);
+    });
+
+    app.get('/api/config', (req, res) => {
+        res.json(config);
+    });
+
+    app.get('/api/status', (req, res) => {
+        res.json({ status: 'running', provider: config.provider, model: config.model });
+    });
+
+    server.listen(port, host, () => {
+        console.log(chalk.green.bold(`\n🍌 Banana Code API Server running at http://${host}:${port}`));
+        console.log(chalk.gray(`WebSocket streaming enabled on the same port.\n`));
+    });
+}

package/src/tools/memoryTools.js

@@ -0,0 +1,46 @@
+import { addMemory, removeMemory, loadMemory } from '../utils/memory.js';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function saveMemoryTool({ fact }) {
+    const spinner = ora({ text: `Saving memory...`, color: 'magenta', stream: process.stdout }).start();
+    try {
+        const id = await addMemory(fact);
+        spinner.stop();
+        return `Successfully saved fact. ID: ${id}`;
+    } catch (err) {
+        spinner.stop();
+        return `Error saving memory: ${err.message}`;
+    }
+}
+
+export async function listMemoryTool() {
+    const spinner = ora({ text: `Reading memories...`, color: 'magenta', stream: process.stdout }).start();
+    try {
+        const memories = await loadMemory();
+        spinner.stop();
+        if (memories.length === 0) {
+            return `No memories currently saved.`;
+        }
+        return JSON.stringify(memories, null, 2);
+    } catch (err) {
+        spinner.stop();
+        return `Error listing memories: ${err.message}`;
+    }
+}
+
+export async function deleteMemoryTool({ id }) {
+    const spinner = ora({ text: `Deleting memory ${id}...`, color: 'magenta', stream: process.stdout }).start();
+    try {
+        const success = await removeMemory(id);
+        spinner.stop();
+        if (success) {
+            return `Successfully deleted memory with ID: ${id}`;
+        } else {
+            return `Error: Memory with ID '${id}' not found.`;
+        }
+    } catch (err) {
+        spinner.stop();
+        return `Error deleting memory: ${err.message}`;
+    }
+}

package/src/tools/readManyFiles.js

@@ -0,0 +1,32 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { requestPermission } from '../permissions.js';
+
+export async function readManyFiles({ filepaths }) {
+    if (!Array.isArray(filepaths)) {
+        return 'Error: filepaths must be an array of strings.';
+    }
+
+    let results = [];
+    
+    // Request permission for all files. You could ask for them individually or batch them.
+    // Here we'll request them individually but sequentially.
+    for (const filepath of filepaths) {
+        const absPath = path.resolve(process.cwd(), filepath);
+        const perm = await requestPermission('Read File', filepath);
+        
+        if (!perm.allowed) {
+            results.push(`--- File: ${filepath} ---\nUser denied permission to read: ${filepath}\n`);
+            continue;
+        }
+
+        try {
+            const content = await fs.readFile(absPath, 'utf8');
+            results.push(`--- File: ${filepath} ---\n${content}\n`);
+        } catch (err) {
+            results.push(`--- File: ${filepath} ---\nError reading file: ${err.message}\n`);
+        }
+    }
+
+    return results.join('\n');
+}

package/src/tools/registry.js

@@ -1,5 +1,6 @@
 import { execCommand } from './execCommand.js';
 import { readFile } from './readFile.js';
+import { readManyFiles } from './readManyFiles.js';
 import { writeFile } from './writeFile.js';
 import { fetchUrl } from './fetchUrl.js';
 import { searchFiles } from './searchFiles.js';
@@ -10,6 +11,7 @@ import { patchFile } from './patchFile.js';
 import { activateSkill } from './activateSkill.js';
 import { delegateTask } from './delegateTask.js';
 import { mcpManager } from '../utils/mcp.js';
+import { saveMemoryTool, listMemoryTool, deleteMemoryTool } from './memoryTools.js';
 
 export const TOOLS = [
     {
@@ -35,6 +37,21 @@ export const TOOLS = [
             required: ['filepath']
         }
     },
+    {
+        name: 'read_many_files',
+        description: 'Read the contents of multiple files at once.',
+        parameters: {
+            type: 'object',
+            properties: {
+                filepaths: {
+                    type: 'array',
+                    description: 'List of file paths to read',
+                    items: { type: 'string' }
+                }
+            },
+            required: ['filepaths']
+        }
+    },
     {
         name: 'write_file',
         description: 'Write content to a file. Overwrites existing content.',
@@ -109,9 +126,9 @@ export const TOOLS = [
     },
     {
         name: 'patch_file',
-        label: 'Surgical File Patch (Beta)',
+        label: 'Surgical File Patch',
         description: 'Edit a file by replacing specific sections of text. Much more efficient for large files.',
-        beta: true,
+        settingsFeature: 'usePatchFile',
         parameters: {
             type: 'object',
             properties: {
@@ -170,14 +187,59 @@ export const TOOLS = [
             },
             required: ['task']
         }
+    },
+    {
+        name: 'save_memory',
+        description: 'Persists a fact across ALL future sessions globally. Use this ONLY to save facts or preferences you want to permanently remember across different projects. Do NOT use for session-specific or temporary data.',
+        memoryFeature: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                fact: { type: 'string', description: 'A concise fact or preference to remember globally.' }
+            },
+            required: ['fact']
+        }
+    },
+    {
+        name: 'list_memory',
+        description: 'Retrieves all globally saved memories with their IDs. Use this to review facts you have saved or find an ID to delete an outdated fact.',
+        memoryFeature: true,
+        parameters: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'delete_memory',
+        description: 'Deletes a specific global memory using its ID. Call list_memory first to find the ID.',
+        memoryFeature: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'The exact ID of the memory to delete.' }
+            },
+            required: ['id']
+        }
     }
 ];
 
 export function getAvailableTools(config = {}) {
     let available = TOOLS.filter(tool => {
+        if (config.askMode) {
+            const forbiddenInAskMode = ['write_file', 'patch_file'];
+            if (forbiddenInAskMode.includes(tool.name)) return false;
+        }
         if (tool.beta) {
             return config.betaTools && config.betaTools.includes(tool.name);
         }
+        if (tool.memoryFeature) {
+            return config.useMemory !== false;
+        }
+        if (tool.settingsFeature) {
+            // Default to true if not explicitly set to false
+            return config[tool.settingsFeature] !== false;
+        }
         return true;
     });
 
@@ -232,6 +294,7 @@ export async function executeTool(name, args, config) {
     switch (name) {
         case 'execute_command': return await execCommand(args);
         case 'read_file': return await readFile(args);
+        case 'read_many_files': return await readManyFiles(args);
         case 'write_file': return await writeFile(args);
         case 'fetch_url': return await fetchUrl(args);
         case 'search_files': return await searchFiles(args);
@@ -241,6 +304,9 @@ export async function executeTool(name, args, config) {
         case 'patch_file': return await patchFile(args);
         case 'activate_skill': return await activateSkill(args);
         case 'delegate_task': return await delegateTask(args, config);
+        case 'save_memory': return await saveMemoryTool(args);
+        case 'list_memory': return await listMemoryTool(args);
+        case 'delete_memory': return await deleteMemoryTool(args);
         default: return `Unknown tool: ${name}`;
     }
 }

package/src/utils/memory.js

@@ -0,0 +1,52 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+const MEMORY_DIR = path.join(os.homedir(), '.config', 'banana-code');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');
+
+export async function loadMemory() {
+    try {
+        const data = await fs.readFile(MEMORY_FILE, 'utf-8');
+        return JSON.parse(data);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return []; // Return empty array if file doesn't exist
+        }
+        throw error;
+    }
+}
+
+export async function saveMemory(memories) {
+    try {
+        await fs.mkdir(MEMORY_DIR, { recursive: true });
+        await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2), 'utf-8');
+    } catch (error) {
+        console.error("Failed to save memory:", error);
+    }
+}
+
+export async function addMemory(fact) {
+    const memories = await loadMemory();
+    const newMemory = {
+        id: crypto.randomUUID().slice(0, 8),
+        fact,
+        createdAt: new Date().toISOString()
+    };
+    memories.push(newMemory);
+    await saveMemory(memories);
+    return newMemory.id;
+}
+
+export async function removeMemory(id) {
+    const memories = await loadMemory();
+    const initialLength = memories.length;
+    const filtered = memories.filter(m => m.id !== id);
+    
+    if (filtered.length < initialLength) {
+        await saveMemory(filtered);
+        return true;
+    }
+    return false;
+}