banana-code 1.2.0

package/lib/statusBar.js

@@ -0,0 +1,283 @@
+/**
+ * statusBar.js - Pinned status bar at the bottom of the terminal
+ *
+ * Uses a scroll region to constrain content above the bar, plus cursor
+ * save/restore to paint a 3-row bar (rule + content + pad) in the
+ * reserved bottom rows, with a blank spacer row above it so the input
+ * prompt is not visually cramped. The bar is rendered on demand (updates, prompt,
+ * resize) to avoid cursor races while typing.
+ */
+
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BG_DARK = '\x1b[48;5;236m';
+const FG_LIGHT = '\x1b[38;5;252m';
+const BORDER_COLOR = '\x1b[38;5;240m';
+const SEP = `${DIM} \u2502 ${RESET}`;
+
+const BAR_HEIGHT = 4;
+const GAP_ROWS = 1;
+class StatusBar {
+  constructor() {
+    this._installed = false;
+    this._lastRendered = '';
+    this._timerStart = null;
+    this._responseTime = null;
+    this._inputHint = '';  // Dim text shown in gap row during active work
+    this._fields = {
+      modelName: '?',
+      modelId: '',
+      mode: 'work',
+      contextPct: 0,
+      contextTokens: 0,
+      contextLimit: 0,
+      mcpConnected: false,
+      sessionIn: 0,
+      sessionOut: 0,
+    };
+  }
+
+  /** Install: set scroll region, start repaint interval, listen for resize */
+  install() {
+    if (!process.stdout.isTTY) return;
+    if (this._installed) {
+      this._lastRendered = '';
+      this._applyScrollRegion();
+      this._renderBar();
+      return;
+    }
+    this._installed = true;
+    this._applyScrollRegion();
+    this._renderBar();
+    this._resizeTimer = null;
+    this._resizeHandler = () => {
+      // Debounce resize to avoid racing with readline's own resize handling.
+      // Without this, rapid resize events cause the scroll region, cursor
+      // position, and prompt to fight each other, producing garbled output.
+      if (this._resizeTimer) clearTimeout(this._resizeTimer);
+      this._resizeTimer = setTimeout(() => {
+        this._resizeTimer = null;
+        this._lastRendered = '';
+        this._applyScrollRegion();
+        this._renderBar();
+        this._paintGapRow();
+      }, 80);
+    };
+    process.stdout.on('resize', this._resizeHandler);
+  }
+
+  /** Uninstall: stop repaint, reset scroll region, clear bar */
+  uninstall() {
+    if (!process.stdout.isTTY) return;
+    this._installed = false;
+    if (this._resizeTimer) {
+      clearTimeout(this._resizeTimer);
+      this._resizeTimer = null;
+    }
+    if (this._resizeHandler) {
+      process.stdout.removeListener('resize', this._resizeHandler);
+      this._resizeHandler = null;
+    }
+    // Reset scroll region to full terminal
+    process.stdout.write('\x1b[r');
+    // Clear the reserved rows (gap + bar)
+    const rows = process.stdout.rows || 24;
+    const reserved = BAR_HEIGHT + GAP_ROWS;
+    const clearStart = Math.max(1, rows - reserved + 1);
+    for (let r = clearStart; r <= rows; r++) {
+      process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+    }
+  }
+
+  /** Reinstall after console.clear() */
+  reinstall() {
+    if (!process.stdout.isTTY) return;
+    this._installed = true;
+    this._lastRendered = '';
+    this._applyScrollRegion();
+    this._renderBar();
+  }
+
+  /** Partial field update + re-render */
+  update(fields) {
+    Object.assign(this._fields, fields);
+    if (this._installed) this._renderBar();
+  }
+
+  /** Start wall-clock response timer */
+  startTiming() {
+    this._timerStart = Date.now();
+    this._responseTime = null;
+  }
+
+  /** Stop timer and re-render */
+  stopTiming() {
+    if (this._timerStart) {
+      this._responseTime = ((Date.now() - this._timerStart) / 1000).toFixed(1);
+      this._timerStart = null;
+      if (this._installed) this._renderBar();
+    }
+  }
+
+  /** Show or clear the input hint in the gap row above the bar */
+  setInputHint(text) {
+    this._inputHint = text || '';
+    if (this._installed) this._paintGapRow();
+  }
+
+  /** Force a render (called from showPrompt) */
+  render() {
+    if (this._installed) {
+      this._lastRendered = '';
+      this._renderBar();
+      this._paintGapRow();
+    }
+  }
+
+  /** Constrain scrollable area to rows above the bar.
+   *  Uses cursor save/restore so the cursor stays wherever it was before. */
+  _applyScrollRegion() {
+    const rows = process.stdout.rows || 24;
+    const reserved = BAR_HEIGHT + GAP_ROWS;
+    const scrollEnd = Math.max(1, rows - reserved);
+    // Save cursor, set scroll region, restore cursor.
+    // This prevents the scroll region reset from moving the cursor.
+    process.stdout.write(`\x1b[s\x1b[1;${scrollEnd}r\x1b[u`);
+  }
+
+  /** Force-repaint the bar. Safe to call frequently (e.g. after every
+   *  clearLine/cursorTo in spinner code). Does NOT reapply the scroll
+   *  region since clearLine/cursorTo don't reset it. */
+  refresh() {
+    if (!process.stdout.isTTY || !this._installed) return;
+    this._lastRendered = '';
+    this._renderBar();
+  }
+
+  /** Paint the status bar rows at the bottom of the terminal */
+  _renderBar() {
+    if (!process.stdout.isTTY || !this._installed) return;
+
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    const f = this._fields;
+
+    // Build content segments
+    const segments = [];
+
+    const modelDisplay = f.modelId
+      ? `${f.modelName} (${f.modelId})`
+      : f.modelName;
+    segments.push(modelDisplay);
+
+    // Mode indicator
+    const modeColors = { work: GREEN, plan: '\x1b[36m', ask: '\x1b[35m' };
+    const modeColor = modeColors[f.mode] || GREEN;
+    segments.push(`${modeColor}${(f.mode || 'work').toUpperCase()}${RESET}${BG_DARK}${FG_LIGHT}`);
+
+    const ctxColor = f.contextPct >= 80 ? RED : f.contextPct >= 50 ? YELLOW : GREEN;
+    const ctxTokensStr = this._formatTokens(f.contextTokens);
+    const ctxLimitStr = this._formatTokens(f.contextLimit);
+    const ctxDisplay = f.contextLimit
+      ? `ctx: ${ctxColor}${f.contextPct}%${RESET}${BG_DARK}${FG_LIGHT} (${ctxTokensStr}/${ctxLimitStr})`
+      : `ctx: ${ctxColor}${f.contextPct}%${RESET}${BG_DARK}${FG_LIGHT}`;
+    segments.push(ctxDisplay);
+
+    const mcpDot = f.mcpConnected
+      ? `${GREEN}\u25CF${RESET}${BG_DARK}${FG_LIGHT}`
+      : `${RED}\u25CF${RESET}${BG_DARK}${FG_LIGHT}`;
+    segments.push(`MCP: ${mcpDot}`);
+
+    const inStr = this._formatTokens(f.sessionIn);
+    const outStr = this._formatTokens(f.sessionOut);
+    segments.push(`in:${inStr} out:${outStr}`);
+
+    if (this._responseTime) {
+      segments.push(`${this._responseTime}s`);
+    }
+
+    // Progressive collapse for narrow terminals
+    let bar = this._joinSegments(segments);
+    let barVisualLen = this._visualLen(bar);
+
+    if (barVisualLen > cols - 4 && this._responseTime) {
+      segments.pop();
+      bar = this._joinSegments(segments);
+      barVisualLen = this._visualLen(bar);
+    }
+    if (barVisualLen > cols - 4 && f.modelId) {
+      segments[0] = f.modelName;
+      bar = this._joinSegments(segments);
+      barVisualLen = this._visualLen(bar);
+    }
+    if (barVisualLen > cols - 4) {
+      // Remove MCP segment (index 3: model, mode, ctx, MCP, in/out)
+      const mcpIdx = segments.findIndex(s => s.startsWith('MCP:'));
+      if (mcpIdx !== -1) segments.splice(mcpIdx, 1);
+      bar = this._joinSegments(segments);
+      barVisualLen = this._visualLen(bar);
+    }
+
+    // Build the 4 rows: rule, top pad, content, bottom pad
+    const rule = `${BORDER_COLOR}${'\u2500'.repeat(cols)}${RESET}`;
+    const contentPad = Math.max(0, cols - barVisualLen - 1);
+    const content = `${BG_DARK}${FG_LIGHT} ${bar}${' '.repeat(contentPad)}${RESET}`;
+    const padRow = `${BG_DARK}${' '.repeat(cols)}${RESET}`;
+
+    const fullBar = rule + padRow + content + padRow;
+    if (fullBar === this._lastRendered) return;
+    this._lastRendered = fullBar;
+
+    const barStartRow = rows - BAR_HEIGHT + 1;
+
+    // Save cursor, draw bar rows, restore cursor.
+    let paint = '\x1b[s';
+    paint +=
+      `\x1b[${barStartRow};1H\x1b[2K` + rule +            // row 1: rule
+      `\x1b[${barStartRow + 1};1H\x1b[2K` + padRow +      // row 2: top pad
+      `\x1b[${barStartRow + 2};1H\x1b[2K` + content +     // row 3: content
+      `\x1b[${barStartRow + 3};1H\x1b[2K` + padRow +      // row 4: bottom pad
+      '\x1b[u';
+    process.stdout.write(paint);
+  }
+
+  /** Paint the gap row above the bar with the input hint (or blank) */
+  _paintGapRow() {
+    if (!process.stdout.isTTY || !this._installed) return;
+    const rows = process.stdout.rows || 24;
+    const cols = process.stdout.columns || 80;
+    const gapRow = rows - BAR_HEIGHT - GAP_ROWS + 1;
+    if (gapRow < 1) return;
+
+    let rowContent;
+    if (this._inputHint) {
+      const hint = this._inputHint.length > cols - 2
+        ? this._inputHint.slice(0, cols - 2)
+        : this._inputHint;
+      rowContent = `${DIM} ${hint}${RESET}`;
+    } else {
+      rowContent = '';
+    }
+    process.stdout.write(`\x1b[s\x1b[${gapRow};1H\x1b[2K${rowContent}\x1b[u`);
+  }
+
+  _joinSegments(segments) {
+    return segments.join(`${RESET}${BG_DARK}${FG_LIGHT}${SEP}${BG_DARK}${FG_LIGHT}`);
+  }
+
+  _formatTokens(n) {
+    if (!n || n === 0) return '0';
+    if (n < 1000) return String(n);
+    return (n / 1000).toFixed(1) + 'K';
+  }
+
+  _visualLen(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '').length;
+  }
+}
+
+module.exports = StatusBar;

