claude-code-templates 1.14.16 → 1.15.1

package/bin/create-claude-config.js

@@ -53,7 +53,11 @@ program
   .option('--hook-stats, --hooks-stats', 'analyze existing automation hooks and offer optimization')
   .option('--mcp-stats, --mcps-stats', 'analyze existing MCP server configurations and offer optimization')
   .option('--analytics', 'launch real-time Claude Code analytics dashboard')
-  .option('--chats, --agents', 'launch Claude Code chats/agents dashboard (opens directly to conversations)')
+  .option('--chats', 'launch mobile-first chats interface (AI-optimized for mobile devices)')
+  .option('--agents', 'launch Claude Code agents dashboard (opens directly to conversations)')
+  .option('--chats-mobile', 'launch mobile-first chats interface (AI-optimized for mobile devices)')
+  .option('--tunnel', 'enable Cloudflare Tunnel for remote access (use with --analytics or --chats)')
+  .option('--verbose', 'enable verbose logging for debugging and development')
   .option('--health-check, --health, --check, --verify', 'run comprehensive health check to verify Claude Code setup')
   .option('--agent <agent>', 'install specific agent component (supports comma-separated values)')
   .option('--command <command>', 'install specific command component (supports comma-separated values)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.14.16",
+  "version": "1.15.1",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {
@@ -69,6 +69,7 @@
     "inquirer": "^8.2.6",
     "open": "^8.4.2",
     "ora": "^5.4.1",
+    "uuid": "^11.1.0",
     "ws": "^8.18.3"
   },
   "engines": {

package/src/analytics/core/AgentAnalyzer.js

@@ -287,11 +287,25 @@ class AgentAnalyzer {
       const content = await fs.readFile(filePath, 'utf8');
       const lines = content.trim().split('\n').filter(line => line.trim());
       
-      return lines.map(line => {
+      return lines.map((line, index) => {
         try {
-          return JSON.parse(line);
+          // Skip empty or whitespace-only lines
+          if (!line.trim()) {
+            return null;
+          }
+          
+          // Basic validation - must start with { and end with }
+          const trimmed = line.trim();
+          if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+            return null;
+          }
+          
+          return JSON.parse(trimmed);
         } catch (error) {
-          console.warn(`Error parsing JSONL line in ${filePath}:`, error.message);
+          // Only log the error occasionally to avoid spam
+          if (index % 10 === 0) {
+            console.warn(`Error parsing JSONL line ${index + 1} in ${filePath}:`, error.message.substring(0, 100));
+          }
           return null;
         }
       }).filter(Boolean);

package/src/analytics/core/ProcessDetector.js

@@ -29,22 +29,38 @@ class ProcessDetector {
 
     return new Promise((resolve) => {
       // Search for processes containing 'claude' but exclude our own analytics process and system processes
-      exec('ps aux | grep -i claude | grep -v grep | grep -v analytics | grep -v "/Applications/Claude.app" | grep -v "npm start"', (error, stdout) => {
+      exec('ps aux | grep -i claude | grep -v grep | grep -v analytics | grep -v "/Applications/Claude.app" | grep -v "npm start" | grep -v chats-mobile', (error, stdout) => {
         if (error) {
           resolve([]);
           return;
         }
         
+        console.log('🔍 Raw Claude processes output:', stdout); // Debug output
+        
         const processes = stdout.split('\n')
           .filter(line => line.trim())
           .filter(line => {
-            // Only include actual Claude CLI processes, not system processes
+            // More flexible Claude CLI process detection
             const fullCommand = line.split(/\s+/).slice(10).join(' ');
-            return fullCommand.includes('claude') && 
-                   !fullCommand.includes('chrome_crashpad_handler') &&
-                   !fullCommand.includes('create-claude-config') &&
-                   !fullCommand.includes('node bin/') &&
-                   fullCommand.trim() === 'claude'; // Only the basic claude command
+            const isClaudeProcess = (
+              fullCommand.includes('claude') &&
+              !fullCommand.includes('chrome_crashpad_handler') &&
+              !fullCommand.includes('create-claude-config') &&
+              !fullCommand.includes('chats-mobile') &&
+              !fullCommand.includes('analytics') &&
+              // Allow various Claude CLI invocations
+              (fullCommand.trim() === 'claude' || 
+               fullCommand.includes('claude --') ||
+               fullCommand.includes('claude ') ||
+               fullCommand.includes('/claude') ||
+               fullCommand.includes('bin/claude'))
+            );
+            
+            if (isClaudeProcess) {
+              console.log('✅ Found Claude process:', fullCommand);
+            }
+            
+            return isClaudeProcess;
           })
           .map(line => {
             const parts = line.split(/\s+/);

package/src/analytics/core/StateCalculator.js

@@ -19,10 +19,21 @@ class StateCalculator {
    */
   determineConversationState(messages, lastModified, runningProcess = null) {
     const now = new Date();
-    const timeDiff = now - lastModified;
-    const minutesAgo = timeDiff / (1000 * 60);
+    const fileTimeDiff = now - lastModified;
+    const fileMinutesAgo = fileTimeDiff / (1000 * 60);
+
+    // Enhanced detection: Look for real Claude Code activity indicators
+    const claudeActivity = this.detectRealClaudeActivity(messages, lastModified);
+    if (claudeActivity.isActive) {
+      return claudeActivity.status;
+    }
+
+    // If there's very recent file activity (within 5 minutes), consider it active
+    if (fileMinutesAgo < 5) {
+      return 'Claude Code working...';
+    }
 
-    // If there's an active process, use simpler and more stable logic
+    // If there's an active process, prioritize that
     if (runningProcess && runningProcess.hasActiveCommand) {
       // Check conversation flow first for immediate response
       if (messages.length > 0) {
@@ -32,39 +43,30 @@ class StateCalculator {
         const lastMessageMinutesAgo = (now - lastMessageTime) / (1000 * 60);
         
         if (lastMessage.role === 'user') {
-          // User sent message - be more conservative about "working" state
-          if (lastMessageMinutesAgo < 1) {
+          // User sent message - be more generous about active state
+          if (lastMessageMinutesAgo < 3) {
             return 'Claude Code working...';
-          } else {
+          } else if (lastMessageMinutesAgo < 10) {
             return 'Awaiting response...';
+          } else {
+            return 'Active session';
           }
         } else if (lastMessage.role === 'assistant') {
-          // Claude responded - check if file activity indicates continued work
-          const fileTimeDiff = (now - lastModified) / 1000; // seconds
-          if (fileTimeDiff < 30) {
-            return 'Claude Code working...';
-          }
-          // Use broader time ranges for more stability
-          if (lastMessageMinutesAgo < 5) {
+          // Claude responded - if there's an active process, still active
+          if (lastMessageMinutesAgo < 10) {
             return 'Awaiting user input...';
           } else {
-            return 'User typing...';
+            return 'Active session';
           }
         }
       }
       
-      // Very recent file activity = Claude working (fallback)
-      const fileTimeDiff = (now - lastModified) / 1000; // seconds
-      if (fileTimeDiff < 30) {
-        return 'Claude Code working...';
-      }
-      
-      // Default for active process
-      return 'Awaiting user input...';
+      // Default for active process - be more generous
+      return 'Active session';
     }
 
     if (messages.length === 0) {
-      return minutesAgo < 5 ? 'Waiting for input...' : 'Idle';
+      return fileMinutesAgo < 5 ? 'Waiting for input...' : 'Idle';
     }
 
     // Sort messages by timestamp to get the actual conversation flow
@@ -73,28 +75,32 @@ class StateCalculator {
     const lastMessageTime = new Date(lastMessage.timestamp);
     const lastMessageMinutesAgo = (now - lastMessageTime) / (1000 * 60);
 
-    // Simplified and more stable state logic
+    // More generous logic for active conversations
     if (lastMessage.role === 'user') {
       // User sent last message
-      if (lastMessageMinutesAgo < 1) {
+      if (lastMessageMinutesAgo < 3) {
         return 'Claude Code working...';
-      } else if (lastMessageMinutesAgo < 5) {
+      } else if (lastMessageMinutesAgo < 10) {
         return 'Awaiting response...';
-      } else {
+      } else if (lastMessageMinutesAgo < 30) {
         return 'User typing...';
+      } else {
+        return 'Recently active';
       }
     } else if (lastMessage.role === 'assistant') {
-      // Assistant sent last message - consolidate similar states
-      if (lastMessageMinutesAgo < 5) {
+      // Assistant sent last message
+      if (lastMessageMinutesAgo < 10) {
         return 'Awaiting user input...';
-      } else {
+      } else if (lastMessageMinutesAgo < 30) {
         return 'User typing...';
+      } else {
+        return 'Recently active';
       }
     }
 
-    // Fallback states
-    if (minutesAgo < 5) return 'Recently active';
-    if (minutesAgo < 60) return 'Idle';
+    // Fallback states - be more generous about "active" state
+    if (fileMinutesAgo < 10 || lastMessageMinutesAgo < 30) return 'Recently active';
+    if (fileMinutesAgo < 60 || lastMessageMinutesAgo < 120) return 'Idle';
     return 'Inactive';
   }
 
@@ -164,6 +170,69 @@ class StateCalculator {
     return 'inactive';
   }
 
+  /**
+   * Detect real Claude Code activity based on conversation patterns and file activity
+   * @param {Array} messages - Conversation messages
+   * @param {Date} lastModified - File last modification time
+   * @returns {Object} Activity detection result
+   */
+  detectRealClaudeActivity(messages, lastModified) {
+    const now = new Date();
+    const fileMinutesAgo = (now - lastModified) / (1000 * 60);
+    
+    if (!messages || messages.length === 0) {
+      return { isActive: false, status: 'No messages' };
+    }
+    
+    // Sort messages by timestamp
+    const sortedMessages = messages.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+    const lastMessage = sortedMessages[sortedMessages.length - 1];
+    const lastMessageTime = new Date(lastMessage.timestamp);
+    const messageMinutesAgo = (now - lastMessageTime) / (1000 * 60);
+    
+    // Real activity indicators:
+    
+    // 1. Very recent file modification (Claude Code just wrote to the conversation file)
+    if (fileMinutesAgo < 1) {
+      return { isActive: true, status: 'Claude Code working...' };
+    }
+    
+    // 2. Recent user message with recent file activity (Claude is processing)
+    if (lastMessage.role === 'user' && messageMinutesAgo < 5 && fileMinutesAgo < 10) {
+      return { isActive: true, status: 'Claude Code working...' };
+    }
+    
+    // 3. Recent assistant message with very recent file activity (might still be working)
+    if (lastMessage.role === 'assistant' && messageMinutesAgo < 2 && fileMinutesAgo < 5) {
+      return { isActive: true, status: 'Claude Code finishing...' };
+    }
+    
+    // 4. Look for tool activity patterns (tools often indicate active sessions)
+    const recentMessages = sortedMessages.slice(-3);
+    const hasRecentTools = recentMessages.some(msg => 
+      (Array.isArray(msg.content) && msg.content.some(block => block.type === 'tool_use')) ||
+      (msg.toolResults && msg.toolResults.length > 0)
+    );
+    
+    if (hasRecentTools && messageMinutesAgo < 10 && fileMinutesAgo < 15) {
+      return { isActive: true, status: 'Active session' };
+    }
+    
+    // 5. Rapid message exchange pattern (back-and-forth conversation)
+    if (sortedMessages.length >= 2) {
+      const lastTwoMessages = sortedMessages.slice(-2);
+      const timeBetweenLast = Math.abs(
+        new Date(lastTwoMessages[1].timestamp) - new Date(lastTwoMessages[0].timestamp)
+      ) / (1000 * 60); // minutes
+      
+      if (timeBetweenLast < 5 && messageMinutesAgo < 15 && fileMinutesAgo < 20) {
+        return { isActive: true, status: 'Active conversation' };
+      }
+    }
+    
+    return { isActive: false, status: null };
+  }
+
   /**
    * Get CSS class for conversation state styling
    * @param {string} conversationState - The conversation state

package/src/analytics/data/DataCache.js

@@ -33,14 +33,14 @@ class DataCache {
       projectStats: new Map(), // projectPath -> { data, timestamp }
     };
     
-    // Cache configuration (reduced TTL for aggressive memory management)
+    // Cache configuration - balanced for performance vs memory
     this.config = {
-      fileContentTTL: 30000, // 30 seconds for file content (reduced from 60s)
-      parsedDataTTL: 15000, // 15 seconds for parsed data (reduced from 30s)
-      computationTTL: 10000, // 10 seconds for expensive computations (reduced from 20s)
-      metadataTTL: 5000, // 5 seconds for metadata (reduced from 10s)
-      processTTL: 500, // 500ms for process data
-      maxCacheSize: 25, // Aggressively reduced to 25 to prevent memory buildup
+      fileContentTTL: 60000, // 1 minute for file content
+      parsedDataTTL: 30000, // 30 seconds for parsed data
+      computationTTL: 20000, // 20 seconds for expensive computations
+      metadataTTL: 10000, // 10 seconds for metadata
+      processTTL: 1000, // 1 second for process data
+      maxCacheSize: 50, // Increased to reduce evictions
     };
     
     // Dependency tracking for smart invalidation