@mmmbuto/nexuscli 0.7.6 → 0.7.8

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

@@ -53,59 +53,80 @@ 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);
-    const availableTokens = config.maxTokens - userTokens - 200; // 200 token buffer
+    const availableTokens = Math.max(0, config.maxTokens - userTokens - 200); // 200 token buffer, never negative
 
     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';
+    // For engine bridge, use structured handoff template
+    if (isEngineBridge) {
+      const handoffContext = this.buildEngineHandoffContext(convoId, fromEngine, toEngine, availableTokens, config);
+      if (handoffContext.text) {
+        contextText = handoffContext.text;
+        contextTokens = handoffContext.tokens;
+        contextSource = handoffContext.source;
+      }
+      // If handoff couldn't fit, fall back to history-only context
+      if (!contextText && availableTokens > 200) {
+        const historyContext = this.buildTokenAwareHistory(convoId, availableTokens, config);
+        if (historyContext.text) {
+          contextText = historyContext.text;
+          contextTokens = historyContext.tokens;
+          contextSource = 'history_fallback';
+        }
+      }
+    } else {
+      // Try summary first (most efficient)
+      if (config.preferSummary) {
+        const summaryContext = this.summaryGenerator.getBridgeContext(convoId);
+        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';
+      // Fallback to token-aware message history
+      if (!contextText && availableTokens > 200) {
+        const historyContext = this.buildTokenAwareHistory(convoId, availableTokens, config);
+        if (historyContext.text) {
+          contextText = historyContext.text;
+          contextTokens = historyContext.tokens;
+          contextSource = 'history';
+        }
       }
     }
 
     // Build final prompt
     let prompt = userMessage;
 
+    if (availableTokens === 0) {
+      console.log(`[ContextBridge] Budget exhausted before context; sending raw message (engine=${toEngine})`);
+    }
+
     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}`;
-      }
+      prompt = `${contextText}\n\n${userMessage}`;
     }
 
-    console.log(`[ContextBridge] Built context: ${contextTokens} tokens from ${contextSource}, bridge: ${isEngineBridge}`);
+    console.log(`[ContextBridge] Built context: ${contextTokens} tokens from ${contextSource}, bridge: ${isEngineBridge}, avail=${availableTokens}, total=${contextTokens + userTokens}`);
 
     return {
       prompt,
@@ -116,6 +137,106 @@ class ContextBridge {
     };
   }
 
+  /**
+   * Build structured context for engine handoff
+   * Uses a clear template that helps the new engine understand previous context
+   * @param {string} conversationId
+   * @param {string} fromEngine
+   * @param {string} toEngine
+   * @param {number} maxTokens
+   * @param {Object} config
+   * @returns {Object} { text, tokens, source }
+   */
+  buildEngineHandoffContext(conversationId, fromEngine, toEngine, maxTokens, config = {}) {
+    const engineNames = {
+      'claude': 'Claude Code (Anthropic)',
+      'codex': 'Codex (OpenAI)',
+      'gemini': 'Gemini (Google)',
+      'deepseek': 'DeepSeek'
+    };
+
+    const fromName = engineNames[fromEngine] || fromEngine;
+    const toName = engineNames[toEngine] || toEngine;
+
+    // Get summary if available
+    const summary = this.summaryGenerator.getSummary(conversationId);
+
+    // Get recent messages (last 5)
+    const messages = Message.getContextMessages(conversationId, 5);
+    const messageCount = Message.countByConversation(conversationId);
+
+    // Build structured template
+    const sections = [];
+
+    // Header
+    sections.push(`<previous_session_context engine="${fromEngine}" total_messages="${messageCount}">`);
+    sections.push(`This conversation was previously handled by ${fromName}.`);
+    sections.push(`You are now continuing as ${toName}.`);
+    sections.push('');
+
+    // Summary section (if available)
+    if (summary && summary.summary_short) {
+      sections.push('## Summary');
+      sections.push(summary.summary_short);
+      sections.push('');
+
+      // Key decisions
+      if (summary.key_decisions && summary.key_decisions.length > 0) {
+        sections.push('## Key Decisions');
+        summary.key_decisions.slice(0, 5).forEach(d => sections.push(`- ${d}`));
+        sections.push('');
+      }
+
+      // Files modified
+      if (summary.files_modified && summary.files_modified.length > 0) {
+        sections.push('## Files Modified');
+        summary.files_modified.slice(0, 10).forEach(f => sections.push(`- ${f}`));
+        sections.push('');
+      }
+    }
+
+    // Recent messages (always include for continuity)
+    if (messages.length > 0) {
+      sections.push('## Recent Messages');
+      for (const msg of messages) {
+        const role = msg.role === 'user' ? 'User' : 'Assistant';
+        const engine = msg.engine ? ` [${msg.engine}]` : '';
+        // Truncate long messages
+        let content = msg.content || '';
+        if (content.length > 500) {
+          content = content.substring(0, 500) + '...';
+        }
+        sections.push(`${role}${engine}: ${content}`);
+        sections.push('');
+      }
+    }
+
+    sections.push('</previous_session_context>');
+    sections.push('');
+    sections.push('Continue assisting with the following request:');
+
+    const text = sections.join('\n');
+    const tokens = this.estimateTokens(text);
+
+    // Check token budget
+    if (tokens > maxTokens) {
+      // Fallback to simpler context if too long
+      console.log(`[ContextBridge] Handoff template too long (${tokens} > ${maxTokens}), using fallback`);
+      const fallback = this.buildTokenAwareHistory(conversationId, maxTokens, config);
+      return {
+        text: fallback.text,
+        tokens: fallback.tokens,
+        source: 'handoff_fallback_history'
+      };
+    }
+
+    return {
+      text,
+      tokens,
+      source: summary ? 'handoff+summary' : 'handoff+history'
+    };
+  }
+
   /**
    * Build token-aware history context
    * @param {string} sessionId - Session ID
@@ -123,9 +244,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 +260,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 +351,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 +363,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 +376,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 +395,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,

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

@@ -10,13 +10,14 @@
  * - -o stream-json: JSON streaming output
  * - --include-directories: Workspace access
  *
- * @version 0.4.0 - TRI CLI Support
+ * @version 0.5.0 - Extended BaseCliWrapper for interrupt support
  */
 
 const fs = require('fs');
 const path = require('path');
 const pty = require('../lib/pty-adapter');
 const GeminiOutputParser = require('./gemini-output-parser');
+const BaseCliWrapper = require('./base-cli-wrapper');
 
 // Default model - Gemini 3 Pro Preview
 const DEFAULT_MODEL = 'gemini-3-pro-preview';
@@ -24,8 +25,9 @@ const DEFAULT_MODEL = 'gemini-3-pro-preview';
 // CLI timeout (10 minutes)
 const CLI_TIMEOUT_MS = 600000;
 
-class GeminiWrapper {
+class GeminiWrapper extends BaseCliWrapper {
   constructor(options = {}) {
+    super();  // Initialize activeProcesses from BaseCliWrapper
     this.geminiPath = this._resolveGeminiPath(options.geminiPath);
     this.workspaceDir = options.workspaceDir || process.cwd();
 
@@ -67,18 +69,19 @@ class GeminiWrapper {
    *
    * @param {Object} params
    * @param {string} params.prompt - User message/prompt
-   * @param {string} params.sessionId - Session UUID (for logging)
+   * @param {string} params.threadId - Native Gemini session ID for resume
    * @param {string} [params.model='gemini-3-pro-preview'] - Model name
    * @param {string} [params.workspacePath] - Workspace directory
    * @param {Function} [params.onStatus] - Callback for status events (SSE streaming)
-   * @returns {Promise<{text: string, usage: Object}>}
+   * @returns {Promise<{text: string, usage: Object, sessionId: string}>}
    */
   async sendMessage({
     prompt,
-    sessionId,
+    threadId,
     model = DEFAULT_MODEL,
     workspacePath,
-    onStatus
+    onStatus,
+    processId: processIdOverride
   }) {
     return new Promise((resolve, reject) => {
       const parser = new GeminiOutputParser();
@@ -87,16 +90,23 @@ class GeminiWrapper {
       const cwd = workspacePath || this.workspaceDir;
 
       // Build CLI arguments
-      // Note: cwd is set in pty.spawn() options, no need for --include-directories
+      // If threadId exists, use --resume to continue native session
       const args = [
         '-y',                              // YOLO mode - auto-approve all actions
         '-m', model,                       // Model selection
         '-o', 'stream-json',               // JSON streaming for structured events
-        prompt                             // Prompt as positional argument
       ];
 
+      // Add resume flag if continuing existing session
+      if (threadId) {
+        args.push('--resume', threadId);
+      }
+
+      // Add prompt as positional argument
+      args.push(prompt);
+
       console.log(`[GeminiWrapper] Model: ${model}`);
-      console.log(`[GeminiWrapper] Session: ${sessionId}`);
+      console.log(`[GeminiWrapper] ThreadId: ${threadId || '(new session)'}`);
       console.log(`[GeminiWrapper] CWD: ${cwd}`);
       console.log(`[GeminiWrapper] Prompt length: ${prompt.length}`);
 
@@ -117,6 +127,11 @@ class GeminiWrapper {
         return reject(new Error(`Failed to spawn Gemini CLI: ${spawnError.message}`));
       }
 
+      // Register process for interrupt capability
+      // Prefer external processId (Nexus sessionId), else threadId, else temp
+      const processId = processIdOverride || threadId || `gemini-${Date.now()}`;
+      this.registerProcess(processId, ptyProcess, 'pty');
+
       let stdout = '';
 
       // Handle PTY data
@@ -145,6 +160,9 @@ class GeminiWrapper {
 
       // Handle PTY exit
       ptyProcess.onExit(({ exitCode }) => {
+        // Unregister process on exit
+        this.unregisterProcess(processId);
+
         if (promiseSettled) return;
         promiseSettled = true;
 
@@ -170,6 +188,7 @@ class GeminiWrapper {
 
         resolve({
           text: finalResponse,
+          sessionId: parser.getSessionId(), // Native Gemini session ID for resume
           usage: {
             prompt_tokens: promptTokens,
             completion_tokens: completionTokens,

package/lib/server/services/session-importer.js

@@ -0,0 +1,155 @@
+/**
+ * SessionImporter - Importa sessioni CLI native in tabella sessions (indice NexusCLI)
+ *
+ * Scansione:
+ *  - Claude: ~/.claude/projects/<slug>/<sessionId>.jsonl
+ *  - Codex : ~/.codex/sessions/<sessionId>.jsonl
+ *  - Gemini: ~/.gemini/sessions/<sessionId>.jsonl
+ *
+ * Note:
+ *  - Usa FILESYSTEM come source of truth: non legge contenuti, solo metadati.
+ *  - workspace_path stimato da slug (best effort, non reversibile al 100%).
+ *  - Non sovrascrive entry esistenti in DB.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { prepare, saveDb } = require('../db');
+
+const HOME = process.env.HOME || '';
+
+const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
+const CODEX_SESSIONS = path.join(HOME, '.codex', 'sessions');
+const GEMINI_SESSIONS = path.join(HOME, '.gemini', 'sessions');
+
+class SessionImporter {
+  constructor() {}
+
+  /**
+   * Importa tutte le sessioni per tutti gli engine
+   * @returns {{claude:number, codex:number, gemini:number}}
+   */
+  importAll() {
+    const claude = this.importClaudeSessions();
+    const codex = this.importCodexSessions();
+    const gemini = this.importGeminiSessions();
+    return { claude, codex, gemini };
+  }
+
+  /**
+   * Claude: ~/.claude/projects/<slug>/<sessionId>.jsonl
+   */
+  importClaudeSessions() {
+    let imported = 0;
+    if (!fs.existsSync(CLAUDE_PROJECTS)) return imported;
+
+    const projectSlugs = fs.readdirSync(CLAUDE_PROJECTS);
+    for (const slug of projectSlugs) {
+      const projectDir = path.join(CLAUDE_PROJECTS, slug);
+      if (!fs.statSync(projectDir).isDirectory()) continue;
+
+      const files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
+      for (const file of files) {
+        const sessionId = file.replace('.jsonl', '');
+        if (this.sessionExists(sessionId)) continue;
+
+        const workspacePath = this.slugToPath(slug);
+        this.insertSession(sessionId, 'claude', workspacePath, null);
+        imported++;
+      }
+    }
+
+    if (imported > 0) saveDb();
+    console.log(`[SessionImporter] Claude imported: ${imported}`);
+    return imported;
+  }
+
+  /**
+   * Codex: ~/.codex/sessions/<sessionId>.jsonl
+   */
+  importCodexSessions() {
+    let imported = 0;
+    if (!fs.existsSync(CODEX_SESSIONS)) return imported;
+
+    const files = fs.readdirSync(CODEX_SESSIONS)
+      .filter(f => f.endsWith('.jsonl') || f.endsWith('.json'));
+    for (const file of files) {
+      const sessionId = file.replace('.jsonl', '');
+      if (this.sessionExists(sessionId)) continue;
+
+      this.insertSession(sessionId, 'codex', '', null);
+      imported++;
+    }
+
+    if (imported > 0) saveDb();
+    console.log(`[SessionImporter] Codex imported: ${imported}`);
+    return imported;
+  }
+
+  /**
+   * Gemini: ~/.gemini/sessions/<sessionId>.jsonl
+   */
+  importGeminiSessions() {
+    let imported = 0;
+    if (!fs.existsSync(GEMINI_SESSIONS)) return imported;
+
+    const files = fs.readdirSync(GEMINI_SESSIONS)
+      .filter(f => f.endsWith('.jsonl') || f.endsWith('.json'));
+    for (const file of files) {
+      const sessionId = file.replace('.jsonl', '');
+      if (this.sessionExists(sessionId)) continue;
+
+      this.insertSession(sessionId, 'gemini', '', null);
+      imported++;
+    }
+
+    if (imported > 0) saveDb();
+    console.log(`[SessionImporter] Gemini imported: ${imported}`);
+    return imported;
+  }
+
+  /**
+   * Inserisce riga minima in sessions
+   */
+  insertSession(id, engine, workspacePath, conversationId) {
+    try {
+      const now = Date.now();
+      const stmt = prepare(`
+        INSERT INTO sessions (id, engine, workspace_path, conversation_id, title, created_at, last_used_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(id, engine, workspacePath || '', conversationId || null, 'Imported Chat', now, now);
+    } catch (err) {
+      console.warn(`[SessionImporter] insert failed for ${id}: ${err.message}`);
+    }
+  }
+
+  /**
+   * Controlla se la sessione esiste già
+   */
+  sessionExists(sessionId) {
+    try {
+      const stmt = prepare('SELECT 1 FROM sessions WHERE id = ?');
+      return !!stmt.get(sessionId);
+    } catch (err) {
+      console.warn(`[SessionImporter] exists check failed: ${err.message}`);
+      return true; // default to skip to avoid duplicates
+    }
+  }
+
+  /**
+   * Best-effort reverse di slug Claude in path
+   * -path-to-dir → /path/to/dir
+   * Conserva i punti.
+   */
+  slugToPath(slug) {
+    if (!slug) return '';
+    // Claude slug era workspacePath.replace(/\//g, '-'); mantiene i punti
+    // Invertiamo: leading '-' → '/', i restanti '-' → '/'
+    let tmp = slug;
+    if (tmp.startsWith('-')) tmp = '/' + tmp.slice(1);
+    return tmp.replace(/-/g, '/');
+  }
+}
+
+module.exports = new SessionImporter();

