claude-code-templates 1.10.1 → 1.12.0

package/README.md

@@ -76,6 +76,10 @@ npx claude-code-templates
 ```bash
 # Launch real-time analytics dashboard
 npx claude-code-templates --analytics
+
+# Launch chats/conversations dashboard (opens directly to conversations)
+npx claude-code-templates --chats
+npx claude-code-templates --agents
 ```
 
 ### Health Check
@@ -128,6 +132,8 @@ npx create-claude-config     # Create-style command
 | `-y, --yes` | Skip prompts and use defaults | `--yes` |
 | `--dry-run` | Show what would be installed | `--dry-run` |
 | `--analytics` | Launch real-time analytics dashboard | `--analytics` |
+| `--chats` | Launch chats/conversations dashboard | `--chats` |
+| `--agents` | Launch agents dashboard (alias for chats) | `--agents` |
 | `--health-check` | Run comprehensive system validation | `--health-check` |
 | `--health` | Run system health check (alias) | `--health` |
 | `--check` | Run system validation (alias) | `--check` |

package/bin/create-claude-config.js

@@ -45,6 +45,7 @@ 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('--health-check, --health, --check, --verify', 'run comprehensive health check to verify Claude Code setup')
   .action(async (options) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.10.1",
+  "version": "1.12.0",
   "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": {
@@ -31,7 +31,6 @@
     "dev:link": "npm link",
     "dev:unlink": "npm unlink -g claude-code-templates",
     "pretest:commands": "npm run dev:link",
-    "prepublishOnly": "echo 'Skipping tests for Ruby on Rails 8 release'",
     "analytics:start": "node src/analytics.js",
     "analytics:test": "npm run test:analytics"
   },

package/src/analytics/core/ConversationAnalyzer.js

@@ -93,7 +93,7 @@ class ConversationAnalyzer {
       };
 
       const jsonlFiles = await findJsonlFiles(this.claudeDir);
-      console.log(chalk.blue(`Found ${jsonlFiles.length} conversation files`));
+      // Loading conversation files quietly for better UX
 
       for (const filePath of jsonlFiles) {
         const stats = await this.getFileStats(filePath);
@@ -101,7 +101,7 @@ class ConversationAnalyzer {
 
         try {
           // Extract project name from path
-          const projectFromPath = this.extractProjectFromPath(filePath);
+          const projectFromPath = await this.extractProjectFromPath(filePath);
 
           // Use cached parsed conversation if available
           const parsedMessages = await this.getParsedConversation(filePath);
@@ -113,6 +113,9 @@ class ConversationAnalyzer {
           // Calculate tool usage data with caching
           const toolUsage = await this.getCachedToolUsage(filePath, parsedMessages);
 
+          const projectFromConversation = await this.extractProjectFromConversation(filePath);
+          const finalProject = projectFromConversation || projectFromPath;
+
           const conversation = {
             id: filename.replace('.jsonl', ''),
             filename: filename,
@@ -125,7 +128,7 @@ class ConversationAnalyzer {
             tokenUsage: tokenUsage,
             modelInfo: modelInfo,
             toolUsage: toolUsage,
-            project: projectFromPath || this.extractProjectFromConversation(parsedMessages),
+            project: finalProject,
             status: stateCalculator.determineConversationStatus(parsedMessages, stats.mtime),
             conversationState: stateCalculator.determineConversationState(parsedMessages, stats.mtime),
             statusSquares: await this.getCachedStatusSquares(filePath, parsedMessages),
@@ -216,26 +219,96 @@ class ConversationAnalyzer {
       return await this.dataCache.getParsedConversation(filepath);
     }
     
-    // Fallback to direct parsing
+    // Fallback to direct parsing with tool correlation
     const content = await fs.readFile(filepath, 'utf8');
-    return content.trim().split('\n')
-      .filter(line => line.trim())
-      .map(line => {
-        try {
-          const item = JSON.parse(line);
-          if (item.message && item.message.role) {
-            return {
-              role: item.message.role,
-              timestamp: new Date(item.timestamp),
-              content: item.message.content,
-              model: item.message.model || null,
-              usage: item.message.usage || null,
-            };
+    const lines = content.trim().split('\n').filter(line => line.trim());
+    
+    return this.parseAndCorrelateToolMessages(lines);
+  }
+
+  /**
+   * Parse JSONL lines and correlate tool_use with tool_result
+   * @param {Array} lines - JSONL lines
+   * @returns {Array} Parsed and correlated messages
+   */
+  parseAndCorrelateToolMessages(lines) {
+    const entries = [];
+    const toolUseMap = new Map();
+    
+    // First pass: parse all entries and map tool_use entries
+    for (const line of lines) {
+      try {
+        const item = JSON.parse(line);
+        if (item.message && (item.type === 'assistant' || item.type === 'user')) {
+          entries.push(item);
+          
+          // Track tool_use entries by their ID
+          if (item.type === 'assistant' && item.message.content) {
+            const toolUseBlock = Array.isArray(item.message.content) 
+              ? item.message.content.find(c => c.type === 'tool_use')
+              : (item.message.content.type === 'tool_use' ? item.message.content : null);
+            
+            if (toolUseBlock && toolUseBlock.id) {
+              toolUseMap.set(toolUseBlock.id, item);
+            }
+          }
+        }
+      } catch (error) {
+        // Skip invalid JSONL lines
+      }
+    }
+    
+    // Second pass: correlate tool_result with tool_use and filter out standalone tool_result entries
+    const processedMessages = [];
+    
+    for (const item of entries) {
+      if (item.type === 'user' && item.message.content) {
+        // Check if this is a tool_result entry
+        const toolResultBlock = Array.isArray(item.message.content)
+          ? item.message.content.find(c => c.type === 'tool_result')
+          : (item.message.content.type === 'tool_result' ? item.message.content : null);
+        
+        if (toolResultBlock && toolResultBlock.tool_use_id) {
+          // This is a tool_result - attach it to the corresponding tool_use
+          // console.log(`🔍 ConversationAnalyzer: Found tool_result for ${toolResultBlock.tool_use_id}, content: "${toolResultBlock.content}"`);
+          const toolUseEntry = toolUseMap.get(toolResultBlock.tool_use_id);
+          // console.log(`🔍 ConversationAnalyzer: toolUseEntry found: ${!!toolUseEntry}`);
+          if (toolUseEntry) {
+            // Attach tool result to the tool use entry
+            if (!toolUseEntry.toolResults) {
+              toolUseEntry.toolResults = [];
+            }
+            toolUseEntry.toolResults.push(toolResultBlock);
+            // console.log(`✅ ConversationAnalyzer: Attached tool result to ${toolResultBlock.tool_use_id}, content length: ${toolResultBlock.content?.length || 0}`);
+            // Don't add this tool_result as a separate message
+            continue;
+          } else {
+            // console.log(`❌ ConversationAnalyzer: No tool_use found for ${toolResultBlock.tool_use_id}`);
           }
-        } catch {}
-        return null;
-      })
-      .filter(Boolean);
+        }
+      }
+      
+      // Convert to our standard format
+      if (item.toolResults) {
+        // console.log(`ConversationAnalyzer: Processing item with ${item.toolResults.length} tool results`);
+      }
+      const parsed = {
+        id: item.message.id || item.uuid || null,
+        role: item.message.role || (item.type === 'assistant' ? 'assistant' : 'user'),
+        timestamp: new Date(item.timestamp),
+        content: item.message.content,
+        model: item.message.model || null,
+        usage: item.message.usage || null,
+        toolResults: item.toolResults || null, // Include attached tool results
+        isCompactSummary: item.isCompactSummary || false, // Preserve compact summary flag
+        uuid: item.uuid || null, // Include UUID for message identification
+        type: item.type || null // Include type field
+      };
+      
+      processedMessages.push(parsed);
+    }
+    
+    return processedMessages;
   }
 
   /**
@@ -363,11 +436,11 @@ class ConversationAnalyzer {
   }
 
   /**
-   * Extract project name from Claude directory file path
+   * Extract project name from Claude directory file path using settings.json
    * @param {string} filePath - Full path to conversation file
-   * @returns {string|null} Project name or null
+   * @returns {Promise<string|null>} Project name or null
    */
-  extractProjectFromPath(filePath) {
+  async extractProjectFromPath(filePath) {
     // Extract project name from file path like:
     // /Users/user/.claude/projects/-Users-user-Projects-MyProject/conversation.jsonl
     const pathParts = filePath.split('/');
@@ -375,34 +448,73 @@ class ConversationAnalyzer {
 
     if (projectIndex !== -1 && projectIndex + 1 < pathParts.length) {
       const projectDir = pathParts[projectIndex + 1];
-      // Clean up the project directory name
-      const cleanName = projectDir
-        .replace(/^-/, '')
-        .replace(/-/g, '/')
-        .split('/')
-        .pop() || 'Unknown';
-
-      return cleanName;
+      
+      // Try to read the settings.json file for this project
+      try {
+        const projectPath = path.join(path.dirname(filePath)); // Directory containing the conversation file
+        const settingsPath = path.join(projectPath, 'settings.json');
+        
+        if (await fs.pathExists(settingsPath)) {
+          const settingsContent = await fs.readFile(settingsPath, 'utf8');
+          const settings = JSON.parse(settingsContent);
+          
+          if (settings.projectName) {
+            return settings.projectName;
+          }
+          
+          // If no projectName in settings, try to extract from projectPath
+          if (settings.projectPath) {
+            return path.basename(settings.projectPath);
+          }
+        }
+      } catch (error) {
+        // If we can't read settings.json, fall back to parsing the directory name
+        console.warn(chalk.yellow(`Warning: Could not read settings.json for project ${projectDir}:`, error.message));
+      }
+      
+      // Fallback: we'll extract project name from conversation content instead
+      // For now, return null to trigger reading from conversation file
+      return null;
     }
 
     return null;
   }
 
+
   /**
    * Attempt to extract project information from conversation content
-   * @param {Array} messages - Array of message objects
-   * @returns {string} Project name or 'Unknown'
-   */
-  extractProjectFromConversation(messages) {
-    // Try to extract project information from conversation
-    for (const message of messages.slice(0, 5)) {
-      if (message.content && typeof message.content === 'string') {
-        const pathMatch = message.content.match(/\/([^\/\s]+)$/);
-        if (pathMatch) {
-          return pathMatch[1];
+   * @param {string} filePath - Path to the conversation file
+   * @returns {Promise<string>} Project name or 'Unknown'
+   */
+  async extractProjectFromConversation(filePath) {
+    try {
+      // Read the conversation file and look for cwd field
+      const content = await this.getFileContent(filePath);
+      const lines = content.trim().split('\n').filter(line => line.trim());
+      
+      for (const line of lines.slice(0, 10)) { // Check first 10 lines
+        try {
+          const item = JSON.parse(line);
+          
+          // Look for cwd field in the message
+          if (item.cwd) {
+            const projectName = path.basename(item.cwd);
+            return projectName;
+          }
+          
+          // Also check if it's in nested objects
+          if (item.message && item.message.cwd) {
+            return path.basename(item.message.cwd);
+          }
+        } catch (parseError) {
+          // Skip invalid JSON lines
+          continue;
         }
       }
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Could not extract project from conversation ${filePath}:`, error.message));
     }
+    
     return 'Unknown';
   }
 
@@ -576,7 +688,8 @@ class ConversationAnalyzer {
     const totalFileSize = conversations.reduce((sum, conv) => sum + conv.fileSize, 0);
 
     // Calculate real Claude sessions (5-hour periods)
-    const claudeSessions = await this.calculateClaudeSessions(conversations);
+    const claudeSessionsResult = await this.calculateClaudeSessions(conversations);
+    const claudeSessions = claudeSessionsResult?.total || 0;
 
     return {
       totalConversations,
@@ -585,8 +698,11 @@ class ConversationAnalyzer {
       activeProjects,
       avgTokensPerConversation,
       totalFileSize: this.formatBytes(totalFileSize),
+      dataSize: this.formatBytes(totalFileSize), // Alias for original dashboard compatibility
       lastActivity: conversations.length > 0 ? conversations[0].lastModified : null,
       claudeSessions,
+      claudeSessionsDetail: claudeSessions > 0 ? `${claudeSessions} session${claudeSessions > 1 ? 's' : ''}` : 'no sessions',
+      claudeSessionsFullData: claudeSessionsResult, // Keep full session data for detailed analysis
     };
   }
 

package/src/analytics/core/FileWatcher.js

@@ -11,6 +11,8 @@ class FileWatcher {
     this.watchers = [];
     this.intervals = [];
     this.isActive = false;
+    this.fileActivity = new Map(); // Track file activity for typing detection
+    this.typingTimeout = new Map(); // Track typing timeouts
   }
 
   /**
@@ -20,13 +22,14 @@ class FileWatcher {
    * @param {Function} processRefreshCallback - Callback to refresh process data
    * @param {Object} dataCache - DataCache instance for invalidation
    */
-  setupFileWatchers(claudeDir, dataRefreshCallback, processRefreshCallback, dataCache = null) {
+  setupFileWatchers(claudeDir, dataRefreshCallback, processRefreshCallback, dataCache = null, conversationChangeCallback = null) {
     console.log(chalk.blue('👀 Setting up file watchers for real-time updates...'));
 
     this.claudeDir = claudeDir;
     this.dataRefreshCallback = dataRefreshCallback;
     this.processRefreshCallback = processRefreshCallback;
     this.dataCache = dataCache;
+    this.conversationChangeCallback = conversationChangeCallback;
 
     this.setupConversationWatcher();
     this.setupProjectWatcher();
@@ -47,21 +50,28 @@ class FileWatcher {
     });
 
     conversationWatcher.on('change', async (filePath) => {
-      console.log(chalk.yellow('🔄 Conversation file changed, updating data...'));
+      
+      // Extract conversation ID from file path
+      const conversationId = this.extractConversationId(filePath);
+      
+      // Enhanced file activity detection for typing
+      await this.handleFileActivity(conversationId, filePath);
       
       // Invalidate cache for the changed file
       if (this.dataCache && filePath) {
         this.dataCache.invalidateFile(filePath);
       }
       
+      // Notify specific conversation change if callback exists
+      if (this.conversationChangeCallback && conversationId) {
+        await this.conversationChangeCallback(conversationId, filePath);
+      }
+      
       await this.triggerDataRefresh();
-      console.log(chalk.green('✅ Data updated'));
     });
 
     conversationWatcher.on('add', async () => {
-      console.log(chalk.yellow('📝 New conversation file detected...'));
       await this.triggerDataRefresh();
-      console.log(chalk.green('✅ Data updated'));
     });
 
     this.watchers.push(conversationWatcher);
@@ -78,15 +88,11 @@ class FileWatcher {
     });
 
     projectWatcher.on('addDir', async () => {
-      console.log(chalk.yellow('📁 New project directory detected...'));
       await this.triggerDataRefresh();
-      console.log(chalk.green('✅ Data updated'));
     });
 
     projectWatcher.on('change', async () => {
-      console.log(chalk.yellow('📁 Project directory changed...'));
       await this.triggerDataRefresh();
-      console.log(chalk.green('✅ Data updated'));
     });
 
     this.watchers.push(projectWatcher);
@@ -98,7 +104,6 @@ class FileWatcher {
   setupPeriodicRefresh() {
     // Periodic refresh to catch any missed changes (reduced frequency)
     const dataRefreshInterval = setInterval(async () => {
-      console.log(chalk.blue('⏱️  Periodic data refresh...'));
       await this.triggerDataRefresh();
     }, 120000); // Every 2 minutes (reduced from 30 seconds)
 
@@ -114,6 +119,137 @@ class FileWatcher {
     this.intervals.push(processRefreshInterval);
   }
 
+  /**
+   * Extract conversation ID from file path
+   * @param {string} filePath - Path to the conversation file
+   * @returns {string|null} Conversation ID or null if not found
+   */
+  extractConversationId(filePath) {
+    try {
+      // Handle different path formats:
+      // /Users/user/.claude/projects/PROJECT_NAME/conversation.jsonl -> PROJECT_NAME
+      // /Users/user/.claude/CONVERSATION_ID.jsonl -> CONVERSATION_ID
+      
+      const pathParts = filePath.split(path.sep);
+      const fileName = pathParts[pathParts.length - 1];
+      
+      if (fileName === 'conversation.jsonl') {
+        // Project-based conversation
+        const projectName = pathParts[pathParts.length - 2];
+        return projectName;
+      } else if (fileName.endsWith('.jsonl')) {
+        // Direct conversation file
+        return fileName.replace('.jsonl', '');
+      }
+      
+      return null;
+    } catch (error) {
+      console.error(chalk.red('Error extracting conversation ID:'), error);
+      return null;
+    }
+  }
+
+  /**
+   * Handle file activity for typing detection
+   * @param {string} conversationId - Conversation ID
+   * @param {string} filePath - File path that changed
+   */
+  async handleFileActivity(conversationId, filePath) {
+    if (!conversationId) return;
+
+    const fs = require('fs');
+    try {
+      // Get file stats
+      const stats = fs.statSync(filePath);
+      const now = Date.now();
+      const fileSize = stats.size;
+      const mtime = stats.mtime.getTime();
+
+      // Get previous activity
+      const previousActivity = this.fileActivity.get(conversationId) || {
+        lastSize: 0,
+        lastMtime: 0,
+        lastMessageCheck: 0
+      };
+
+      // Check if this is just a file touch/modification without significant content change
+      const sizeChanged = fileSize !== previousActivity.lastSize;
+      const timeChanged = mtime !== previousActivity.lastMtime;
+      const timeSinceLastCheck = now - previousActivity.lastMessageCheck;
+
+      // Update activity tracking
+      this.fileActivity.set(conversationId, {
+        lastSize: fileSize,
+        lastMtime: mtime,
+        lastMessageCheck: now
+      });
+
+      // If file changed but we haven't checked for complete messages recently
+      if ((sizeChanged || timeChanged) && timeSinceLastCheck > 1000) {
+        // Clear any existing typing timeout
+        const existingTimeout = this.typingTimeout.get(conversationId);
+        if (existingTimeout) {
+          clearTimeout(existingTimeout);
+        }
+
+        // Set a timeout to detect if this is typing activity
+        const typingTimeout = setTimeout(async () => {
+          // After delay, check if a complete message was added
+          await this.checkForTypingActivity(conversationId, filePath);
+        }, 2000); // Wait 2 seconds to see if a complete message appears
+
+        this.typingTimeout.set(conversationId, typingTimeout);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error handling file activity for ${conversationId}:`), error);
+    }
+  }
+
+  /**
+   * Check if file activity indicates user typing
+   * @param {string} conversationId - Conversation ID
+   * @param {string} filePath - File path to check
+   */
+  async checkForTypingActivity(conversationId, filePath) {
+    try {
+      // Parse the conversation to see if new complete messages were added
+      const ConversationAnalyzer = require('./ConversationAnalyzer');
+      const analyzer = new ConversationAnalyzer();
+      const messages = await analyzer.getParsedConversation(filePath);
+
+      if (messages && messages.length > 0) {
+        const lastMessage = messages[messages.length - 1];
+        const lastMessageTime = new Date(lastMessage.timestamp).getTime();
+        const now = Date.now();
+        const messageAge = now - lastMessageTime;
+
+        // If the last message is very recent (< 5 seconds), it's probably a new complete message
+        // If it's older, the file activity might indicate typing
+        if (messageAge > 5000 && lastMessage.role === 'assistant') {
+          // File activity after assistant message suggests user is typing
+          
+          // Send typing notification if we have access to notification manager
+          if (this.notificationManager) {
+            this.notificationManager.notifyConversationStateChange(conversationId, 'User typing...', {
+              detectionMethod: 'file_activity',
+              timestamp: new Date().toISOString()
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error checking typing activity for ${conversationId}:`), error);
+    }
+  }
+
+  /**
+   * Set notification manager for state notifications
+   * @param {Object} notificationManager - NotificationManager instance
+   */
+  setNotificationManager(notificationManager) {
+    this.notificationManager = notificationManager;
+  }
+
   /**
    * Trigger data refresh with error handling
    */
@@ -274,7 +410,6 @@ class FileWatcher {
    * Force immediate refresh
    */
   async forceRefresh() {
-    console.log(chalk.cyan('🔄 Force refreshing data...'));
     await this.triggerDataRefresh();
     if (this.processRefreshCallback) {
       await this.processRefreshCallback();