@banaxi/banana-code 1.0.5 → 1.2.0

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/activateSkill.js

@@ -0,0 +1,22 @@
+import { getAvailableSkills } from '../utils/skills.js';
+
+export async function activateSkill({ skillName }) {
+    const skills = getAvailableSkills();
+    // Match by ID or Name
+    const skill = skills.find(s => s.id === skillName || s.name === skillName);
+    
+    if (!skill) {
+        return `Error: Skill '${skillName}' not found. Available skills: ${skills.map(s => s.name).join(', ')}`;
+    }
+    
+    // The format expected by the AI agent
+    let output = `<activated_skill>\n`;
+    output += `<instructions>\n${skill.instructions}\n</instructions>\n`;
+    output += `<available_resources>\n`;
+    output += `- location: ${skill.path}\n`;
+    output += `  (Use list_directory and read_file to access bundled scripts, references, or assets)\n`;
+    output += `</available_resources>\n`;
+    output += `</activated_skill>`;
+    
+    return output;
+}

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/tools/registry.js

@@ -7,6 +7,7 @@ import { listDirectory } from './listDirectory.js';
 import { duckDuckGo } from './duckDuckGo.js';
 import { duckDuckGoScrape } from './duckDuckGoScrape.js';
 import { patchFile } from './patchFile.js';
+import { activateSkill } from './activateSkill.js';
 
 export const TOOLS = [
     {
@@ -133,6 +134,17 @@ export const TOOLS = [
             },
             required: ['filepath', 'edits']
         }
+    },
+    {
+        name: 'activate_skill',
+        description: 'Activates a specialized agent skill by name. Returns the skill\'s instructions wrapped in <activated_skill> tags. These provide specialized guidance for the current task.',
+        parameters: {
+            type: 'object',
+            properties: {
+                skillName: { type: 'string', description: 'The name or ID of the skill to activate.' }
+            },
+            required: ['skillName']
+        }
     }
 ];
 
@@ -156,6 +168,7 @@ export async function executeTool(name, args) {
         case 'duck_duck_go': return await duckDuckGo(args);
         case 'duck_duck_go_scrape': return await duckDuckGoScrape(args);
         case 'patch_file': return await patchFile(args);
+        case 'activate_skill': return await activateSkill(args);
         default: return `Unknown tool: ${name}`;
     }
 }

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/skills.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const SKILLS_DIR = path.join(os.homedir(), '.config', 'banana-code', 'skills');
+
+/**
+ * Scans the skills directory and parses SKILL.md files.
+ * @returns {Array} List of discovered skills.
+ */
+export function getAvailableSkills() {
+    try {
+        if (!fs.existsSync(SKILLS_DIR)) {
+            fs.mkdirSync(SKILLS_DIR, { recursive: true });
+        }
+    } catch (e) {
+        return [];
+    }
+
+    let skills = [];
+    try {
+        const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(SKILLS_DIR, entry.name);
+                const mdPath = path.join(skillPath, 'SKILL.md');
+                
+                if (fs.existsSync(mdPath)) {
+                    try {
+                        const content = fs.readFileSync(mdPath, 'utf8');
+                        // Match YAML frontmatter between --- and ---
+                        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+                        
+                        if (match) {
+                            const frontmatter = match[1];
+                            const body = content.slice(match[0].length).trim();
+                            
+                            // Simple YAML parsing via regex
+                            const nameMatch = frontmatter.match(/name:\s*['"]?([^'"\n]+)['"]?/);
+                            const descMatch = frontmatter.match(/description:\s*['"]?([^'"\n]+)['"]?/);
+                            
+                            if (nameMatch && descMatch) {
+                                skills.push({
+                                    id: entry.name,
+                                    name: nameMatch[1].trim(),
+                                    description: descMatch[1].trim(),
+                                    instructions: body,
+                                    path: skillPath
+                                });
+                            }
+                        }
+                    } catch (err) {
+                        // Skip corrupted or unreadable skills
+                    }
+                }
+            }
+        }
+    } catch (e) {}
+    
+    return skills;
+}

package/src/utils/tokens.js

@@ -0,0 +1,44 @@
+/**
+ * Estimates the number of tokens in a given string.
+ * This is a rough approximation (1 token ≈ 4 characters or ~0.75 words) 
+ * used to provide a quick estimate without needing heavy, provider-specific tokenizer libraries.
+ * 
+ * @param {string} text - The input text to estimate tokens for.
+ * @returns {number} The estimated token count.
+ */
+export function estimateTokens(text) {
+    if (!text || typeof text !== 'string') return 0;
+    
+    // A common heuristic: 1 token is roughly 4 English characters.
+    // For code, it can be denser, but this provides a reasonable ballpark.
+    return Math.ceil(text.length / 4);
+}
+
+/**
+ * Calculates the estimated token count for the entire conversation history.
+ * 
+ * @param {Array} messages - The array of message objects.
+ * @returns {number} The estimated total tokens.
+ */
+export function estimateConversationTokens(messages) {
+    if (!Array.isArray(messages)) return 0;
+    
+    let totalString = '';
+    
+    // Stringify the entire message array to get a representation of its "weight"
+    // This includes system prompts, tool calls, and results.
+    try {
+        totalString = JSON.stringify(messages);
+    } catch (e) {
+        // Fallback if there are circular references (unlikely in simple message arrays)
+        messages.forEach(msg => {
+            if (typeof msg === 'string') totalString += msg;
+            else if (msg && typeof msg === 'object') {
+                if (msg.content) totalString += typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                if (msg.parts) totalString += JSON.stringify(msg.parts);
+            }
+        });
+    }
+
+    return estimateTokens(totalString);
+}

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}`;
+    }
+}