package/lib/streamHandler.js

@@ -0,0 +1,306 @@
+/**
+ * Streaming response handler for Banana Code
+ *
+ * Filters out <file_operation>, <run_command>, and <think> blocks during streaming
+ * so users only see the explanation text. The full response (with XML)
+ * is still captured for parsing after streaming completes.
+ *
+ * Also handles "orphan" </think> tags where the model outputs reasoning
+ * WITHOUT an opening <think> tag (common with Qwen models).
+ */
+
+// Strip model control tokens like <|start|>, <|channel|>, <|constrain|>, <|end|>, etc.
+// These leak from models like GPT-OSS, Llama, and others.
+const CONTROL_TOKEN_RE = /<\|[^|]*\|>/g;
+function stripControlTokens(text) {
+  const cleaned = text.replace(CONTROL_TOKEN_RE, '');
+  // If the line was entirely control tokens + whitespace, return empty
+  return cleaned.replace(/^\s+$/, '');
+}
+
+class StreamHandler {
+  constructor(options = {}) {
+    this.onToken = options.onToken || (() => {});
+    this.onComplete = options.onComplete || (() => {});
+    this.onError = options.onError || (() => {});
+    this.onBlockProgress = options.onBlockProgress || null; // (type, charsSoFar) - called while inside suppressed XML blocks
+    this.buffer = '';
+    this.fullResponse = '';
+
+    // For filtering XML blocks during display
+    this.displayBuffer = '';
+    this.insideXmlBlock = false;
+    this.xmlBlockType = null; // 'file_operation', 'run_command', or 'think'
+
+    // For detecting orphan </think> tags (model reasoning without opening tag)
+    // Buffer output until we confirm there's no orphan </think> coming
+    this.orphanBuffer = '';
+    this.orphanCheckComplete = false; // Once true, stop buffering for orphan check
+  }
+
+  /**
+   * Process content for display, filtering out XML blocks
+   * Returns only the text that should be shown to the user
+   *
+   * Handles two cases:
+   * 1. Normal XML blocks: <think>...</think>, <file_operation>...</file_operation>, etc.
+   * 2. Orphan closing tags: Model outputs reasoning without <think> tag, only </think> at end
+   */
+  filterForDisplay(content) {
+    this.displayBuffer += content;
+
+    // Regex patterns
+    const openTagRegex = /<\s*(file_operation|run_command|think|thinking)\s*>[\r\n]*/i;
+    const closeFileOp = /<\s*\/\s*file_operation\s*>/i;
+    const closeRunCmd = /<\s*\/\s*run_command\s*>/i;
+    const closeThink = /<\s*\/\s*think(?:ing)?\s*>/i;
+
+    let output = '';
+
+    while (this.displayBuffer.length > 0) {
+      if (this.insideXmlBlock) {
+        // Look for closing tag based on block type
+        let closeRegex;
+        if (this.xmlBlockType === 'file_operation') {
+          closeRegex = closeFileOp;
+        } else if (this.xmlBlockType === 'run_command') {
+          closeRegex = closeRunCmd;
+        } else {
+          closeRegex = closeThink;
+        }
+        const closeMatch = this.displayBuffer.match(closeRegex);
+
+        if (closeMatch) {
+          // Found closing tag, skip everything up to and including it
+          // Use displayBuffer length as the final count (displayBuffer has accumulated content since block open)
+          if (this.onBlockProgress) this.onBlockProgress(this.xmlBlockType, this.displayBuffer.length, true);
+          const closeEnd = closeMatch.index + closeMatch[0].length;
+          this.displayBuffer = this.displayBuffer.slice(closeEnd);
+          this.insideXmlBlock = false;
+          this.xmlBlockType = null;
+        } else {
+          // Still inside block, keep buffering
+          // displayBuffer contains all content since block opened, so use its length directly
+          if (this.onBlockProgress) this.onBlockProgress(this.xmlBlockType, this.displayBuffer.length, false);
+          break;
+        }
+      } else {
+        // Not inside a block - check for orphan </think> first (before checking opening tags)
+        if (!this.orphanCheckComplete) {
+          // Check if we have an orphan </think> (closing tag without opening)
+          const orphanCloseMatch = this.displayBuffer.match(closeThink);
+          const openThinkMatch = this.displayBuffer.match(/<\s*(think|thinking)\s*>/i);
+
+          if (orphanCloseMatch) {
+            // Found </think> - check if there's an opening tag before it
+            if (!openThinkMatch || openThinkMatch.index > orphanCloseMatch.index) {
+              // Orphan! Discard everything up to and including </think>
+              const closeEnd = orphanCloseMatch.index + orphanCloseMatch[0].length;
+              let remaining = this.displayBuffer.slice(closeEnd);
+              // Also strip any leading whitespace/newlines after </think>
+              remaining = remaining.replace(/^[\s\r\n]+/, '');
+              this.displayBuffer = remaining;
+              this.orphanCheckComplete = true;
+              // Also discard anything we had buffered
+              this.orphanBuffer = '';
+              continue; // Re-process remaining buffer
+            }
+          }
+
+          // Check if buffer might still receive </think>
+          // If we see content that looks like actual response (not reasoning), stop checking
+          // Heuristic: If buffer is > 500 chars with no </think>, assume no orphan
+          if (this.displayBuffer.length > 500) {
+            this.orphanCheckComplete = true;
+            // Flush orphan buffer
+            output += this.orphanBuffer;
+            this.orphanBuffer = '';
+          }
+        }
+
+        // Look for opening tag
+        const openMatch = this.displayBuffer.match(openTagRegex);
+
+        if (openMatch) {
+          // Found opening tag - mark orphan check complete if it's a think tag
+          const blockType = openMatch[1].toLowerCase();
+          if (blockType === 'think' || blockType === 'thinking') {
+            this.orphanCheckComplete = true;
+            output += this.orphanBuffer;
+            this.orphanBuffer = '';
+          }
+
+          // Output everything before the tag
+          const beforeTag = this.displayBuffer.slice(0, openMatch.index);
+          if (this.orphanCheckComplete) {
+            output += beforeTag;
+          } else {
+            this.orphanBuffer += beforeTag;
+          }
+
+          // Skip past the opening tag
+          this.displayBuffer = this.displayBuffer.slice(openMatch.index + openMatch[0].length);
+          this.insideXmlBlock = true;
+          this.xmlBlockType = blockType === 'thinking' ? 'think' : blockType;
+        } else {
+          // No complete opening tag found
+          // Check if buffer ends with a partial tag
+          const partialMatch = this.displayBuffer.match(/<[^>]{0,20}$/);
+
+          if (partialMatch) {
+            // Output everything before the potential partial tag
+            const beforePartial = this.displayBuffer.slice(0, partialMatch.index);
+            if (this.orphanCheckComplete) {
+              output += beforePartial;
+            } else {
+              this.orphanBuffer += beforePartial;
+            }
+            this.displayBuffer = this.displayBuffer.slice(partialMatch.index);
+            break;
+          } else {
+            // Safe to output everything
+            if (this.orphanCheckComplete) {
+              output += this.displayBuffer;
+            } else {
+              this.orphanBuffer += this.displayBuffer;
+            }
+            this.displayBuffer = '';
+          }
+        }
+      }
+    }
+
+    return stripControlTokens(output);
+  }
+
+  async handleStream(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const IDLE_TIMEOUT = 30000; // 30 seconds with no data = assume done (LM Studio needs time after prompt processing)
+
+    try {
+      while (true) {
+        // Race between read and timeout
+        const readPromise = reader.read();
+        const timeoutPromise = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('IDLE_TIMEOUT')), IDLE_TIMEOUT)
+        );
+
+        let done, value;
+        try {
+          const result = await Promise.race([readPromise, timeoutPromise]);
+          done = result.done;
+          value = result.value;
+        } catch (e) {
+          if (e.message === 'IDLE_TIMEOUT') {
+            // No data for 5 seconds, assume stream is complete
+            break;
+          }
+          throw e;
+        }
+
+        if (done) {
+          break;
+        }
+
+        const chunk = decoder.decode(value, { stream: true });
+        this.buffer += chunk;
+
+        // Process SSE data
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          let content = '';
+
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+
+            if (data === '[DONE]') {
+              // Stream complete signal - exit the loop
+              this.onComplete(this.fullResponse);
+              return this.fullResponse;
+            }
+
+            try {
+              const parsed = JSON.parse(data);
+              // Try multiple possible response formats
+              content = parsed.choices?.[0]?.delta?.content
+                || parsed.choices?.[0]?.text
+                || parsed.content
+                || parsed.delta?.content
+                || parsed.text
+                || '';
+            } catch {
+              // Not valid JSON, treat as raw text
+              content = data;
+            }
+          } else if (line.trim() && !line.startsWith(':')) {
+            // Raw text line (not SSE comment)
+            content = line;
+          }
+
+          if (content) {
+            this.fullResponse += content;
+            // Filter out XML blocks for display
+            const displayContent = this.filterForDisplay(content);
+            if (displayContent) {
+              this.onToken(displayContent);
+            }
+          }
+        }
+      }
+
+      // Process any remaining buffer
+      if (this.buffer) {
+        const lines = this.buffer.split('\n');
+        for (const line of lines) {
+          if (line.startsWith('data: ') && line.slice(6) !== '[DONE]') {
+            try {
+              const parsed = JSON.parse(line.slice(6));
+              // Try multiple possible response formats
+              const content = parsed.choices?.[0]?.delta?.content
+                || parsed.choices?.[0]?.text
+                || parsed.content
+                || parsed.delta?.content
+                || parsed.text
+                || '';
+              if (content) {
+                this.fullResponse += content;
+                // Filter out XML blocks for display
+                const displayContent = this.filterForDisplay(content);
+                if (displayContent) {
+                  this.onToken(displayContent);
+                }
+              }
+            } catch {
+              // Ignore
+            }
+          }
+        }
+      }
+
+      this.onComplete(this.fullResponse);
+      return this.fullResponse;
+
+    } catch (error) {
+      this.onError(error);
+      throw error;
+    }
+  }
+
+  getFullResponse() {
+    return this.fullResponse;
+  }
+}
+
+// Non-streaming fallback with simulated streaming effect
+async function simulateStreaming(text, onToken, delay = 5) {
+  const words = text.split(/(\s+)/);
+  for (const word of words) {
+    onToken(word);
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+}
+
+module.exports = { StreamHandler, simulateStreaming };