@mmmbuto/nexuscli 0.5.0

package/lib/server/services/context-bridge.js

@@ -0,0 +1,289 @@
+/**
+ * ContextBridge - Unified context management with token optimization
+ *
+ * Features:
+ * - Token-aware context truncation
+ * - Engine-specific context compression
+ * - Auto-summary triggering
+ * - Unified bridging logic for all engines
+ */
+
+const Message = require('../models/Message');
+const SummaryGenerator = require('./summary-generator');
+
+// Token estimation constants (approximate)
+const CHARS_PER_TOKEN = 4; // GPT/Claude average
+const DEFAULT_MAX_TOKENS = 4000; // Context budget for bridging
+const SUMMARY_TRIGGER_THRESHOLD = 15; // Messages before auto-summary
+
+// Engine-specific context limits
+const ENGINE_LIMITS = {
+  'claude': { maxTokens: 4000, preferSummary: true },
+  'codex': { maxTokens: 3000, preferSummary: true, codeOnly: true },
+  'deepseek': { maxTokens: 3000, preferSummary: true },
+  'gemini': { maxTokens: 6000, preferSummary: false } // Gemini has large context
+};
+
+class ContextBridge {
+  constructor() {
+    this.summaryGenerator = new SummaryGenerator();
+  }
+
+  /**
+   * Estimate token count for text
+   * @param {string} text - Text to estimate
+   * @returns {number} Estimated token count
+   */
+  estimateTokens(text) {
+    if (!text) return 0;
+    // Simple estimation: ~4 chars per token for English/code
+    // More accurate would use tiktoken, but this is faster
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+  }
+
+  /**
+   * Get engine-specific configuration
+   * @param {string} engine - Engine name
+   * @returns {Object} Engine config
+   */
+  getEngineConfig(engine) {
+    return ENGINE_LIMITS[engine] || ENGINE_LIMITS['claude'];
+  }
+
+  /**
+   * Build optimized context for engine switch
+   * @param {Object} params
+   * @param {string} params.sessionId - Session ID
+   * @param {string} params.fromEngine - Previous engine
+   * @param {string} params.toEngine - Target engine
+   * @param {string} params.userMessage - Current user message
+   * @returns {Object} { prompt, isEngineBridge, contextTokens }
+   */
+  async buildContext({ sessionId, fromEngine, toEngine, userMessage }) {
+    const config = this.getEngineConfig(toEngine);
+    const isEngineBridge = fromEngine && fromEngine !== toEngine;
+
+    // Reserve tokens for user message
+    const userTokens = this.estimateTokens(userMessage);
+    const availableTokens = config.maxTokens - userTokens - 200; // 200 token buffer
+
+    let contextText = '';
+    let contextTokens = 0;
+    let contextSource = 'none';
+
+    // Try summary first (most efficient)
+    if (config.preferSummary) {
+      const summaryContext = this.summaryGenerator.getBridgeContext(sessionId);
+      if (summaryContext) {
+        const summaryTokens = this.estimateTokens(summaryContext);
+        if (summaryTokens <= availableTokens) {
+          contextText = summaryContext;
+          contextTokens = summaryTokens;
+          contextSource = 'summary';
+        }
+      }
+    }
+
+    // Fallback to token-aware message history
+    if (!contextText && availableTokens > 200) {
+      const historyContext = this.buildTokenAwareHistory(sessionId, availableTokens, config);
+      if (historyContext.text) {
+        contextText = historyContext.text;
+        contextTokens = historyContext.tokens;
+        contextSource = 'history';
+      }
+    }
+
+    // Build final prompt
+    let prompt = userMessage;
+
+    if (contextText) {
+      if (isEngineBridge) {
+        prompt = `${contextText}\n\n[Switching from ${fromEngine} to ${toEngine}]\n\nUser message:\n${userMessage}`;
+      } else {
+        prompt = `${contextText}\n\nUser message:\n${userMessage}`;
+      }
+    }
+
+    console.log(`[ContextBridge] Built context: ${contextTokens} tokens from ${contextSource}, bridge: ${isEngineBridge}`);
+
+    return {
+      prompt,
+      isEngineBridge,
+      contextTokens,
+      contextSource,
+      totalTokens: contextTokens + userTokens
+    };
+  }
+
+  /**
+   * Build token-aware history context
+   * @param {string} sessionId - Session ID
+   * @param {number} maxTokens - Token budget
+   * @param {Object} config - Engine config
+   * @returns {Object} { text, tokens, messageCount }
+   */
+  buildTokenAwareHistory(sessionId, maxTokens, config = {}) {
+    // Get more messages than we need, we'll trim
+    const messages = Message.getContextMessages(sessionId, 20);
+
+    if (messages.length === 0) {
+      return { text: '', tokens: 0, messageCount: 0 };
+    }
+
+    const lines = [];
+    let tokenCount = 0;
+    let includedCount = 0;
+
+    // Process from newest to oldest (we got them in chronological order, reverse)
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+
+      // For code-focused engines, filter out non-code content
+      let content = msg.content;
+      if (config.codeOnly) {
+        content = this.extractCodeContent(content);
+        if (!content) continue; // Skip if no code
+      }
+
+      // Truncate long messages
+      if (content.length > 2000) {
+        content = content.substring(0, 2000) + '...';
+      }
+
+      const role = msg.role === 'user' ? 'User' : 'Assistant';
+      const engineTag = msg.engine ? ` [${msg.engine}]` : '';
+      const line = `${role}${engineTag}: ${content}`;
+
+      const lineTokens = this.estimateTokens(line);
+
+      // Check if adding this would exceed budget
+      if (tokenCount + lineTokens > maxTokens) {
+        break;
+      }
+
+      lines.unshift(line); // Add to beginning (chronological)
+      tokenCount += lineTokens;
+      includedCount++;
+    }
+
+    if (lines.length === 0) {
+      return { text: '', tokens: 0, messageCount: 0 };
+    }
+
+    const text = `[Context from recent messages]\n${lines.join('\n\n')}`;
+
+    return {
+      text,
+      tokens: tokenCount,
+      messageCount: includedCount
+    };
+  }
+
+  /**
+   * Extract code blocks and technical content from text
+   * @param {string} text - Full text
+   * @returns {string} Code-focused content
+   */
+  extractCodeContent(text) {
+    if (!text) return '';
+
+    // Extract code blocks
+    const codeBlocks = [];
+    const codeBlockRegex = /```[\s\S]*?```/g;
+    let match;
+
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+      codeBlocks.push(match[0]);
+    }
+
+    if (codeBlocks.length > 0) {
+      return codeBlocks.join('\n\n');
+    }
+
+    // If no code blocks, check if text contains technical content
+    const technicalPatterns = [
+      /function\s+\w+/,
+      /const\s+\w+\s*=/,
+      /class\s+\w+/,
+      /import\s+.*from/,
+      /require\s*\(/,
+      /\/\/|\/\*|\*\//,
+      /\.(js|ts|py|java|cpp|go|rs)\b/,
+      /npm|git|docker|curl/
+    ];
+
+    for (const pattern of technicalPatterns) {
+      if (pattern.test(text)) {
+        return text;
+      }
+    }
+
+    return ''; // Not code-relevant
+  }
+
+  /**
+   * Check if auto-summary should be triggered
+   * @param {string} sessionId - Session ID
+   * @param {boolean} isEngineBridge - Was this an engine switch
+   * @returns {boolean} Should generate summary
+   */
+  shouldTriggerSummary(sessionId, isEngineBridge = false) {
+    // Always trigger on engine bridge
+    if (isEngineBridge) return true;
+
+    const messageCount = Message.countByConversation(sessionId);
+
+    // Trigger every 10 messages after threshold
+    if (messageCount >= SUMMARY_TRIGGER_THRESHOLD && messageCount % 10 === 0) {
+      return true;
+    }
+
+    // Check if we have a stale summary (older than 20 messages)
+    const existingSummary = this.summaryGenerator.getSummary(sessionId);
+    if (!existingSummary && messageCount > SUMMARY_TRIGGER_THRESHOLD) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Trigger summary generation (async, non-blocking)
+   * @param {string} sessionId - Session ID
+   * @param {string} logPrefix - Log prefix for debugging
+   */
+  triggerSummaryGeneration(sessionId, logPrefix = '[ContextBridge]') {
+    const messages = Message.getByConversation(sessionId, 40);
+
+    this.summaryGenerator.generateAndSave(sessionId, messages)
+      .then(summary => {
+        if (summary) {
+          console.log(`${logPrefix} Summary updated: ${summary.summary_short?.substring(0, 50)}...`);
+        }
+      })
+      .catch(err => {
+        console.warn(`${logPrefix} Summary generation failed:`, err.message);
+      });
+  }
+
+  /**
+   * Get context stats for debugging
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Stats
+   */
+  getContextStats(sessionId) {
+    const messageCount = Message.countByConversation(sessionId);
+    const lastEngine = Message.getLastEngine(sessionId);
+    const hasSummary = !!this.summaryGenerator.getSummary(sessionId);
+
+    return {
+      messageCount,
+      lastEngine,
+      hasSummary,
+      summaryThreshold: SUMMARY_TRIGGER_THRESHOLD
+    };
+  }
+}
+
+module.exports = new ContextBridge();

