@mmmbuto/nexuscli 0.5.0

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

@@ -0,0 +1,249 @@
+/**
+ * GeminiWrapper - Wrapper for Gemini CLI (gemini command)
+ *
+ * Executes Gemini CLI with node-pty for real PTY support.
+ * Uses JSON streaming output for structured event parsing.
+ *
+ * CLI Arguments:
+ * - -y: YOLO mode (auto-approve all actions)
+ * - -m <model>: Model selection (gemini-3-pro-preview, etc.)
+ * - -o stream-json: JSON streaming output
+ * - --include-directories: Workspace access
+ *
+ * @version 0.4.0 - TRI CLI Support
+ */
+
+const fs = require('fs');
+const path = require('path');
+const pty = require('../lib/pty-adapter');
+const GeminiOutputParser = require('./gemini-output-parser');
+
+// Default model - Gemini 3 Pro Preview
+const DEFAULT_MODEL = 'gemini-3-pro-preview';
+
+// CLI timeout (10 minutes)
+const CLI_TIMEOUT_MS = 600000;
+
+class GeminiWrapper {
+  constructor(options = {}) {
+    this.geminiPath = this._resolveGeminiPath(options.geminiPath);
+    this.workspaceDir = options.workspaceDir || process.cwd();
+
+    console.log(`[GeminiWrapper] Initialized with binary: ${this.geminiPath}`);
+  }
+
+  /**
+   * Resolve path to gemini CLI binary
+   */
+  _resolveGeminiPath(overridePath) {
+    if (overridePath && fs.existsSync(overridePath)) {
+      return overridePath;
+    }
+
+    // Common installation paths
+    const candidates = [
+      path.join(process.env.HOME || '', '.local/bin/gemini'),
+      path.join(process.env.PREFIX || '', 'bin/gemini'),
+      '/usr/local/bin/gemini',
+      '/usr/bin/gemini',
+      'gemini', // Fallback to PATH lookup
+    ];
+
+    for (const candidate of candidates) {
+      try {
+        if (candidate === 'gemini' || fs.existsSync(candidate)) {
+          return candidate;
+        }
+      } catch (_) {
+        // Skip invalid paths
+      }
+    }
+
+    return 'gemini'; // Assume in PATH
+  }
+
+  /**
+   * Send a message to Gemini CLI
+   *
+   * @param {Object} params
+   * @param {string} params.prompt - User message/prompt
+   * @param {string} params.sessionId - Session UUID (for logging)
+   * @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}>}
+   */
+  async sendMessage({
+    prompt,
+    sessionId,
+    model = DEFAULT_MODEL,
+    workspacePath,
+    onStatus
+  }) {
+    return new Promise((resolve, reject) => {
+      const parser = new GeminiOutputParser();
+      let promiseSettled = false;
+
+      const cwd = workspacePath || this.workspaceDir;
+
+      // Build CLI arguments
+      // Note: cwd is set in pty.spawn() options, no need for --include-directories
+      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
+      ];
+
+      console.log(`[GeminiWrapper] Model: ${model}`);
+      console.log(`[GeminiWrapper] Session: ${sessionId}`);
+      console.log(`[GeminiWrapper] CWD: ${cwd}`);
+      console.log(`[GeminiWrapper] Prompt length: ${prompt.length}`);
+
+      // Spawn Gemini CLI with PTY
+      let ptyProcess;
+      try {
+        ptyProcess = pty.spawn(this.geminiPath, args, {
+          name: 'xterm-color',
+          cols: 120,
+          rows: 40,
+          cwd: cwd,
+          env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+          }
+        });
+      } catch (spawnError) {
+        return reject(new Error(`Failed to spawn Gemini CLI: ${spawnError.message}`));
+      }
+
+      let stdout = '';
+
+      // Handle PTY data
+      ptyProcess.onData((data) => {
+        stdout += data;
+
+        // Clean ANSI escape codes before parsing
+        const cleanData = data
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')  // Standard ANSI codes
+          .replace(/\x1B\[\?[0-9;]*[a-zA-Z]/g, '') // Private modes
+          .replace(/\r/g, '');                     // Carriage returns
+
+        // Parse and emit events
+        if (onStatus && cleanData.trim()) {
+          try {
+            const events = parser.parse(cleanData);
+            events.forEach(event => {
+              console.log(`[GeminiWrapper] Event: ${event.type}`, event.message || event.text?.substring(0, 50) || '');
+              onStatus(event);
+            });
+          } catch (parseError) {
+            console.error('[GeminiWrapper] Parser error:', parseError.message);
+          }
+        }
+      });
+
+      // Handle PTY exit
+      ptyProcess.onExit(({ exitCode }) => {
+        if (promiseSettled) return;
+        promiseSettled = true;
+
+        console.log(`[GeminiWrapper] Exit code: ${exitCode}`);
+
+        // Non-zero exit is an error (except null which is normal)
+        if (exitCode !== 0 && exitCode !== null) {
+          console.error('[GeminiWrapper] Error output:', stdout.substring(0, 500));
+          reject(new Error(`Gemini CLI error (exit ${exitCode}): ${stdout.substring(0, 200)}`));
+          return;
+        }
+
+        // Get final response and usage from parser
+        const finalResponse = parser.getFinalResponse();
+        const usage = parser.getUsage();
+
+        console.log(`[GeminiWrapper] Response length: ${finalResponse.length}`);
+        console.log(`[GeminiWrapper] Usage:`, usage ? JSON.stringify(usage) : 'none');
+
+        // Calculate token counts (fallback if parser didn't get them)
+        const promptTokens = usage?.input_tokens || Math.ceil(prompt.length / 4);
+        const completionTokens = usage?.output_tokens || Math.ceil(finalResponse.length / 4);
+
+        resolve({
+          text: finalResponse,
+          usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+          }
+        });
+      });
+
+      // Handle errors
+      if (ptyProcess.onError) {
+        ptyProcess.onError((error) => {
+          if (promiseSettled) return;
+          promiseSettled = true;
+          console.error('[GeminiWrapper] PTY error:', error);
+          reject(new Error(`Gemini CLI PTY error: ${error.message}`));
+        });
+      }
+
+      // Timeout after 10 minutes
+      const timeout = setTimeout(() => {
+        if (!promiseSettled) {
+          promiseSettled = true;
+          console.error('[GeminiWrapper] Timeout after 10 minutes');
+          try {
+            ptyProcess.kill();
+          } catch (_) {}
+          reject(new Error('Gemini CLI timeout (10 minutes)'));
+        }
+      }, CLI_TIMEOUT_MS);
+
+      // Clear timeout on exit
+      ptyProcess.onExit(() => clearTimeout(timeout));
+    });
+  }
+
+  /**
+   * Check if Gemini CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    return new Promise((resolve) => {
+      const { exec } = require('child_process');
+      exec(`${this.geminiPath} --version`, { timeout: 5000 }, (error, stdout) => {
+        if (error) {
+          console.log('[GeminiWrapper] CLI not available:', error.message);
+          resolve(false);
+        } else {
+          console.log('[GeminiWrapper] CLI available:', stdout.trim().substring(0, 50));
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Get the default model
+   */
+  getDefaultModel() {
+    return DEFAULT_MODEL;
+  }
+
+  /**
+   * Get available models
+   */
+  getAvailableModels() {
+    return [
+      {
+        id: 'gemini-3-pro-preview',
+        name: 'Gemini 3 Pro Preview',
+        description: '🚀 Latest Gemini 3 model',
+        default: true
+      }
+    ];
+  }
+}
+
+module.exports = GeminiWrapper;

