@banaxi/banana-code 1.5.1 → 1.6.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.6.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/index.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;
@@ -424,6 +437,91 @@ async function handleSlashCommand(command) {
                 }
             }
             break;
+        case '/memory':
+            if (!config.useMemory) {
+                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,6 +535,8 @@ 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)
   /debug           - Toggle debug mode (show tool results)
@@ -829,6 +929,14 @@ async function main() {
             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;
+            await startApiServer(port, createProvider);
+            return;
+        }
+
         const resumeIdx = process.argv.indexOf('--resume');
         if (resumeIdx !== -1) {
             let resumeId = process.argv[resumeIdx + 1];

package/src/permissions.js

@@ -1,5 +1,6 @@
 import { select } from '@inquirer/prompts';
 import chalk from 'chalk';
+import crypto from 'crypto';
 
 const sessionPermissions = new Set();
 
@@ -18,6 +19,15 @@ export async function requestPermission(actionType, details) {
         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) {
+        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) {

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) {
+    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, () => {
+        console.log(chalk.green.bold(`\n🍌 Banana Code API Server running at http://localhost:${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/registry.js

@@ -10,6 +10,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 = [
     {
@@ -109,9 +110,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,6 +171,40 @@ 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']
+        }
     }
 ];
 
@@ -178,6 +213,13 @@ export function getAvailableTools(config = {}) {
         if (tool.beta) {
             return config.betaTools && config.betaTools.includes(tool.name);
         }
+        if (tool.memoryFeature) {
+            return config.useMemory === true;
+        }
+        if (tool.settingsFeature) {
+            // Default to true if not explicitly set to false
+            return config[tool.settingsFeature] !== false;
+        }
         return true;
     });
 
@@ -241,6 +283,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;
+}