package/lib/server/services/gemini-output-parser.js

@@ -0,0 +1,398 @@
+/**
+ * GeminiOutputParser - Parse Gemini CLI JSON stream output
+ *
+ * Parses `gemini -o stream-json` output format.
+ *
+ * JSON Event Types from Gemini CLI:
+ * - init: Session initialization { type: 'init', session_id, model }
+ * - message: Response content { type: 'message', role: 'assistant', content, delta: true }
+ * - tool_use: Tool invocation { type: 'tool_use', tool, input }
+ * - tool_result: Tool output { type: 'tool_result', tool, output, status }
+ * - result: Final stats { type: 'result', status, stats: { input_tokens, output_tokens } }
+ * - error: Error event { type: 'error', message }
+ *
+ * Emits normalized events for SSE streaming:
+ * - status: { type: 'status', category: 'tool'|'system', message, icon }
+ * - response_chunk: { type: 'response_chunk', text, isIncremental }
+ * - response_done: { type: 'response_done', fullText }
+ * - done: { type: 'done', usage, status }
+ * - error: { type: 'error', message }
+ *
+ * @version 0.4.0 - TRI CLI Support
+ */
+
+class GeminiOutputParser {
+  constructor() {
+    this.buffer = '';
+    this.finalResponse = '';
+    this.usage = null;
+    this.sessionId = null;
+    this.model = null;
+    this.pendingTools = new Map();
+  }
+
+  /**
+   * Parse a chunk of stdout (may contain multiple JSON lines)
+   * @param {string} chunk - Raw stdout chunk from node-pty
+   * @returns {Array} Array of normalized event objects for SSE
+   */
+  parse(chunk) {
+    const events = [];
+
+    // Add chunk to buffer
+    this.buffer += chunk;
+
+    // Process complete lines
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete last line
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      // Skip non-JSON lines (CLI status messages, retry messages, etc.)
+      if (!trimmed.startsWith('{')) {
+        // Log significant non-JSON messages
+        if (trimmed.includes('Attempt') || trimmed.includes('failed') || trimmed.includes('Error')) {
+          console.log('[GeminiOutputParser] CLI message:', trimmed.substring(0, 100));
+        }
+        continue;
+      }
+
+      try {
+        const json = JSON.parse(trimmed);
+        const lineEvents = this._parseJsonEvent(json);
+        events.push(...lineEvents);
+      } catch (e) {
+        console.warn('[GeminiOutputParser] JSON parse error:', e.message, '- Line:', trimmed.substring(0, 80));
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Parse a single JSON event from Gemini CLI
+   * @param {Object} event - Parsed JSON object
+   * @returns {Array} Events to emit
+   */
+  _parseJsonEvent(event) {
+    const events = [];
+
+    switch (event.type) {
+      case 'init':
+        // Session initialization
+        this.sessionId = event.session_id;
+        this.model = event.model;
+        console.log('[GeminiOutputParser] Session initialized:', this.sessionId, 'Model:', this.model);
+        events.push({
+          type: 'status',
+          category: 'system',
+          message: 'Session initialized',
+          icon: '🚀',
+          sessionId: this.sessionId,
+          model: this.model,
+          timestamp: event.timestamp || new Date().toISOString(),
+        });
+        break;
+
+      case 'message':
+        if (event.role === 'assistant' || event.role === 'model') {
+          // Assistant response - streaming content
+          const content = event.content || '';
+          if (content) {
+            // Accumulate response
+            if (event.delta) {
+              // Delta mode - append to existing
+              this.finalResponse += content;
+            } else {
+              // Full replacement (rare)
+              this.finalResponse = content;
+            }
+
+            events.push({
+              type: 'response_chunk',
+              text: content,
+              isIncremental: !!event.delta,
+            });
+          }
+        }
+        break;
+
+      case 'tool_use':
+        // Tool being invoked
+        const toolEvent = this._formatToolUseEvent(event);
+        events.push(toolEvent);
+        this.pendingTools.set(event.tool_id || event.tool_use_id || event.tool_name, event);
+        break;
+
+      case 'tool_result':
+        // Tool execution completed
+        // Gemini CLI uses 'tool_name'
+        const toolName = event.tool_name || event.tool || 'Tool';
+        const success = event.status !== 'error' && event.status !== 'failure';
+
+        events.push({
+          type: 'status',
+          category: 'tool',
+          message: `${toolName}: ${success ? 'completed' : 'failed'}`,
+          icon: success ? '✅' : '❌',
+          toolOutput: this._truncateOutput(event.output || event.result),
+          timestamp: event.timestamp || new Date().toISOString(),
+        });
+
+        this.pendingTools.delete(event.tool_use_id || event.tool);
+        break;
+
+      case 'result':
+        // Final result with stats
+        this.usage = event.stats || null;
+        console.log('[GeminiOutputParser] Result received, status:', event.status, 'stats:', JSON.stringify(this.usage));
+
+        // Emit response_done
+        events.push({
+          type: 'response_done',
+          fullText: this.finalResponse,
+        });
+
+        // Emit done with usage stats
+        events.push({
+          type: 'done',
+          status: event.status,
+          usage: {
+            prompt_tokens: this.usage?.input_tokens || 0,
+            completion_tokens: this.usage?.output_tokens || 0,
+            total_tokens: (this.usage?.input_tokens || 0) + (this.usage?.output_tokens || 0),
+          },
+          duration_ms: this.usage?.duration_ms || 0,
+          tool_calls: this.usage?.tool_calls || 0,
+          sessionId: this.sessionId,
+        });
+        break;
+
+      case 'error':
+        console.error('[GeminiOutputParser] Error event:', event.message || event.error);
+        events.push({
+          type: 'error',
+          message: event.message || event.error || 'Unknown error',
+        });
+        break;
+
+      default:
+        // Unknown event type - log but don't fail
+        console.log('[GeminiOutputParser] Unknown event type:', event.type);
+    }
+
+    return events;
+  }
+
+  /**
+   * Format a tool_use event into a status event
+   */
+  _formatToolUseEvent(event) {
+    // Extract tool name from various possible fields
+    // Gemini CLI uses 'tool_name' and 'parameters'
+    const tool = event.tool_name || event.tool || event.name || event.function?.name || '';
+    const input = event.parameters || event.input || event.args || event.function?.arguments || {};
+    let message = tool || 'Tool';
+
+    // Debug: log raw event to understand structure
+    if (!tool) {
+      console.log('[GeminiOutputParser] Tool event without name:', JSON.stringify(event).substring(0, 200));
+    }
+
+    // Format message based on tool type
+    switch (tool) {
+      case 'shell':
+      case 'run_shell_command':
+      case 'execute_command':
+        message = `Shell: ${this._truncate(event.command || input.command || '', 60)}`;
+        break;
+      case 'read_file':
+      case 'read_many_files':
+      case 'read':
+        message = `Reading: ${this._truncate(event.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'write_file':
+      case 'write':
+        message = `Writing: ${this._truncate(event.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'edit_file':
+      case 'edit':
+        message = `Editing: ${this._truncate(event.path || input.path || input.file_path || '', 50)}`;
+        break;
+      case 'search_files':
+      case 'grep':
+      case 'find_files':
+        message = `Searching: ${this._truncate(event.pattern || input.pattern || input.query || '', 40)}`;
+        break;
+      case 'list_directory':
+      case 'list_dir':
+      case 'ls':
+        message = `Listing: ${this._truncate(event.path || input.path || input.dir_path || '.', 50)}`;
+        break;
+      case 'web_search':
+      case 'google_search':
+      case 'search':
+        message = `Web search: ${this._truncate(event.query || input.query || '', 40)}`;
+        break;
+      case 'web_fetch':
+      case 'fetch_url':
+        message = `Fetching: ${this._truncate(event.url || input.url || '', 50)}`;
+        break;
+      default:
+        // For unknown tools, try to create a meaningful message
+        if (tool) {
+          message = `${tool}: running...`;
+        } else {
+          // Try to extract any useful info from the event
+          const keys = Object.keys(event).filter(k => !['type', 'timestamp', 'tool_use_id'].includes(k));
+          if (keys.length > 0) {
+            message = `Tool: ${keys[0]}...`;
+          } else {
+            message = 'Tool: running...';
+          }
+        }
+    }
+
+    return {
+      type: 'status',
+      category: 'tool',
+      message,
+      icon: this._getToolIcon(tool),
+      timestamp: event.timestamp || new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Get emoji icon for tool type
+   */
+  _getToolIcon(tool) {
+    const icons = {
+      // Shell commands
+      'shell': '🔧',
+      'run_shell_command': '🔧',
+      'execute_command': '🔧',
+      // File operations
+      'read_file': '📖',
+      'read_many_files': '📚',
+      'read': '📖',
+      'write_file': '✍️',
+      'write': '✍️',
+      'edit_file': '📝',
+      'edit': '📝',
+      // Search
+      'search_files': '🔍',
+      'grep': '🔍',
+      'find_files': '🔍',
+      // Directory
+      'list_directory': '🗂️',
+      'list_dir': '🗂️',
+      'ls': '🗂️',
+      // Web
+      'web_search': '🔎',
+      'google_search': '🔎',
+      'search': '🔎',
+      'web_fetch': '🌐',
+      'fetch_url': '🌐',
+    };
+    return icons[tool] || '⚙️';
+  }
+
+  /**
+   * Truncate string to max length
+   */
+  _truncate(str, maxLen) {
+    if (!str) return '';
+    if (str.length <= maxLen) return str;
+    return str.substring(0, maxLen) + '...';
+  }
+
+  /**
+   * Truncate tool output (can be very long)
+   */
+  _truncateOutput(content) {
+    if (!content) return null;
+    const str = typeof content === 'string' ? content : JSON.stringify(content);
+    if (str.length > 500) {
+      return str.substring(0, 500) + '\n... (truncated)';
+    }
+    return str;
+  }
+
+  /**
+   * Filter out internal "thinking" patterns from model output
+   * Common in preview models that expose chain-of-thought
+   */
+  _filterThinkingPatterns(text) {
+    if (!text) return text;
+
+    const thinkingPatterns = [
+      /^Wait,?\s+.{0,200}$/gm,
+      /^Actually,?\s+.{0,200}$/gm,
+      /^Let me\s+.{0,150}$/gm,
+      /^I will\s+.{0,150}$/gm,
+      /^I should\s+.{0,150}$/gm,
+      /^I need to\s+.{0,150}$/gm,
+      /^Ready\.?\s*$/gm,
+      /^Okay\.?\s*$/gm,
+    ];
+
+    let filtered = text;
+    for (const pattern of thinkingPatterns) {
+      filtered = filtered.replace(pattern, '');
+    }
+
+    // Remove multiple consecutive newlines
+    filtered = filtered.replace(/\n{3,}/g, '\n\n');
+    return filtered.trim();
+  }
+
+  /**
+   * Get accumulated final response (filtered)
+   */
+  getFinalResponse() {
+    return this._filterThinkingPatterns(this.finalResponse);
+  }
+
+  /**
+   * Get raw unfiltered response (for debugging)
+   */
+  getRawResponse() {
+    return this.finalResponse;
+  }
+
+  /**
+   * Get usage statistics
+   */
+  getUsage() {
+    return this.usage;
+  }
+
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+
+  /**
+   * Get model name
+   */
+  getModel() {
+    return this.model;
+  }
+
+  /**
+   * Reset parser state for new request
+   */
+  reset() {
+    this.buffer = '';
+    this.finalResponse = '';
+    this.usage = null;
+    this.pendingTools.clear();
+    // Keep sessionId and model for session continuity
+  }
+}
+
+module.exports = GeminiOutputParser;