package/lib/server/services/history-sync.js

@@ -0,0 +1,407 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const Conversation = require('../models/Conversation');
+const Message = require('../models/Message');
+const { prepare } = require('../db');
+
+/**
+ * HistorySync - Sync Claude Code history.jsonl with database
+ *
+ * Reads ~/.claude/history.jsonl (JSONL format) and syncs to SQLite:
+ * - Groups messages by sessionId
+ * - Creates conversations (id = sessionId)
+ * - Populates messages table
+ * - Extracts title from first message display
+ *
+ * Architecture:
+ * - Claude Code saves all messages to history.jsonl natively
+ * - This service bridges history.jsonl → SQLite database
+ * - Frontend sidebar reads from database (synced from history)
+ *
+ * Features:
+ * - Incremental sync (only new messages)
+ * - Grouped by date (today, yesterday, last 7 days, etc.)
+ * - Preserves sessionId for resume (-r flag)
+ */
+class HistorySync {
+  constructor(options = {}) {
+    // Default to user's home directory
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    this.historyPath = options.historyPath || path.join(homeDir, '.claude', 'history.jsonl');
+    this.lastSyncTime = 0;
+    this.syncCacheMs = options.syncCacheMs || 30000; // Cache for 30 seconds
+  }
+
+  /**
+   * Check if history file exists
+   */
+  exists() {
+    try {
+      return fs.existsSync(this.historyPath);
+    } catch (error) {
+      console.error('[HistorySync] Error checking history file:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Parse history.jsonl and group by sessionId
+   * @returns {Promise<Map<sessionId, Session>>}
+   */
+  async parseHistory() {
+    const startTime = Date.now();
+    const sessions = new Map();
+    let totalMessages = 0;
+
+    if (!this.exists()) {
+      console.warn(`[HistorySync] History file not found: ${this.historyPath}`);
+      return sessions;
+    }
+
+    const fileStream = fs.createReadStream(this.historyPath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line);
+        totalMessages++;
+
+        // Only process entries with sessionId
+        if (!entry.sessionId) continue;
+
+        const timestamp = entry.timestamp || Date.now();
+
+        // Initialize session bag
+        if (!sessions.has(entry.sessionId)) {
+          sessions.set(entry.sessionId, {
+            id: entry.sessionId,
+            project: entry.project || null,
+            messages: [],
+            firstTimestamp: timestamp,
+            lastTimestamp: timestamp
+          });
+        }
+
+        const session = sessions.get(entry.sessionId);
+
+        session.messages.push({
+          display: entry.display || '',
+          timestamp,
+          project: entry.project || null,
+          pastedContents: entry.pastedContents || {}
+        });
+
+        session.firstTimestamp = Math.min(session.firstTimestamp, timestamp);
+        session.lastTimestamp = Math.max(session.lastTimestamp, timestamp);
+
+        // Keep most recent non-null project as workspace hint
+        if (entry.project) {
+          session.project = entry.project;
+        }
+      } catch (parseError) {
+        console.error('[HistorySync] Failed to parse line:', parseError.message);
+      }
+    }
+
+    const parseTime = Date.now() - startTime;
+    console.log(`[HistorySync] Parsed ${totalMessages} messages from history.jsonl in ${parseTime}ms`);
+    console.log(`[HistorySync] Found ${sessions.size} unique sessions`);
+
+    return sessions;
+  }
+
+  /**
+   * Sync history to database
+   * @param {Map<string, Session>|boolean} sessionsOrForce - Session map or force flag
+   * @param {Object} options
+   * @param {boolean} options.force - Force sync even if cache is valid
+   * @returns {Promise<{synced: number, skipped: number, cached?: boolean}>}
+   */
+  async syncToDatabase(sessionsOrForce = false, options = {}) {
+    let sessions = null;
+    let force = false;
+
+    if (sessionsOrForce instanceof Map) {
+      sessions = sessionsOrForce;
+      force = Boolean(options.force);
+    } else {
+      force = Boolean(sessionsOrForce);
+    }
+
+    const now = Date.now();
+
+    // Check cache (only when we are allowed to self-parse)
+    if (!sessions && !force && (now - this.lastSyncTime) < this.syncCacheMs) {
+      console.log('[HistorySync] Using cached sync (< 30s old)');
+      return { synced: 0, skipped: 0, cached: true };
+    }
+
+    const startTime = Date.now();
+    const parsedSessions = sessions || await this.parseHistory();
+
+    let conversationsCreated = 0;
+    let messagesCreated = 0;
+    let conversationsSkipped = 0;
+
+    // Process each session
+    for (const [sessionId, sessionData] of parsedSessions.entries()) {
+      if (!sessionData.messages || sessionData.messages.length === 0) continue;
+
+      // Sort messages by timestamp
+      const messages = [...sessionData.messages].sort((a, b) => a.timestamp - b.timestamp);
+
+      // Check if conversation exists
+      let conversation = Conversation.getById(sessionId);
+
+      if (!conversation) {
+        // Create new conversation
+        const firstMessage = messages[0];
+        const title = this.extractTitle(firstMessage.display);
+
+        try {
+          // Use sessionId as conversation ID
+          conversation = {
+            id: sessionId,
+            title,
+            created_at: sessionData.firstTimestamp || firstMessage.timestamp,
+            updated_at: sessionData.lastTimestamp || messages[messages.length - 1].timestamp,
+            metadata: sessionData.project ? JSON.stringify({ workspace: sessionData.project }) : null
+          };
+
+          // Insert directly (bypass UUID generation in Conversation.create)
+          const stmt = prepare(`
+            INSERT OR REPLACE INTO conversations (id, title, created_at, updated_at, metadata)
+            VALUES (?, ?, ?, ?, ?)
+          `);
+          stmt.run(sessionId, title, conversation.created_at, conversation.updated_at, conversation.metadata);
+
+          conversationsCreated++;
+          console.log(`[HistorySync] Created conversation: ${sessionId} - "${title}"`);
+
+        } catch (error) {
+          console.error(`[HistorySync] Failed to create conversation ${sessionId}:`, error.message);
+          continue;
+        }
+      } else {
+        conversationsSkipped++;
+      }
+
+      // Get existing messages for this conversation
+      const existingMessages = Message.getByConversation(sessionId);
+      const existingTimestamps = new Set(existingMessages.map(m => m.created_at));
+      let newMessagesForSession = 0;
+      let sessionInserted = false;
+
+      // Insert new messages
+      for (const historyMsg of messages) {
+        // Skip if message already exists (by timestamp)
+        if (existingTimestamps.has(historyMsg.timestamp)) continue;
+
+        try {
+          Message.create(
+            sessionId,
+            'user', // All history entries are user messages
+            historyMsg.display,
+            {
+              project: historyMsg.project,
+              pastedContents: historyMsg.pastedContents
+            },
+            historyMsg.timestamp
+          );
+          messagesCreated++;
+          newMessagesForSession++;
+        } catch (error) {
+          console.error(`[HistorySync] Failed to create message:`, error.message);
+        }
+      }
+
+      // Ensure session row exists (for workspace filtering)
+      try {
+        const sessionCheckStmt = prepare('SELECT id FROM sessions WHERE id = ?');
+        const hasSession = sessionCheckStmt.get(sessionId);
+
+        if (!hasSession) {
+          const insertSessionStmt = prepare(`
+            INSERT INTO sessions (
+              id, engine, workspace_path, session_path, title,
+              last_used_at, created_at, pinned, importance, message_count, metadata,
+              conversation_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `);
+
+          insertSessionStmt.run(
+            sessionId,
+            'claude-code',
+            sessionData.project || process.cwd(),
+            null,
+            conversation.title,
+            conversation.updated_at,
+            conversation.created_at,
+            0,
+            0,
+            existingMessages.length + newMessagesForSession,
+            conversation.metadata,
+            sessionId  // conversation_id = sessionId for history sync
+          );
+          sessionInserted = true;
+        }
+      } catch (sessionErr) {
+        console.warn('[HistorySync] Failed to ensure session row:', sessionErr.message);
+      }
+
+      // Update sessions.message_count / last_used_at if we added new messages
+      if (newMessagesForSession > 0 && !sessionInserted) {
+        try {
+          const updateSessionStmt = prepare(`
+            UPDATE sessions
+            SET message_count = COALESCE(message_count, 0) + ?, last_used_at = ?
+            WHERE id = ?
+          `);
+          updateSessionStmt.run(newMessagesForSession, sessionData.lastTimestamp || Date.now(), sessionId);
+        } catch (updateErr) {
+          console.warn('[HistorySync] Failed to update session counters:', updateErr.message);
+        }
+      }
+    }
+
+    const syncTime = Date.now() - startTime;
+    this.lastSyncTime = now;
+
+    console.log(`[HistorySync] Sync completed in ${syncTime}ms`);
+    console.log(`[HistorySync] - Conversations: ${conversationsCreated} created, ${conversationsSkipped} skipped`);
+    console.log(`[HistorySync] - Messages: ${messagesCreated} created`);
+
+    return {
+      synced: conversationsCreated + messagesCreated,
+      skipped: conversationsSkipped,
+      newConversations: conversationsCreated,
+      newMessages: messagesCreated,
+      cached: false
+    };
+  }
+
+  /**
+   * Wrapper to perform full sync with cache control
+   * @param {boolean} force
+   */
+  async sync(force = false) {
+    const sessions = await this.parseHistory();
+    return this.syncToDatabase(sessions, { force });
+  }
+
+  /**
+   * Extract conversation title from display message
+   * @param {string} display - First message display text
+   * @returns {string} Title (max 80 chars)
+   */
+  extractTitle(display) {
+    if (!display) return 'Untitled Conversation';
+
+    // Truncate to 80 characters
+    let title = display.substring(0, 80);
+
+    // If truncated, add ellipsis
+    if (display.length > 80) {
+      title += '...';
+    }
+
+    return title;
+  }
+
+  /**
+   * Get grouped conversations by date
+   * @returns {Promise<Object>} Grouped conversations
+   */
+  async getGroupedConversations() {
+    // Sync first
+    await this.syncToDatabase();
+
+    // Use existing Conversation.listGroupedByDate()
+    return Conversation.listGroupedByDate();
+  }
+
+  /**
+   * Get conversations filtered by workspace (sessions.workspace_path)
+   * @param {string} workspacePath
+   * @param {number} limit - Max conversations (default: 50)
+   * @returns {Promise<Object>} Grouped by date like listGroupedByDate
+   */
+  async getWorkspaceSessions(workspacePath, limit = 50) {
+    if (!workspacePath) return { today: [], yesterday: [], last7days: [], last30days: [], older: [] };
+
+    // Skip sync if cached - workspace query is fast enough
+    // await this.sync(); // Removed - too slow!
+
+    try {
+      const now = Date.now();
+      const oneDayMs = 24 * 60 * 60 * 1000;
+
+      // Optimized query: use index on workspace_path, limit results
+      const stmt = prepare(`
+        SELECT c.*,
+          CASE
+            WHEN (? - c.updated_at) < ? THEN 'today'
+            WHEN (? - c.updated_at) < ? THEN 'yesterday'
+            WHEN (? - c.updated_at) < ? THEN 'last7days'
+            WHEN (? - c.updated_at) < ? THEN 'last30days'
+            ELSE 'older'
+          END as date_group
+        FROM conversations c
+        INNER JOIN sessions s ON c.id = s.id
+        WHERE s.workspace_path = ?
+        ORDER BY c.updated_at DESC
+        LIMIT ?
+      `);
+
+      const rows = stmt.all(
+        now, oneDayMs,           // today
+        now, 2 * oneDayMs,       // yesterday
+        now, 7 * oneDayMs,       // last7days
+        now, 30 * oneDayMs,      // last30days
+        workspacePath,
+        limit
+      );
+
+      // Group results
+      const grouped = {
+        today: [],
+        yesterday: [],
+        last7days: [],
+        last30days: [],
+        older: []
+      };
+
+      for (const row of rows) {
+        const group = row.date_group;
+        delete row.date_group;
+
+        // Parse metadata
+        if (row.metadata) {
+          try {
+            row.metadata = JSON.parse(row.metadata);
+            if (row.metadata.bookmarked !== undefined) {
+              row.metadata.pinned = row.metadata.bookmarked;
+            }
+          } catch (e) {
+            row.metadata = null;
+          }
+        }
+
+        grouped[group].push(row);
+      }
+
+      return grouped;
+    } catch (err) {
+      console.error('[HistorySync] Workspace filter error:', err.message);
+      return { today: [], yesterday: [], last7days: [], last30days: [], older: [] };
+    }
+  }
+}
+
+module.exports = HistorySync;