claude-code-templates 1.24.16 → 1.25.0

package/src/chats-mobile.js

@@ -10,6 +10,7 @@ const StateCalculator = require('./analytics/core/StateCalculator');
 const FileWatcher = require('./analytics/core/FileWatcher');
 const DataCache = require('./analytics/data/DataCache');
 const WebSocketServer = require('./analytics/notifications/WebSocketServer');
+const SessionSharing = require('./session-sharing');
 
 class ChatsMobile {
   constructor(options = {}) {
@@ -28,7 +29,10 @@ class ChatsMobile {
     const homeDir = os.homedir();
     const claudeDir = path.join(homeDir, '.claude');
     this.conversationAnalyzer = new ConversationAnalyzer(claudeDir, this.dataCache);
-    
+
+    // Initialize SessionSharing for export/import functionality
+    this.sessionSharing = new SessionSharing(this.conversationAnalyzer);
+
     this.data = {
       conversations: [],
       conversationStates: {},
@@ -173,6 +177,244 @@ class ChatsMobile {
       }
     });
 
+    // API to get unique working directories from conversations
+    this.app.get('/api/directories', (req, res) => {
+      try {
+        // Extract unique directories from conversations
+        const directories = new Set();
+
+        this.data.conversations.forEach(conv => {
+          if (conv.project && conv.project.trim()) {
+            directories.add(conv.project);
+          }
+        });
+
+        // Convert to array and sort alphabetically
+        const sortedDirectories = Array.from(directories).sort((a, b) =>
+          a.toLowerCase().localeCompare(b.toLowerCase())
+        );
+
+        res.json({
+          directories: sortedDirectories,
+          count: sortedDirectories.length,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('Error getting directories:', error);
+        res.status(500).json({ error: 'Internal server error' });
+      }
+    });
+
+    // API to search conversations with advanced filters
+    this.app.post('/api/search', async (req, res) => {
+      try {
+        const { query, workingDirectory, dateFrom, dateTo, contentSearch } = req.body;
+
+        let results = [...this.data.conversations];
+
+        // Filter by working directory (project)
+        if (workingDirectory && workingDirectory.trim()) {
+          results = results.filter(conv => {
+            if (!conv.project) return false;
+            return conv.project.toLowerCase().includes(workingDirectory.toLowerCase());
+          });
+        }
+
+        // Filter by date range
+        if (dateFrom) {
+          const fromDate = new Date(dateFrom);
+          results = results.filter(conv => new Date(conv.created) >= fromDate);
+        }
+
+        if (dateTo) {
+          const toDate = new Date(dateTo);
+          toDate.setHours(23, 59, 59, 999); // Include entire day
+          results = results.filter(conv => new Date(conv.created) <= toDate);
+        }
+
+        // Filter by conversation metadata (filename, id)
+        if (query && query.trim()) {
+          const searchTerm = query.toLowerCase();
+          results = results.filter(conv =>
+            conv.filename.toLowerCase().includes(searchTerm) ||
+            conv.id.toLowerCase().includes(searchTerm) ||
+            (conv.project && conv.project.toLowerCase().includes(searchTerm))
+          );
+        }
+
+        // Search within message content
+        if (contentSearch && contentSearch.trim()) {
+          const contentTerm = contentSearch.toLowerCase();
+          const matchingConversations = [];
+
+          for (const conv of results) {
+            try {
+              const messages = await this.conversationAnalyzer.getParsedConversation(conv.filePath);
+
+              // Search in message content
+              const hasMatch = messages.some(msg => {
+                // Search in text content
+                if (typeof msg.content === 'string') {
+                  return msg.content.toLowerCase().includes(contentTerm);
+                }
+
+                // Search in array content (tool use, text blocks)
+                if (Array.isArray(msg.content)) {
+                  return msg.content.some(block => {
+                    if (block.type === 'text' && block.text) {
+                      return block.text.toLowerCase().includes(contentTerm);
+                    }
+                    if (block.type === 'tool_use' && block.name) {
+                      return block.name.toLowerCase().includes(contentTerm);
+                    }
+                    return false;
+                  });
+                }
+
+                return false;
+              });
+
+              if (hasMatch) {
+                matchingConversations.push(conv);
+              }
+            } catch (error) {
+              // Skip conversations that can't be parsed
+              this.log('warn', `Error searching in conversation ${conv.id}:`, error.message);
+            }
+          }
+
+          results = matchingConversations;
+        }
+
+        // Sort by last modified (most recent first)
+        results.sort((a, b) => new Date(b.lastModified) - new Date(a.lastModified));
+
+        res.json({
+          results: results,
+          count: results.length,
+          filters: {
+            query,
+            workingDirectory,
+            dateFrom,
+            dateTo,
+            contentSearch
+          },
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('Error searching conversations:', error);
+        res.status(500).json({ error: 'Internal server error', message: error.message });
+      }
+    });
+
+    // API to search within a specific conversation
+    this.app.post('/api/conversations/:id/search', async (req, res) => {
+      try {
+        const conversationId = req.params.id;
+        const { query } = req.body;
+        const conversation = this.data.conversations.find(conv => conv.id === conversationId);
+
+        if (!conversation) {
+          return res.status(404).json({ error: 'Conversation not found' });
+        }
+
+        if (!query || !query.trim()) {
+          return res.json({
+            matches: [],
+            totalMatches: 0,
+            conversationId: conversationId
+          });
+        }
+
+        // Get all messages from the conversation
+        const allMessages = await this.conversationAnalyzer.getParsedConversation(conversation.filePath);
+        const searchTerm = query.toLowerCase();
+        const matches = [];
+
+        // Search through all messages
+        allMessages.forEach((msg, index) => {
+          let messageText = '';
+          let allText = [];
+
+          // Extract text from message content
+          if (typeof msg.content === 'string') {
+            allText.push(msg.content);
+          } else if (Array.isArray(msg.content)) {
+            msg.content.forEach(block => {
+              if (block.type === 'text' && block.text) {
+                allText.push(block.text);
+              }
+              // Also search in tool_use content
+              if (block.type === 'tool_use') {
+                if (block.name) allText.push(block.name);
+                if (block.input) {
+                  allText.push(JSON.stringify(block.input));
+                }
+              }
+            });
+          }
+
+          // IMPORTANT: Also search in tool results (this is where code blocks appear!)
+          if (msg.toolResults && Array.isArray(msg.toolResults)) {
+            msg.toolResults.forEach(toolResult => {
+              if (toolResult.content) {
+                if (typeof toolResult.content === 'string') {
+                  allText.push(toolResult.content);
+                } else if (Array.isArray(toolResult.content)) {
+                  toolResult.content.forEach(block => {
+                    if (block.type === 'text' && block.text) {
+                      allText.push(block.text);
+                    }
+                  });
+                }
+              }
+            });
+          }
+
+          // Combine all text
+          messageText = allText.join(' ');
+
+          // Search in the combined text
+          if (messageText.toLowerCase().includes(searchTerm)) {
+            // Find all positions of the search term in this message
+            const lowerText = messageText.toLowerCase();
+            let position = 0;
+            let matchCount = 0;
+
+            while ((position = lowerText.indexOf(searchTerm, position)) !== -1) {
+              matchCount++;
+              position += searchTerm.length;
+            }
+
+            matches.push({
+              messageIndex: index,
+              messageId: msg.id,
+              role: msg.role,
+              timestamp: msg.timestamp,
+              preview: this.getMessagePreview(messageText, searchTerm),
+              matchCount: matchCount
+            });
+          }
+        });
+
+        console.log(`🔍 Search in conversation ${conversationId}:`, {
+          query: query,
+          messagesWithMatches: matches.length,
+          totalOccurrences: matches.reduce((sum, m) => sum + m.matchCount, 0)
+        });
+
+        res.json({
+          matches: matches,
+          totalMatches: matches.length,
+          conversationId: conversationId,
+          query: query
+        });
+      } catch (error) {
+        console.error('Error searching in conversation:', error);
+        res.status(500).json({ error: 'Internal server error', message: error.message });
+      }
+    });
+
     // API to get specific conversation messages (with pagination support)
     this.app.get('/api/conversations/:id/messages', async (req, res) => {
       try {
@@ -236,6 +478,39 @@ class ChatsMobile {
       }
     });
 
+    // API to share a conversation session
+    this.app.post('/api/conversations/:id/share', async (req, res) => {
+      try {
+        const conversationId = req.params.id;
+        const conversation = this.data.conversations.find(conv => conv.id === conversationId);
+
+        if (!conversation) {
+          return res.status(404).json({ error: 'Conversation not found' });
+        }
+
+        console.log(chalk.cyan(`📤 Sharing conversation ${conversationId}...`));
+
+        // Share the session using SessionSharing module
+        const shareResult = await this.sessionSharing.shareSession(conversationId, conversation);
+
+        res.json({
+          success: true,
+          conversationId: conversationId,
+          uploadUrl: shareResult.uploadUrl,
+          shareCommand: shareResult.shareCommand,
+          expiresIn: shareResult.expiresIn,
+          qrCode: shareResult.qrCode,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('Error sharing conversation:', error);
+        res.status(500).json({
+          error: 'Failed to share session',
+          message: error.message
+        });
+      }
+    });
+
     // Serve the mobile chats page as default
     this.app.get('/', (req, res) => {
       res.sendFile(path.join(__dirname, 'analytics-web', 'chats_mobile.html'));
@@ -418,6 +693,26 @@ class ChatsMobile {
     console.log(chalk.gray('🔧 WebSocket server setup prepared'));
   }
 
+  /**
+   * Helper function to get message preview with context
+   */
+  getMessagePreview(text, searchTerm, contextLength = 100) {
+    const lowerText = text.toLowerCase();
+    const lowerTerm = searchTerm.toLowerCase();
+    const position = lowerText.indexOf(lowerTerm);
+
+    if (position === -1) return text.substring(0, contextLength);
+
+    const start = Math.max(0, position - contextLength / 2);
+    const end = Math.min(text.length, position + searchTerm.length + contextLength / 2);
+
+    let preview = text.substring(start, end);
+    if (start > 0) preview = '...' + preview;
+    if (end < text.length) preview = preview + '...';
+
+    return preview;
+  }
+
   /**
    * Load initial conversation data
    */

package/src/index.js

@@ -18,6 +18,8 @@ const { runHealthCheck } = require('./health-check');
 const { runPluginDashboard } = require('./plugin-dashboard');
 const { trackingService } = require('./tracking-service');
 const { createGlobalAgent, listGlobalAgents, removeGlobalAgent, updateGlobalAgent } = require('./sdk/global-agent-manager');
+const SessionSharing = require('./session-sharing');
+const ConversationAnalyzer = require('./analytics/core/ConversationAnalyzer');
 
 async function showMainMenu() {
   console.log('');
@@ -222,7 +224,48 @@ async function createClaudeConfig(options = {}) {
     await startChatsMobile(options);
     return;
   }
-  
+
+  // Handle session clone (download and import shared session)
+  if (options.cloneSession) {
+    console.log(chalk.blue('📥 Cloning shared Claude Code session...'));
+
+    try {
+      const os = require('os');
+      const homeDir = os.homedir();
+      const claudeDir = path.join(homeDir, '.claude');
+
+      // Initialize ConversationAnalyzer and SessionSharing
+      const conversationAnalyzer = new ConversationAnalyzer(claudeDir);
+      const sessionSharing = new SessionSharing(conversationAnalyzer);
+
+      // Clone the session (cloneSession method handles all console output)
+      const result = await sessionSharing.cloneSession(options.cloneSession, {
+        projectPath: options.directory || process.cwd()
+      });
+
+      // Track session clone
+      trackingService.trackAnalyticsDashboard({
+        page: 'session-clone',
+        source: 'command_line',
+        success: true
+      });
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to clone session:'), error.message);
+
+      // Track failed clone
+      trackingService.trackAnalyticsDashboard({
+        page: 'session-clone',
+        source: 'command_line',
+        success: false,
+        error: error.message
+      });
+
+      process.exit(1);
+    }
+
+    return;
+  }
+
   // Handle health check
   let shouldRunSetup = false;
   if (options.healthCheck || options.health || options.check || options.verify) {