@mmmbuto/nexuscli 0.5.0

package/lib/server/routes/conversations.js

@@ -0,0 +1,224 @@
+const express = require('express');
+const Conversation = require('../models/Conversation');
+const Message = require('../models/Message');
+const HistorySync = require('../services/history-sync');
+const sessionManager = require('../services/session-manager');
+const { getOrSet, invalidateConversations, KEYS, getStats } = require('../services/cache');
+
+const router = express.Router();
+const historySync = new HistorySync();
+
+/**
+ * GET /api/v1/conversations
+ * List conversations (optionally grouped by date)
+ *
+ * Query params:
+ * - groupBy=date: Group conversations by date
+ * - sync=true: Force sync with Claude Code history.jsonl (default: auto)
+ * - limit=N: Limit per group (default: 20, 0 = unlimited)
+ * - workspace=path: Filter by workspace path
+ */
+router.get('/', async (req, res) => {
+  try {
+    const startTime = Date.now();
+    const groupBy = req.query.groupBy;
+    const syncParam = req.query.sync;
+    const workspace = req.query.workspace;
+    const limit = parseInt(req.query.limit) || 20;
+    const noCache = req.query.nocache === 'true' || req.query.nocache === '1';
+    const forceSync = syncParam === 'true' || syncParam === '1';
+
+    // Sync with Claude Code history.jsonl
+    // Only sync if explicitly requested (removed auto-sync for performance)
+    if (forceSync && historySync.exists()) {
+      try {
+        await historySync.sync(true);
+        invalidateConversations(); // Clear cache after sync
+      } catch (syncError) {
+        console.error('[Conversations] Sync error:', syncError);
+        // Continue even if sync fails (use cached data)
+      }
+    }
+
+    // Filter by workspace if requested (returns grouped data)
+    if (workspace) {
+      const cacheKey = KEYS.CONVERSATIONS_WORKSPACE(workspace);
+      const grouped = noCache
+        ? await historySync.getWorkspaceSessions(workspace, limit)
+        : await getOrSet(cacheKey, () => historySync.getWorkspaceSessions(workspace, limit), 30);
+
+      console.log(`[Conversations] Workspace query took ${Date.now() - startTime}ms (cached: ${!noCache})`);
+      return res.json(grouped);
+    }
+
+    // Return conversations grouped by date
+    if (groupBy === 'date') {
+      const grouped = noCache
+        ? Conversation.listGroupedByDate(limit)
+        : await getOrSet(KEYS.CONVERSATIONS_GROUPED, () => Conversation.listGroupedByDate(limit), 30);
+
+      console.log(`[Conversations] Grouped query took ${Date.now() - startTime}ms (cached: ${!noCache})`);
+      return res.json(grouped);
+    }
+
+    // Return flat list (not cached - less frequent)
+    const conversations = Conversation.listRecent(limit);
+    console.log(`[Conversations] List query took ${Date.now() - startTime}ms`);
+
+    res.json({ conversations });
+  } catch (error) {
+    console.error('[Conversations] List error:', error);
+    res.status(500).json({ error: 'Failed to list conversations' });
+  }
+});
+
+/**
+ * GET /api/v1/conversations/:id
+ * Get conversation with messages
+ *
+ * Query params:
+ * - limit=N: Max messages to return (default: 50)
+ * - offset=N: Skip first N messages (default: 0)
+ * - all=true: Return all messages (ignores limit/offset)
+ */
+router.get('/:id', (req, res) => {
+  try {
+    const conversation = Conversation.getById(req.params.id);
+
+    if (!conversation) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+
+    // Get total message count
+    const totalMessages = Message.countByConversation(req.params.id);
+
+    // Parse query params
+    const all = req.query.all === 'true';
+    const limit = all ? totalMessages : (parseInt(req.query.limit) || 50);
+    const offset = all ? 0 : (parseInt(req.query.offset) || 0);
+
+    // Get messages for this conversation
+    const messages = Message.getByConversation(req.params.id, limit, offset);
+
+    res.json({
+      ...conversation,
+      messages,
+      pagination: {
+        total: totalMessages,
+        limit,
+        offset,
+        hasMore: (offset + messages.length) < totalMessages
+      }
+    });
+  } catch (error) {
+    console.error('[Conversations] Get error:', error);
+    res.status(500).json({ error: 'Failed to get conversation' });
+  }
+});
+
+/**
+ * PATCH /api/v1/conversations/:id
+ * Update conversation title
+ */
+router.patch('/:id', (req, res) => {
+  try {
+    const { title } = req.body;
+
+    if (!title) {
+      return res.status(400).json({ error: 'Title is required' });
+    }
+
+    const updated = Conversation.updateTitle(req.params.id, title);
+
+    if (!updated) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+
+    invalidateConversations(); // Clear cache after update
+    res.json({ success: true });
+  } catch (error) {
+    console.error('[Conversations] Update error:', error);
+    res.status(500).json({ error: 'Failed to update conversation' });
+  }
+});
+
+/**
+ * DELETE /api/v1/conversations/:id
+ * Delete conversation (cascade deletes messages and sessions)
+ */
+router.delete('/:id', (req, res) => {
+  try {
+    const conversationId = req.params.id;
+
+    // First, cleanup sessions for this conversation
+    const sessionsDeleted = sessionManager.deleteConversationSessions(conversationId);
+    console.log(`[Conversations] Deleted ${sessionsDeleted} sessions for ${conversationId}`);
+
+    // Then delete the conversation (cascade deletes messages)
+    const deleted = Conversation.delete(conversationId);
+
+    if (!deleted) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+
+    invalidateConversations(); // Clear cache after delete
+    res.json({ success: true, sessionsDeleted });
+  } catch (error) {
+    console.error('[Conversations] Delete error:', error);
+    res.status(500).json({ error: 'Failed to delete conversation' });
+  }
+});
+
+/**
+ * POST /api/v1/conversations/:id/bookmark
+ * Toggle bookmark status
+ */
+router.post('/:id/bookmark', (req, res) => {
+  try {
+    const bookmarked = Conversation.toggleBookmark(req.params.id);
+
+    if (bookmarked === null) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+
+    invalidateConversations(); // Clear cache after bookmark change
+    res.json({ bookmarked });
+  } catch (error) {
+    console.error('[Conversations] Bookmark error:', error);
+    res.status(500).json({ error: 'Failed to toggle bookmark' });
+  }
+});
+
+/**
+ * POST /api/v1/conversations/:id/pin
+ * Toggle pin status (alias for bookmark for UI consistency)
+ */
+router.post('/:id/pin', (req, res) => {
+  try {
+    const pinned = Conversation.toggleBookmark(req.params.id);
+
+    if (pinned === null) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+
+    invalidateConversations(); // Clear cache after pin change
+    res.json({ pinned });
+  } catch (error) {
+    console.error('[Conversations] Pin error:', error);
+    res.status(500).json({ error: 'Failed to toggle pin' });
+  }
+});
+
+/**
+ * GET /api/v1/conversations/cache/stats
+ * Get cache statistics (for debugging)
+ */
+router.get('/cache/stats', (req, res) => {
+  try {
+    res.json(getStats());
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

package/lib/server/routes/gemini.js

@@ -0,0 +1,228 @@
+/**
+ * Gemini Route - /api/v1/gemini
+ *
+ * Send messages to Gemini CLI with SSE streaming.
+ * Part of TRI CLI v0.4.0
+ */
+
+const express = require('express');
+const GeminiWrapper = require('../services/gemini-wrapper');
+const Message = require('../models/Message');
+const { v4: uuidv4 } = require('uuid');
+const sessionManager = require('../services/session-manager');
+const contextBridge = require('../services/context-bridge');
+
+const router = express.Router();
+const geminiWrapper = new GeminiWrapper();
+
+/**
+ * POST /api/v1/gemini
+ * Send message to Gemini CLI with SSE streaming
+ *
+ * Request body:
+ * {
+ *   "conversationId": "uuid" (optional for new chat)
+ *   "message": "user prompt",
+ *   "model": "gemini-3-pro-preview" (optional),
+ *   "workspace": "/path" (optional)
+ * }
+ *
+ * Response: SSE stream
+ * - status: Tool use, system events
+ * - response_chunk: Streaming text
+ * - message_done: Final response and usage
+ */
+router.post('/', async (req, res) => {
+  try {
+    console.log('[Gemini] === NEW GEMINI REQUEST ===');
+    console.log('[Gemini] Body:', JSON.stringify(req.body, null, 2));
+
+    const { conversationId, message, model = 'gemini-3-pro-preview', workspace } = req.body;
+
+    console.log(`[Gemini] conversationId: ${conversationId}`);
+    console.log(`[Gemini] message: ${message?.substring(0, 100)}`);
+    console.log(`[Gemini] model: ${model}`);
+    console.log(`[Gemini] workspace: ${workspace}`);
+
+    if (!message) {
+      console.log('[Gemini] ERROR: message required');
+      return res.status(400).json({ error: 'message required' });
+    }
+
+    // Check if Gemini CLI is available
+    const isAvailable = await geminiWrapper.isAvailable();
+    if (!isAvailable) {
+      console.log('[Gemini] ERROR: Gemini CLI not available');
+      return res.status(503).json({
+        error: 'Gemini CLI not available',
+        details: 'Please install Gemini CLI: npm install -g @anthropic/gemini-cli'
+      });
+    }
+
+    // Resolve workspace path
+    const workspacePath = workspace || process.cwd();
+
+    // Use SessionManager for session sync pattern
+    const frontendConversationId = conversationId || uuidv4();
+    const { sessionId, isNew: isNewSession } = await sessionManager.getOrCreateSession(
+      frontendConversationId,
+      'gemini',
+      workspacePath
+    );
+
+    console.log(`[Gemini] Session resolved: ${sessionId} (new: ${isNewSession})`);
+
+    // Set up SSE
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
+
+    // Send initial event
+    res.write(`data: ${JSON.stringify({
+      type: 'message_start',
+      messageId: `user-${Date.now()}`,
+      sessionId,
+      engine: 'gemini'
+    })}\n\n`);
+
+    // Use optimized ContextBridge for token-aware context building
+    // Note: Gemini has larger context window, uses preferSummary: false config
+    const lastEngine = Message.getLastEngine(sessionId);
+    const contextResult = await contextBridge.buildContext({
+      sessionId,
+      fromEngine: lastEngine,
+      toEngine: 'gemini',
+      userMessage: message
+    });
+
+    const promptWithContext = contextResult.prompt;
+    const isEngineBridge = contextResult.isEngineBridge;
+
+    console.log(`[Gemini] Context: ${contextResult.contextTokens} tokens from ${contextResult.contextSource}, total: ${contextResult.totalTokens}`);
+
+    // Notify frontend about engine switch
+    if (isEngineBridge) {
+      res.write(`data: ${JSON.stringify({
+        type: 'status',
+        category: 'system',
+        message: `Context bridged from ${lastEngine}`,
+        icon: '🔄'
+      })}\n\n`);
+    }
+
+    // Save user message to DB
+    try {
+      Message.create(
+        sessionId,
+        'user',
+        message,
+        { workspace: workspacePath, model },
+        Date.now(),
+        'gemini'
+      );
+    } catch (dbErr) {
+      console.warn('[Gemini] Failed to save user message:', dbErr.message);
+    }
+
+    // Update session title if new chat
+    if (isNewSession) {
+      const title = sessionManager.extractTitle(message);
+      sessionManager.updateSessionTitle(sessionId, title);
+    }
+
+    console.log('[Gemini] Calling Gemini CLI...');
+
+    // Call Gemini wrapper with SSE streaming
+    const result = await geminiWrapper.sendMessage({
+      prompt: promptWithContext,
+      sessionId,
+      model,
+      workspacePath,
+      onStatus: (event) => {
+        // Forward all events to SSE
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+    });
+
+    console.log(`[Gemini] Response received: ${result.text?.length || 0} chars`);
+
+    // Save assistant response to DB
+    try {
+      Message.create(
+        sessionId,
+        'assistant',
+        result.text,
+        { model, usage: result.usage },
+        Date.now(),
+        'gemini'
+      );
+    } catch (dbErr) {
+      console.warn('[Gemini] Failed to save assistant message:', dbErr.message);
+    }
+
+    // Smart auto-summary: trigger based on message count and engine bridging
+    if (contextBridge.shouldTriggerSummary(sessionId, isEngineBridge)) {
+      contextBridge.triggerSummaryGeneration(sessionId, '[Gemini]');
+    }
+
+    // Send final message with full content
+    res.write(`data: ${JSON.stringify({
+      type: 'message_done',
+      content: result.text,
+      usage: result.usage,
+      sessionId,
+      conversationId: frontendConversationId,
+      engine: 'gemini',
+      model
+    })}\n\n`);
+
+    res.end();
+    console.log('[Gemini] === REQUEST COMPLETE ===');
+
+  } catch (error) {
+    console.error('[Gemini] Error:', error);
+
+    if (!res.headersSent) {
+      res.status(500).json({ error: error.message });
+    } else {
+      // Send error via SSE if headers already sent
+      res.write(`data: ${JSON.stringify({
+        type: 'error',
+        error: error.message
+      })}\n\n`);
+      res.end();
+    }
+  }
+});
+
+/**
+ * GET /api/v1/gemini/status
+ * Check if Gemini CLI is available
+ */
+router.get('/status', async (req, res) => {
+  try {
+    const isAvailable = await geminiWrapper.isAvailable();
+    res.json({
+      available: isAvailable,
+      defaultModel: geminiWrapper.getDefaultModel(),
+      models: geminiWrapper.getAvailableModels()
+    });
+  } catch (error) {
+    console.error('[Gemini] Status check error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/v1/gemini/models
+ * List available Gemini models
+ */
+router.get('/models', (req, res) => {
+  res.json({
+    models: geminiWrapper.getAvailableModels(),
+    default: geminiWrapper.getDefaultModel()
+  });
+});
+
+module.exports = router;