banana-code 1.2.0

package/lib/subAgentManager.js

@@ -0,0 +1,406 @@
+/**
+ * Sub-Agent Manager for Banana Code
+ * Orchestrates sub-agent lifecycle: spawn, track, cancel.
+ * Any model on any provider can spawn sub-agents on any other provider/model.
+ */
+
+const { AgenticRunner, TOOLS, READ_ONLY_TOOLS } = require('./agenticRunner');
+const crypto = require('crypto');
+
+const MAX_DEPTH = 2;
+const DEFAULT_MAX_ITERATIONS_SUBAGENT = 25;
+const DEFAULT_TIMEOUT_CLOUD_MS = 120_000;
+const DEFAULT_TIMEOUT_LOCAL_MS = 300_000;
+const DEFAULT_MAX_TOKENS_SUBAGENT = 16384;
+const MAX_CONCURRENT_CLOUD = 5;
+
+const SUB_AGENT_DIRECTIVE = [
+  'You are a sub-agent spawned to perform a specific task. Focus exclusively on the task.',
+  'You have full tool access. Complete the task and report findings concisely.',
+  'Do not ask follow-up questions. Do not suggest next steps. Just do the work and report.'
+].join('\n');
+
+class SubAgentManager {
+  constructor(options = {}) {
+    this.providerManager = options.providerManager;
+    this.modelRegistry = options.modelRegistry;
+    this.promptManager = options.promptManager;
+    this.config = options.config;
+    this.projectDir = options.projectDir || process.cwd();
+
+    // Callbacks
+    this.onAgentStart = options.onAgentStart || (() => {});
+    this.onAgentToolCall = options.onAgentToolCall || (() => {});
+    this.onAgentToolResult = options.onAgentToolResult || (() => {});
+    this.onAgentComplete = options.onAgentComplete || (() => {});
+    this.onAgentError = options.onAgentError || (() => {});
+
+    // Active agents map: id -> SubAgent record
+    this.agents = new Map();
+  }
+
+  /**
+   * Spawn a sub-agent on a given model/provider.
+   *
+   * @param {string} modelKey - "provider:alias" format, e.g. "anthropic:claude-sonnet-4.6", "local:current"
+   * @param {string} task - Task description
+   * @param {Object} options
+   * @param {string} options.context - Optional context string
+   * @param {string[]} options.files - File paths to pre-read and inject
+   * @param {boolean} options.readOnly - Restrict to read-only tools
+   * @param {number} options.maxIterations - Default 25
+   * @param {number} options.timeout - Timeout in ms
+   * @param {number} options.depth - Recursion depth (0 = main, 1 = first sub-agent)
+   * @param {AbortSignal} options.signal - Parent abort signal
+   * @returns {Object} - { id, result, error, tokens, toolCalls, elapsed }
+   */
+  async spawn(modelKey, task, options = {}) {
+    const depth = options.depth || 1;
+
+    // Resolve model - fall back to current model if requested model not found
+    let resolved = this.modelRegistry.resolveModelKey(modelKey);
+    if (!resolved) {
+      resolved = this.modelRegistry.getCurrentModel();
+      if (!resolved) {
+        return {
+          error: `Could not resolve model "${modelKey}" and no current model available. Use /agent models to see available models.`,
+          tokens: 0,
+          toolCalls: 0
+        };
+      }
+    }
+
+    const id = crypto.randomBytes(4).toString('hex');
+    const isLocal = (resolved.provider || 'local') === 'local';
+    const timeout = options.timeout || (isLocal ? DEFAULT_TIMEOUT_LOCAL_MS : DEFAULT_TIMEOUT_CLOUD_MS);
+    const maxIterations = options.maxIterations || DEFAULT_MAX_ITERATIONS_SUBAGENT;
+
+    const agent = {
+      id,
+      model: resolved.key,
+      provider: resolved.provider || 'local',
+      providerModelId: resolved.providerModelId || resolved.id,
+      task,
+      status: 'running',
+      result: null,
+      error: null,
+      startedAt: Date.now(),
+      completedAt: null,
+      toolCalls: [],
+      tokens: { prompt: 0, completion: 0, total: 0 },
+      depth,
+      parentId: options.parentId || null
+    };
+
+    this.agents.set(id, agent);
+    this.onAgentStart(agent);
+
+    try {
+      // Get provider client for this model
+      const client = await this.providerManager.getClientForModel(resolved);
+
+      // Build system prompt
+      const basePrompt = this._buildSystemPrompt(resolved);
+      const systemContent = this._assembleSystemPrompt(basePrompt, task, options, resolved);
+
+      // Build messages
+      const messages = [
+        { role: 'system', content: systemContent }
+      ];
+
+      // Pre-read files if requested
+      if (options.files && options.files.length > 0) {
+        const fileContents = this._readFiles(options.files);
+        if (fileContents) {
+          messages.push({ role: 'user', content: `Here are the relevant files:\n\n${fileContents}` });
+        }
+      }
+
+      // Main task message
+      messages.push({ role: 'user', content: task });
+
+      // Create runner
+      const runner = new AgenticRunner(client, {
+        onToolCall: (tool, args) => {
+          agent.toolCalls.push({ tool, args, timestamp: Date.now() });
+          this.onAgentToolCall(agent, tool, args);
+        },
+        onToolResult: (tool, success, result) => {
+          this.onAgentToolResult(agent, tool, success, result);
+        },
+        onToken: () => {},       // sub-agents don't stream to terminal
+        onContent: () => {},
+        onReasoning: () => {},
+        onWarning: () => {},
+        onIntermediateContent: () => {}
+      });
+
+      // Set up abort with timeout
+      const abortController = new AbortController();
+      agent.abortController = abortController;
+      const timeoutId = setTimeout(() => abortController.abort(), timeout);
+
+      // Forward parent signal
+      if (options.signal) {
+        if (options.signal.aborted) {
+          abortController.abort();
+        } else {
+          options.signal.addEventListener('abort', () => abortController.abort(), { once: true });
+        }
+      }
+
+      // Build tool list and custom executors
+      const baseTools = options.readOnly ? READ_ONLY_TOOLS : TOOLS;
+      let customTools = [];
+      let customToolExecutors = new Map();
+      if (depth < MAX_DEPTH) {
+        customTools = [SPAWN_AGENT_TOOL_DEF];
+        customToolExecutors.set('spawn_agent', async (args, opts) => {
+          return await this.spawn(args.model, args.task, {
+            context: args.context,
+            readOnly: args.read_only,
+            depth: depth + 1,
+            parentId: id,
+            signal: opts.signal
+          });
+        });
+      }
+
+      try {
+        const result = await runner.run(messages, this.projectDir, {
+          model: resolved.providerModelId || resolved.id,
+          temperature: resolved.inferenceSettings?.temperature ?? 0.5,
+          topP: resolved.inferenceSettings?.topP,
+          reasoningEffort: resolved.reasoningEffort,
+          maxTokens: DEFAULT_MAX_TOKENS_SUBAGENT,
+          tools: [...baseTools, ...customTools],
+          readOnly: options.readOnly || false,
+          signal: abortController.signal,
+          customToolExecutors,
+          customTools
+        });
+
+        clearTimeout(timeoutId);
+
+        agent.status = 'completed';
+        agent.result = result;
+        agent.completedAt = Date.now();
+        agent.tokens = {
+          prompt: runner.totalPromptTokens,
+          completion: runner.totalCompletionTokens,
+          total: runner.totalTokens
+        };
+
+        this.onAgentComplete(agent);
+
+        return {
+          id,
+          result: result || '(No response from sub-agent)',
+          tokens: agent.tokens.total,
+          toolCalls: agent.toolCalls.length,
+          elapsed: agent.completedAt - agent.startedAt,
+          model: resolved.key,
+          provider: resolved.provider
+        };
+
+      } catch (err) {
+        clearTimeout(timeoutId);
+        throw err;
+      }
+
+    } catch (err) {
+      agent.status = 'failed';
+      agent.error = err.message || String(err);
+      agent.completedAt = Date.now();
+      this.onAgentError(agent, err);
+
+      return {
+        id,
+        error: `Sub-agent failed: ${agent.error}`,
+        tokens: agent.tokens?.total || 0,
+        toolCalls: agent.toolCalls?.length || 0,
+        elapsed: (agent.completedAt || Date.now()) - agent.startedAt,
+        model: modelKey,
+        provider: agent.provider
+      };
+    }
+  }
+
+  /**
+   * Spawn multiple agents. Cloud agents run concurrently (up to MAX_CONCURRENT_CLOUD),
+   * local agents run sequentially.
+   */
+  async spawnParallel(specs, options = {}) {
+    const cloudSpecs = [];
+    const localSpecs = [];
+
+    for (const spec of specs) {
+      const resolved = this.modelRegistry.resolveModelKey(spec.model);
+      if (resolved && (resolved.provider || 'local') === 'local') {
+        localSpecs.push(spec);
+      } else {
+        cloudSpecs.push(spec);
+      }
+    }
+
+    const results = [];
+
+    // Cloud agents: run concurrently in batches
+    if (cloudSpecs.length > 0) {
+      for (let i = 0; i < cloudSpecs.length; i += MAX_CONCURRENT_CLOUD) {
+        const batch = cloudSpecs.slice(i, i + MAX_CONCURRENT_CLOUD);
+        const batchResults = await Promise.all(
+          batch.map(spec => this.spawn(spec.model, spec.task, {
+            ...options,
+            context: spec.context,
+            readOnly: spec.read_only,
+            files: spec.files
+          }))
+        );
+        results.push(...batchResults);
+      }
+    }
+
+    // Local agents: sequential
+    for (const spec of localSpecs) {
+      const result = await this.spawn(spec.model, spec.task, {
+        ...options,
+        context: spec.context,
+        readOnly: spec.read_only,
+        files: spec.files
+      });
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get a specific agent record.
+   */
+  getAgent(id) {
+    return this.agents.get(id) || null;
+  }
+
+  /**
+   * List all agents in this session.
+   */
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+
+  /**
+   * Cancel a running agent (best-effort via AbortController).
+   */
+  cancel(id) {
+    const agent = this.agents.get(id);
+    if (!agent || agent.status !== 'running') return false;
+    agent.status = 'cancelled';
+    agent.completedAt = Date.now();
+    // Signal the abort controller to actually stop the runner
+    if (agent.abortController) {
+      agent.abortController.abort();
+    }
+    return true;
+  }
+
+  // ─── Private Helpers ─────────────────────────────────────────────────────
+
+  _buildSystemPrompt(modelMeta) {
+    // Use code-agent prompt as base, fall back to whatever is available
+    const promptName = modelMeta.prompt || 'code-agent';
+    if (this.promptManager && this.promptManager.has(promptName)) {
+      return this.promptManager.get(promptName);
+    }
+    if (this.promptManager && this.promptManager.has('code-agent')) {
+      return this.promptManager.get('code-agent');
+    }
+    return '';
+  }
+
+  _assembleSystemPrompt(basePrompt, task, options, modelMeta) {
+    let prompt = basePrompt;
+    prompt += `\n\n${SUB_AGENT_DIRECTIVE}`;
+
+    // Add project instructions
+    if (this.config) {
+      const instructions = this.config.getInstructions();
+      if (instructions) {
+        prompt += `\n\n## Project Instructions (from ${instructions.source})\n\n${instructions.content}`;
+      }
+    }
+
+    // Add context
+    if (options.context) {
+      prompt += `\n\n## Context from Parent Agent\n\n${options.context}`;
+    }
+
+    // Context budget: trim if exceeding ~50% of model's context limit
+    const contextLimit = modelMeta.contextLimit || 32768;
+    const maxPromptChars = Math.floor(contextLimit * 2); // rough char-to-token ratio
+    if (prompt.length > maxPromptChars) {
+      prompt = prompt.slice(0, maxPromptChars) + '\n\n[...context trimmed to fit model context window]';
+    }
+
+    return prompt;
+  }
+
+  _readFiles(filePaths) {
+    const fs = require('fs');
+    const path = require('path');
+    const parts = [];
+
+    for (const filePath of filePaths) {
+      try {
+        const fullPath = path.resolve(this.projectDir, filePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          // Limit each file to 10k chars
+          const trimmed = content.length > 10000
+            ? content.slice(0, 10000) + '\n[...truncated]'
+            : content;
+          parts.push(`### ${filePath}\n\`\`\`\n${trimmed}\n\`\`\``);
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+
+    return parts.length > 0 ? parts.join('\n\n') : null;
+  }
+}
+
+/**
+ * Tool definition for spawn_agent, exported for use by banana.js
+ */
+const SPAWN_AGENT_TOOL_DEF = {
+  type: 'function',
+  function: {
+    name: 'spawn_agent',
+    description: 'Spawn a sub-agent on a different model. Use for code review, parallel research, complex reasoning, or delegating to specialized models. Use "local:current" to spawn on the same model you are running on.',
+    parameters: {
+      type: 'object',
+      properties: {
+        model: {
+          type: 'string',
+          description: 'Model in "provider:alias" format. Use "local:current" for the same model (recommended default). Cloud examples: "anthropic:claude-sonnet-4-6", "openai:gpt-4o"'
+        },
+        task: {
+          type: 'string',
+          description: 'Clear task description for the sub-agent'
+        },
+        context: {
+          type: 'string',
+          description: 'Optional context (relevant code, findings, constraints)'
+        },
+        read_only: {
+          type: 'boolean',
+          description: 'Restrict to read-only tools. Default: false'
+        }
+      },
+      required: ['model', 'task']
+    }
+  }
+};
+
+module.exports = { SubAgentManager, SPAWN_AGENT_TOOL_DEF, MAX_DEPTH };

package/lib/tokenCounter.js

@@ -0,0 +1,132 @@
+/**
+ * Token counting and cost estimation for Banana Code
+ */
+
+class TokenCounter {
+  constructor(config) {
+    this.config = config;
+    this.sessionTokens = {
+      input: 0,
+      output: 0
+    };
+
+    // Rough cost estimates per 1M tokens (adjust based on your model)
+    this.costs = {
+      local: { input: 0, output: 0 }, // Free for local models
+      'gpt-4': { input: 30, output: 60 },
+      'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
+      'claude-3-opus': { input: 15, output: 75 },
+      'claude-3-sonnet': { input: 3, output: 15 }
+    };
+  }
+
+  // Estimate tokens from text (rough approximation)
+  // More accurate would be to use tiktoken, but this works for estimates
+  estimateTokens(text) {
+    if (!text) return 0;
+
+    // Average English: ~4 chars per token
+    // Code tends to be more tokenized: ~3.5 chars per token
+    const charCount = text.length;
+
+    // Detect if it's mostly code
+    const codeIndicators = ['{', '}', '(', ')', ';', '=>', 'function', 'const', 'import'];
+    const isCode = codeIndicators.some(indicator => text.includes(indicator));
+
+    const charsPerToken = isCode ? 3.5 : 4;
+    return Math.ceil(charCount / charsPerToken);
+  }
+
+  // Track tokens for a request/response
+  trackUsage(inputText, outputText) {
+    const inputTokens = this.estimateTokens(inputText);
+    const outputTokens = this.estimateTokens(outputText);
+
+    this.sessionTokens.input += inputTokens;
+    this.sessionTokens.output += outputTokens;
+
+    return { inputTokens, outputTokens };
+  }
+
+  // Track exact API-reported usage when available
+  addUsage(inputTokens = 0, outputTokens = 0) {
+    const inTokens = Math.max(0, Number(inputTokens) || 0);
+    const outTokens = Math.max(0, Number(outputTokens) || 0);
+    this.sessionTokens.input += inTokens;
+    this.sessionTokens.output += outTokens;
+    return { inputTokens: inTokens, outputTokens: outTokens };
+  }
+
+  // Get session totals
+  getSessionUsage() {
+    return {
+      input: this.sessionTokens.input,
+      output: this.sessionTokens.output,
+      total: this.sessionTokens.input + this.sessionTokens.output
+    };
+  }
+
+  // Reset session tracking
+  resetSession() {
+    this.sessionTokens = { input: 0, output: 0 };
+  }
+
+  // Estimate cost (for non-local models)
+  estimateCost(model = 'local') {
+    const rates = this.costs[model] || this.costs.local;
+    const inputCost = (this.sessionTokens.input / 1000000) * rates.input;
+    const outputCost = (this.sessionTokens.output / 1000000) * rates.output;
+
+    return {
+      input: inputCost,
+      output: outputCost,
+      total: inputCost + outputCost,
+      formatted: `$${(inputCost + outputCost).toFixed(4)}`
+    };
+  }
+
+  // Check if we're approaching token limit
+  checkLimit(additionalTokens = 0) {
+    const maxTokens = this.config.get('maxTokens') || 32000;
+    const threshold = this.config.get('tokenWarningThreshold') || 0.8;
+    const current = this.sessionTokens.input + this.sessionTokens.output + additionalTokens;
+
+    const percentage = current / maxTokens;
+
+    return {
+      current,
+      max: maxTokens,
+      percentage,
+      isWarning: percentage >= threshold,
+      isExceeded: percentage >= 1,
+      remaining: maxTokens - current
+    };
+  }
+
+  // Format token count for display
+  formatCount(count) {
+    if (count >= 1000000) {
+      return `${(count / 1000000).toFixed(2)}M`;
+    } else if (count >= 1000) {
+      return `${(count / 1000).toFixed(1)}K`;
+    }
+    return count.toString();
+  }
+
+  // Get a nice summary string
+  getSummary() {
+    const usage = this.getSessionUsage();
+    const limit = this.checkLimit();
+
+    let summary = `Tokens: ${this.formatCount(usage.total)} `;
+    summary += `(${this.formatCount(usage.input)} in / ${this.formatCount(usage.output)} out)`;
+
+    if (limit.isWarning) {
+      summary += ` ⚠️ ${Math.round(limit.percentage * 100)}% of limit`;
+    }
+
+    return summary;
+  }
+}
+
+module.exports = TokenCounter;

package/lib/visionAnalyzer.js

@@ -0,0 +1,163 @@
+/**
+ * Vision Analyzer for Banana Code
+ *
+ * Primary: Send images directly to local vision models (Qwen3 VL) via LM Studio
+ * Fallback: Use Gemini API to analyze images when non-vision model is loaded
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class VisionAnalyzer {
+  constructor(options = {}) {
+    // Gemini API endpoint - fallback for non-vision models
+    this.apiKey = options.apiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+    this.apiUrl = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent';
+    this.geminiEnabled = !!this.apiKey;
+  }
+
+  /**
+   * Set the active provider so vision checks work correctly.
+   * Monkey Models provider handles vision server-side via Gemini proxy.
+   */
+  setActiveProvider(provider) {
+    this.activeProvider = provider;
+  }
+
+  /**
+   * Check if any vision capability is available.
+   * Monkey Models handles vision server-side, so it's always available.
+   */
+  isEnabled() {
+    if (this.activeProvider === 'monkey') return true;
+    return this.geminiEnabled;
+  }
+
+  /**
+   * Build a multimodal message for LM Studio (OpenAI-compatible format)
+   * Use this when the current model supports vision natively.
+   * @param {string} text - The user's message text
+   * @param {Array} images - Array of {base64, mimeType, path} objects
+   * @returns {Object} - A message object with multimodal content array
+   */
+  buildMultimodalMessage(text, images) {
+    const content = [
+      { type: 'text', text }
+    ];
+    for (const img of images) {
+      content.push({
+        type: 'image_url',
+        image_url: {
+          url: `data:${img.mimeType};base64,${img.base64}`
+        }
+      });
+    }
+    return { role: 'user', content };
+  }
+
+  /**
+   * Analyze an image via Gemini API (fallback when local model isn't vision-capable)
+   * @param {Object} imageData - Image data with base64 and mimeType
+   * @param {string} context - Optional context about what user wants to know
+   * @returns {Promise<string>} - Analysis text
+   */
+  async analyzeImage(imageData, context = '') {
+    if (!this.geminiEnabled) {
+      return null;
+    }
+
+    const prompt = context
+      ? `Analyze this image in detail. The user wants to know: "${context}"\n\nProvide a comprehensive description including:\n1. What type of content this is (UI screenshot, code, diagram, photo, etc.)\n2. All visible text, labels, and content\n3. Layout and structure\n4. Colors, styling, and design elements\n5. Any issues, errors, or notable observations\n6. Specific details relevant to the user's question`
+      : `Analyze this image in comprehensive detail for a software developer. Include:\n1. What type of content this is (UI screenshot, code, diagram, error message, etc.)\n2. All visible text, labels, buttons, and content (transcribe exactly)\n3. Layout structure and hierarchy\n4. Colors, styling, fonts, spacing\n5. Any visible errors, warnings, or issues\n6. Technical observations (framework hints, patterns, accessibility concerns)\n7. What a developer would need to know to work with or fix this`;
+
+    try {
+      const response = await fetch(`${this.apiUrl}?key=${this.apiKey}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{
+            parts: [
+              { text: prompt },
+              {
+                inline_data: {
+                  mime_type: imageData.mimeType,
+                  data: imageData.base64
+                }
+              }
+            ]
+          }],
+          generationConfig: {
+            temperature: 0.2,
+            maxOutputTokens: 2048
+          }
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        console.error('Vision API error:', error);
+        return null;
+      }
+
+      const data = await response.json();
+      const analysis = data.candidates?.[0]?.content?.parts?.[0]?.text;
+
+      return analysis || null;
+    } catch (error) {
+      console.error('Vision analysis failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Analyze multiple images via Gemini (fallback)
+   * @param {Array} images - Array of image data objects
+   * @param {string} context - User's question/context
+   * @returns {Promise<string>} - Combined analysis
+   */
+  async analyzeImages(images, context = '') {
+    if (!this.geminiEnabled || images.length === 0) {
+      return null;
+    }
+
+    const analyses = [];
+
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      const imgContext = images.length > 1
+        ? `Image ${i + 1} of ${images.length}. ${context}`
+        : context;
+
+      const analysis = await this.analyzeImage(img, imgContext);
+      if (analysis) {
+        analyses.push(`**[Image ${i + 1}: ${img.path || 'uploaded'}]**\n${analysis}`);
+      }
+    }
+
+    if (analyses.length === 0) {
+      return null;
+    }
+
+    return analyses.join('\n\n---\n\n');
+  }
+
+  /**
+   * Format analysis for inclusion in prompt
+   * @param {string} analysis - The image analysis
+   * @returns {string} - Formatted for prompt injection
+   */
+  formatForPrompt(analysis) {
+    if (!analysis) return '';
+
+    return `
+<image_analysis>
+The following is an AI-generated analysis of the attached image(s). Use this information to understand what the user is showing you:
+
+${analysis}
+</image_analysis>
+
+`;
+  }
+}
+
+module.exports = VisionAnalyzer;