@mmmbuto/nexuscli 0.7.6 → 0.7.7

package/lib/server/services/claude-wrapper.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const pty = require('../lib/pty-adapter');
 const OutputParser = require('./output-parser');
+const BaseCliWrapper = require('./base-cli-wrapper');
 const { getApiKey } = require('../db');
 
 /**
@@ -18,9 +19,12 @@ const { getApiKey } = require('../db');
  * - Parses stdout for tool use, thinking, file ops
  * - Emits status events → SSE stream
  * - Returns final response text → saved in DB
+ *
+ * @version 0.5.0 - Extended BaseCliWrapper for interrupt support
  */
-class ClaudeWrapper {
+class ClaudeWrapper extends BaseCliWrapper {
   constructor(options = {}) {
+    super();  // Initialize activeProcesses from BaseCliWrapper
     this.claudePath = this.resolveClaudePath(options.claudePath);
     this.workspaceDir = options.workspaceDir || process.env.NEXUSCLI_WORKSPACE || process.cwd();
   }
@@ -200,6 +204,9 @@ class ClaudeWrapper {
         return reject(new Error(msg));
       }
 
+      // Register process for interrupt capability
+      this.registerProcess(conversationId, ptyProcess, 'pty');
+
       let stdout = '';
 
       // Process output chunks
@@ -255,6 +262,9 @@ class ClaudeWrapper {
       }
 
       ptyProcess.onExit(({ exitCode }) => {
+        // Unregister process on exit
+        this.unregisterProcess(conversationId);
+
         console.log(`[ClaudeWrapper] Exit code: ${exitCode}`);
 
         if (exitCode !== 0) {

package/lib/server/services/cli-loader.js.backup

@@ -0,0 +1,446 @@
+/**
+ * CliLoader - Unified message loader for TRI CLI (Claude/Codex/Gemini)
+ *
+ * Loads messages on-demand from CLI history files (lazy loading).
+ * Filesystem is the source of truth - no DB caching of messages.
+ *
+ * Session file locations:
+ * - Claude: ~/.claude/projects/<workspace-slug>/<sessionId>.jsonl
+ * - Codex:  ~/.codex/sessions/<sessionId>.jsonl (if available)
+ * - Gemini: ~/.gemini/sessions/<sessionId>.jsonl (if available)
+ *
+ * @version 0.4.0 - TRI CLI Support
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const DEFAULT_LIMIT = 30;
+
+// Engine-specific paths
+const ENGINE_PATHS = {
+  claude: path.join(process.env.HOME || '', '.claude'),
+  codex: path.join(process.env.HOME || '', '.codex'),
+  gemini: path.join(process.env.HOME || '', '.gemini'),
+};
+
+class CliLoader {
+  constructor() {
+    this.claudePath = ENGINE_PATHS.claude;
+    this.codexPath = ENGINE_PATHS.codex;
+    this.geminiPath = ENGINE_PATHS.gemini;
+  }
+
+  /**
+   * Load messages from CLI history by session.
+   * Supports all three engines: Claude, Codex, Gemini.
+   *
+   * @param {Object} params
+   * @param {string} params.sessionId - Session UUID
+   * @param {string} params.engine - 'claude'|'claude-code'|'codex'|'gemini'
+   * @param {string} params.workspacePath - Workspace directory (required for Claude)
+   * @param {number} [params.limit=30] - Max messages to return
+   * @param {number} [params.before] - Timestamp cursor for pagination (ms)
+   * @param {string} [params.mode='asc'] - Return order ('asc'|'desc')
+   * @returns {Promise<{messages: Array, pagination: Object}>}
+   */
+  async loadMessagesFromCLI({
+    sessionId,
+    threadId,          // optional native thread id (e.g., Codex exec thread)
+    sessionPath,       // alias kept for compatibility
+    engine = 'claude',
+    workspacePath,
+    limit = DEFAULT_LIMIT,
+    before,
+    mode = 'asc'
+  }) {
+    if (!sessionId) {
+      throw new Error('sessionId is required');
+    }
+
+    const startedAt = Date.now();
+    const normalizedEngine = this._normalizeEngine(engine);
+    const nativeId = threadId || sessionPath || sessionId;
+
+    let result;
+    switch (normalizedEngine) {
+      case 'claude':
+        result = await this.loadClaudeMessages({ sessionId, workspacePath, limit, before, mode });
+        break;
+
+      case 'codex':
+        result = await this.loadCodexMessages({ sessionId, nativeId, limit, before, mode });
+        break;
+
+      case 'gemini':
+        result = await this.loadGeminiMessages({ sessionId, limit, before, mode });
+        break;
+
+      default:
+        throw new Error(`Unsupported engine: ${engine}`);
+    }
+
+    console.log(`[CliLoader] ${normalizedEngine} messages loaded in ${Date.now() - startedAt}ms (session ${sessionId}, ${result.messages.length} msgs)`);
+    return result;
+  }
+
+  /**
+   * Normalize engine name variants
+   */
+  _normalizeEngine(engine) {
+    if (!engine) return 'claude';
+    const lower = engine.toLowerCase();
+    if (lower.includes('claude')) return 'claude';
+    if (lower.includes('codex') || lower.includes('openai')) return 'codex';
+    if (lower.includes('gemini') || lower.includes('google')) return 'gemini';
+    return lower;
+  }
+
+  /**
+   * Convert workspace path to slug (for .claude/projects/ directory)
+   * Same as Claude Code behavior: /path/to/dir → -path-to-dir
+   * Also converts dots to dashes (e.g., com.termux → com-termux)
+   */
+  pathToSlug(workspacePath) {
+    if (!workspacePath) return '-default';
+    // Replace slashes AND dots with dashes (matches Claude Code behavior)
+    return workspacePath.replace(/[\/\.]/g, '-');
+  }
+
+  // ============================================================
+  // CLAUDE - Load from ~/.claude/projects/<slug>/<sessionId>.jsonl
+  // ============================================================
+
+  async loadClaudeMessages({ sessionId, workspacePath, limit, before, mode }) {
+    if (!workspacePath) {
+      console.warn('[CliLoader] No workspacePath for Claude, using cwd');
+      workspacePath = process.cwd();
+    }
+
+    const slug = this.pathToSlug(workspacePath);
+    const sessionFile = path.join(this.claudePath, 'projects', slug, `${sessionId}.jsonl`);
+
+    if (!fs.existsSync(sessionFile)) {
+      console.warn(`[CliLoader] Claude session file not found: ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Filter and normalize
+    const messages = rawMessages
+      .filter(entry => entry.type === 'user' || entry.type === 'assistant')
+      .map(entry => this._normalizeClaudeEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Claude Code session entry to message shape
+   */
+  _normalizeClaudeEntry(entry) {
+    // Extract content - handle both string and array of content blocks
+    let content = '';
+    const rawContent = entry.message?.content;
+
+    if (typeof rawContent === 'string') {
+      content = rawContent;
+    } else if (Array.isArray(rawContent)) {
+      // Claude Code uses array of content blocks: [{type: 'text', text: '...'}, ...]
+      content = rawContent
+        .filter(block => block.type === 'text' && block.text)
+        .map(block => block.text)
+        .join('\n');
+    } else if (entry.display || entry.text) {
+      // Fallback for older formats
+      content = entry.display || entry.text || '';
+    }
+
+    const role = entry.message?.role || entry.type || 'assistant';
+    const created_at = new Date(entry.timestamp).getTime() || Date.now();
+
+    return {
+      id: entry.message?.id || `claude-${created_at}`,
+      role,
+      content,
+      engine: 'claude',
+      created_at,
+      metadata: {
+        model: entry.message?.model,
+        stop_reason: entry.message?.stop_reason
+      }
+    };
+  }
+
+  // ============================================================
+  // CODEX - Load from ~/.codex/sessions/<sessionId>.jsonl
+  // ============================================================
+
+  async loadCodexMessages({ sessionId, nativeId, limit, before, mode }) {
+    const baseDir = path.join(this.codexPath, 'sessions');
+    let sessionFile = path.join(baseDir, `${nativeId || sessionId}.jsonl`);
+
+    // If flat file missing, search nested rollout-* files by threadId
+    if (!fs.existsSync(sessionFile)) {
+      sessionFile = this.findCodexSessionFile(baseDir, nativeId || sessionId);
+    }
+
+    // Codex exec may not persist sessions; handle gracefully
+    if (!sessionFile || !fs.existsSync(sessionFile)) {
+      console.log(`[CliLoader] Codex session file not found (id=${nativeId || sessionId})`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Normalize then filter only chat messages
+    const messages = rawMessages
+      .map(entry => this._normalizeCodexEntry(entry))
+      .filter(msg => msg && (msg.role === 'user' || msg.role === 'assistant'));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Codex session entry to message shape
+   */
+  _normalizeCodexEntry(entry) {
+    // Skip non-chat bookkeeping events
+    const skipTypes = ['session_meta', 'turn_context', 'event_msg', 'token_count'];
+    if (skipTypes.includes(entry.type)) return null;
+
+    const role =
+      entry.role ||
+      entry.payload?.role ||
+      (entry.payload?.type === 'message' ? entry.payload.role : null) ||
+      entry.message?.role ||
+      'assistant';
+
+    const created_at = entry.timestamp
+      ? new Date(entry.timestamp).getTime()
+      : (entry.payload?.timestamp ? new Date(entry.payload.timestamp).getTime() : Date.now());
+
+    // Codex may store content in multiple shapes
+    let content = '';
+    if (typeof entry.content === 'string') {
+      content = entry.content;
+    } else if (typeof entry.payload?.content === 'string') {
+      content = entry.payload.content;
+    } else if (Array.isArray(entry.payload?.content)) {
+      content = entry.payload.content
+        .map(block => block.text || block.message || block.title || '')
+        .filter(Boolean)
+        .join('\n');
+    } else if (entry.payload?.text) {
+      content = entry.payload.text;
+    } else if (entry.message) {
+      content = typeof entry.message === 'string' ? entry.message : JSON.stringify(entry.message);
+    }
+
+    return {
+      id: entry.id || `codex-${created_at}`,
+      role,
+      content,
+      engine: 'codex',
+      created_at,
+      metadata: {
+        model: entry.model,
+        reasoning_effort: entry.reasoning_effort
+      }
+    };
+  }
+
+  /**
+   * Find Codex rollout file by threadId within YYYY/MM/DD directories
+   */
+  findCodexSessionFile(baseDir, threadId) {
+    if (!threadId || !fs.existsSync(baseDir)) return null;
+    try {
+      const years = fs.readdirSync(baseDir);
+      for (const year of years) {
+        const yearPath = path.join(baseDir, year);
+        if (!fs.statSync(yearPath).isDirectory()) continue;
+        const months = fs.readdirSync(yearPath);
+        for (const month of months) {
+          const monthPath = path.join(yearPath, month);
+          if (!fs.statSync(monthPath).isDirectory()) continue;
+          const days = fs.readdirSync(monthPath);
+          for (const day of days) {
+            const dayPath = path.join(monthPath, day);
+            if (!fs.statSync(dayPath).isDirectory()) continue;
+            const files = fs.readdirSync(dayPath);
+            for (const file of files) {
+              if (file.endsWith('.jsonl') && file.includes(threadId)) {
+                return path.join(dayPath, file);
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`[CliLoader] Failed to search Codex session file: ${err.message}`);
+    }
+    return null;
+  }
+
+  // ============================================================
+  // GEMINI - Load from ~/.gemini/sessions/<sessionId>.jsonl
+  // ============================================================
+
+  async loadGeminiMessages({ sessionId, limit, before, mode }) {
+    const sessionFile = path.join(this.geminiPath, 'sessions', `${sessionId}.jsonl`);
+
+    // Gemini CLI may not save sessions - check if file exists
+    if (!fs.existsSync(sessionFile)) {
+      console.log(`[CliLoader] Gemini session file not found: ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Filter and normalize
+    const messages = rawMessages
+      .filter(entry => entry.role === 'user' || entry.role === 'model' || entry.role === 'assistant')
+      .map(entry => this._normalizeGeminiEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Gemini session entry to message shape
+   */
+  _normalizeGeminiEntry(entry) {
+    // Gemini uses 'model' instead of 'assistant'
+    const role = entry.role === 'model' ? 'assistant' : (entry.role || 'assistant');
+    const created_at = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+
+    // Gemini content format
+    let content = '';
+    if (typeof entry.content === 'string') {
+      content = entry.content;
+    } else if (Array.isArray(entry.parts)) {
+      // Gemini uses parts array: [{text: '...'}]
+      content = entry.parts
+        .filter(p => p.text)
+        .map(p => p.text)
+        .join('\n');
+    } else if (entry.text) {
+      content = entry.text;
+    }
+
+    return {
+      id: entry.id || `gemini-${created_at}`,
+      role,
+      content,
+      engine: 'gemini',
+      created_at,
+      metadata: {
+        model: entry.model
+      }
+    };
+  }
+
+  // ============================================================
+  // UTILITY METHODS
+  // ============================================================
+
+  /**
+   * Parse JSONL file line by line (memory efficient)
+   */
+  async _parseJsonlFile(filePath) {
+    const entries = [];
+
+    const fileStream = fs.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
+      } catch (e) {
+        // Skip malformed lines
+        console.warn(`[CliLoader] Skipping malformed JSON line in ${filePath}`);
+      }
+    }
+
+    return entries;
+  }
+
+  /**
+   * Apply pagination to messages array
+   */
+  _paginateMessages(messages, limit, before, mode) {
+    // Filter by timestamp if 'before' cursor provided
+    let filtered = messages;
+    if (before) {
+      filtered = messages.filter(m => m.created_at < Number(before));
+    }
+
+    // Sort newest first for pagination slicing
+    filtered.sort((a, b) => b.created_at - a.created_at);
+
+    // Apply limit
+    const page = filtered.slice(0, limit);
+    const hasMore = filtered.length > limit;
+    const oldestTimestamp = page.length ? page[page.length - 1].created_at : null;
+
+    // Return in requested order (default asc for UI rendering)
+    const ordered = mode === 'desc'
+      ? page
+      : [...page].sort((a, b) => a.created_at - b.created_at);
+
+    return {
+      messages: ordered,
+      pagination: {
+        hasMore,
+        oldestTimestamp,
+        total: messages.length
+      }
+    };
+  }
+
+  /**
+   * Return empty result structure
+   */
+  _emptyResult() {
+    return {
+      messages: [],
+      pagination: {
+        hasMore: false,
+        oldestTimestamp: null,
+        total: 0
+      }
+    };
+  }
+
+  /**
+   * Get session file path for an engine
+   * Useful for external checks
+   */
+  getSessionFilePath(sessionId, engine, workspacePath) {
+    const normalizedEngine = this._normalizeEngine(engine);
+
+    switch (normalizedEngine) {
+      case 'claude':
+        const slug = this.pathToSlug(workspacePath);
+        return path.join(this.claudePath, 'projects', slug, `${sessionId}.jsonl`);
+
+      case 'codex':
+        return path.join(this.codexPath, 'sessions', `${sessionId}.jsonl`);
+
+      case 'gemini':
+        return path.join(this.geminiPath, 'sessions', `${sessionId}.jsonl`);
+
+      default:
+        return null;
+    }
+  }
+}
+
+module.exports = CliLoader;

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

@@ -263,6 +263,13 @@ class CodexOutputParser {
     return this.usage;
   }
 
+  /**
+   * Get thread ID (native Codex session ID)
+   */
+  getThreadId() {
+    return this.threadId;
+  }
+
   /**
    * Reset parser state for new request
    */
@@ -270,6 +277,7 @@ class CodexOutputParser {
     this.buffer = '';
     this.finalResponse = '';
     this.usage = null;
+    this.threadId = null;
     this.pendingCommands.clear();
   }
 }

package/lib/server/services/codex-wrapper.js

@@ -4,19 +4,20 @@
  *
  * Based on NexusChat codex-cli-wrapper.js pattern
  * Requires: codex-cli 0.62.1+ with exec subcommand
+ *
+ * @version 0.5.0 - Extended BaseCliWrapper for interrupt support
  */
 
 const { spawn, exec } = require('child_process');
 const CodexOutputParser = require('./codex-output-parser');
+const BaseCliWrapper = require('./base-cli-wrapper');
 
-class CodexWrapper {
+class CodexWrapper extends BaseCliWrapper {
   constructor(options = {}) {
+    super();  // Initialize activeProcesses from BaseCliWrapper
     this.workspaceDir = options.workspaceDir || process.cwd();
     this.codexBin = options.codexBin || 'codex';
 
-    // Track active sessions
-    this.activeSessions = new Set();
-
     console.log('[CodexWrapper] Initialized');
     console.log('[CodexWrapper] Workspace:', this.workspaceDir);
     console.log('[CodexWrapper] Binary:', this.codexBin);
@@ -91,6 +92,11 @@ class CodexWrapper {
         },
       });
 
+      // Register process for interrupt capability
+      // Use threadId if available, otherwise generate temp ID
+      const processId = threadId || `codex-${Date.now()}`;
+      this.registerProcess(processId, proc, 'spawn');
+
       proc.stdout.on('data', (data) => {
         const str = data.toString();
         stdout += str;
@@ -102,6 +108,9 @@ class CodexWrapper {
       });
 
       proc.on('close', (exitCode) => {
+        // Unregister process on exit
+        this.unregisterProcess(processId);
+
         clearTimeout(timeout);
         this.handleExit(exitCode, stdout, parser, prompt, resolve, reject);
       });

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

@@ -53,15 +53,17 @@ class ContextBridge {
   /**
    * Build optimized context for engine switch
    * @param {Object} params
-   * @param {string} params.sessionId - Session ID
+   * @param {string} params.conversationId - Stable conversation ID (cross-engine)
+   * @param {string} params.sessionId - Legacy session ID (fallback)
    * @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 }) {
+  async buildContext({ conversationId, sessionId, fromEngine, toEngine, userMessage }) {
     const config = this.getEngineConfig(toEngine);
     const isEngineBridge = fromEngine && fromEngine !== toEngine;
+    const convoId = conversationId || sessionId; // backward compat
 
     // Reserve tokens for user message
     const userTokens = this.estimateTokens(userMessage);
@@ -73,7 +75,7 @@ class ContextBridge {
 
     // Try summary first (most efficient)
     if (config.preferSummary) {
-      const summaryContext = this.summaryGenerator.getBridgeContext(sessionId);
+      const summaryContext = this.summaryGenerator.getBridgeContext(convoId);
       if (summaryContext) {
         const summaryTokens = this.estimateTokens(summaryContext);
         if (summaryTokens <= availableTokens) {
@@ -86,7 +88,7 @@ class ContextBridge {
 
     // Fallback to token-aware message history
     if (!contextText && availableTokens > 200) {
-      const historyContext = this.buildTokenAwareHistory(sessionId, availableTokens, config);
+      const historyContext = this.buildTokenAwareHistory(convoId, availableTokens, config);
       if (historyContext.text) {
         contextText = historyContext.text;
         contextTokens = historyContext.tokens;
@@ -123,9 +125,9 @@ class ContextBridge {
    * @param {Object} config - Engine config
    * @returns {Object} { text, tokens, messageCount }
    */
-  buildTokenAwareHistory(sessionId, maxTokens, config = {}) {
+  buildTokenAwareHistory(conversationId, maxTokens, config = {}) {
     // Get more messages than we need, we'll trim
-    const messages = Message.getContextMessages(sessionId, 20);
+    const messages = Message.getContextMessages(conversationId, 20);
 
     if (messages.length === 0) {
       return { text: '', tokens: 0, messageCount: 0 };
@@ -139,11 +141,13 @@ class ContextBridge {
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i];
 
-      // For code-focused engines, filter out non-code content
+      // For code-focused engines, compress assistant responses to code only
+      // BUT always keep user messages for context continuity
       let content = msg.content;
-      if (config.codeOnly) {
-        content = this.extractCodeContent(content);
-        if (!content) continue; // Skip if no code
+      if (config.codeOnly && msg.role === 'assistant') {
+        const codeContent = this.extractCodeContent(content);
+        // Only use code-only if there's actual code, otherwise keep truncated original
+        content = codeContent || (content.length > 500 ? content.substring(0, 500) + '...' : content);
       }
 
       // Truncate long messages
@@ -228,11 +232,11 @@ class ContextBridge {
    * @param {boolean} isEngineBridge - Was this an engine switch
    * @returns {boolean} Should generate summary
    */
-  shouldTriggerSummary(sessionId, isEngineBridge = false) {
+  shouldTriggerSummary(conversationId, isEngineBridge = false) {
     // Always trigger on engine bridge
     if (isEngineBridge) return true;
 
-    const messageCount = Message.countByConversation(sessionId);
+    const messageCount = Message.countByConversation(conversationId);
 
     // Trigger every 10 messages after threshold
     if (messageCount >= SUMMARY_TRIGGER_THRESHOLD && messageCount % 10 === 0) {
@@ -240,7 +244,7 @@ class ContextBridge {
     }
 
     // Check if we have a stale summary (older than 20 messages)
-    const existingSummary = this.summaryGenerator.getSummary(sessionId);
+    const existingSummary = this.summaryGenerator.getSummary(conversationId);
     if (!existingSummary && messageCount > SUMMARY_TRIGGER_THRESHOLD) {
       return true;
     }
@@ -253,10 +257,10 @@ class ContextBridge {
    * @param {string} sessionId - Session ID
    * @param {string} logPrefix - Log prefix for debugging
    */
-  triggerSummaryGeneration(sessionId, logPrefix = '[ContextBridge]') {
-    const messages = Message.getByConversation(sessionId, 40);
+  triggerSummaryGeneration(conversationId, logPrefix = '[ContextBridge]') {
+    const messages = Message.getByConversation(conversationId, 40);
 
-    this.summaryGenerator.generateAndSave(sessionId, messages)
+    this.summaryGenerator.generateAndSave(conversationId, messages)
       .then(summary => {
         if (summary) {
           console.log(`${logPrefix} Summary updated: ${summary.summary_short?.substring(0, 50)}...`);
@@ -272,10 +276,10 @@ class ContextBridge {
    * @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);
+  getContextStats(conversationId) {
+    const messageCount = Message.countByConversation(conversationId);
+    const lastEngine = Message.getLastEngine(conversationId);
+    const hasSummary = !!this.summaryGenerator.getSummary(conversationId);
 
     return {
       messageCount,