package/lib/server/services/session-manager.js

@@ -442,6 +442,26 @@ class SessionManager {
     }
   }
 
+  /**
+   * Bump session activity counters (message_count, last_used_at)
+   * @param {string} sessionId
+   * @param {number} increment
+   */
+  bumpSessionActivity(sessionId, increment = 1) {
+    if (!sessionId) return;
+    try {
+      const stmt = prepare(`
+        UPDATE sessions
+        SET message_count = COALESCE(message_count, 0) + ?, last_used_at = ?
+        WHERE id = ?
+      `);
+      stmt.run(increment, Date.now(), sessionId);
+      saveDb();
+    } catch (error) {
+      console.warn(`[SessionManager] Failed to bump activity for ${sessionId}:`, error.message);
+    }
+  }
+
   /**
    * Get all sessions for a conversation
    */

package/lib/server/services/workspace-manager.js

@@ -328,13 +328,8 @@ class WorkspaceManager {
     // Sort by most recent first
     sessions.sort((a, b) => b.last_used_at - a.last_used_at);
 
-    // Limit to most recent 10 sessions (lazy load the rest)
-    const limit = 10;
-    const totalSessions = sessions.length;
-    const limitedSessions = sessions.slice(0, limit);
-
-    console.log(`[WorkspaceManager] Loaded ${limitedSessions.length} of ${totalSessions} sessions (sorted by recency)`);
-    return limitedSessions;
+    console.log(`[WorkspaceManager] Loaded ${sessions.length} sessions (sorted by recency)`);
+    return sessions;
   }
 
   /**
@@ -396,7 +391,7 @@ class WorkspaceManager {
    * @returns {string}
    */
   getSessionPath(workspacePath) {
-    // Convert /home/user/myproject → -home-user-myproject
+    // Convert /var/www/myapp → -var-www-myapp
     const projectDir = workspacePath.replace(/\//g, '-').replace(/^-/, '');
     return path.join(this.claudePath, 'projects', projectDir);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini)",
   "main": "lib/server/server.js",
   "bin": {