@mmmbuto/nexuscli 0.7.7 → 0.7.8

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

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

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

@@ -35,7 +35,7 @@ class CodexWrapper extends BaseCliWrapper {
    * @param {Function} options.onStatus - Callback for status events
    * @returns {Promise<Object>} Response with text, usage, threadId
    */
-  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus }) {
+  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus, processId: processIdOverride }) {
     return new Promise((resolve, reject) => {
       const parser = new CodexOutputParser();
       const cwd = workspacePath || this.workspaceDir;
@@ -93,8 +93,8 @@ class CodexWrapper extends BaseCliWrapper {
       });
 
       // Register process for interrupt capability
-      // Use threadId if available, otherwise generate temp ID
-      const processId = threadId || `codex-${Date.now()}`;
+      // Prefer external processId (Nexus sessionId), else threadId, else temp
+      const processId = processIdOverride || threadId || `codex-${Date.now()}`;
       this.registerProcess(processId, proc, 'spawn');
 
       proc.stdout.on('data', (data) => {

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

@@ -67,47 +67,66 @@ class ContextBridge {
 
     // 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(convoId);
-      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(convoId, 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,
@@ -118,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

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

@@ -80,7 +80,8 @@ class GeminiWrapper extends BaseCliWrapper {
     threadId,
     model = DEFAULT_MODEL,
     workspacePath,
-    onStatus
+    onStatus,
+    processId: processIdOverride
   }) {
     return new Promise((resolve, reject) => {
       const parser = new GeminiOutputParser();
@@ -127,8 +128,8 @@ class GeminiWrapper extends BaseCliWrapper {
       }
 
       // Register process for interrupt capability
-      // Use threadId if available, otherwise generate temp ID
-      const processId = threadId || `gemini-${Date.now()}`;
+      // Prefer external processId (Nexus sessionId), else threadId, else temp
+      const processId = processIdOverride || threadId || `gemini-${Date.now()}`;
       this.registerProcess(processId, ptyProcess, 'pty');
 
       let stdout = '';

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/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;
   }
 
   /**

package/lib/server/tests/performance.test.js

@@ -45,7 +45,7 @@ describe('Performance Benchmarks', () => {
 
   test('Workspace validation should be fast', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/var/www/myapp';
+    const testPath = '/home/user/myproject';
 
     const start = Date.now();
     const validated = await manager.validateWorkspace(testPath);

package/lib/server/tests/services.test.js

@@ -16,7 +16,7 @@ describe('WorkspaceManager', () => {
 
   test('should validate workspace path', async () => {
     // Test with allowed path
-    const validPath = '/var/www/myapp';
+    const validPath = '/home/user/myproject';
     const result = await manager.validateWorkspace(validPath);
     expect(result).toBe(validPath);
   });
@@ -147,7 +147,7 @@ describe('SummaryGenerator', () => {
 describe('Integration - Service Interactions', () => {
   test('WorkspaceManager should use consistent path resolution', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/var/www/myapp';
+    const testPath = '/home/user/myproject';
     const validated = await manager.validateWorkspace(testPath);
     expect(validated).toBe(testPath);
   });

package/package.json

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