claude-code-templates 1.12.2 → 1.13.1

package/src/analytics.js

@@ -10,6 +10,7 @@ const ProcessDetector = require('./analytics/core/ProcessDetector');
 const ConversationAnalyzer = require('./analytics/core/ConversationAnalyzer');
 const FileWatcher = require('./analytics/core/FileWatcher');
 const SessionAnalyzer = require('./analytics/core/SessionAnalyzer');
+const AgentAnalyzer = require('./analytics/core/AgentAnalyzer');
 const DataCache = require('./analytics/data/DataCache');
 const WebSocketServer = require('./analytics/notifications/WebSocketServer');
 const NotificationManager = require('./analytics/notifications/NotificationManager');
@@ -24,6 +25,7 @@ class ClaudeAnalytics {
     this.processDetector = new ProcessDetector();
     this.fileWatcher = new FileWatcher();
     this.sessionAnalyzer = new SessionAnalyzer();
+    this.agentAnalyzer = new AgentAnalyzer();
     this.dataCache = new DataCache();
     this.performanceMonitor = new PerformanceMonitor({
       enabled: true,
@@ -667,6 +669,28 @@ class ClaudeAnalytics {
       }
     });
 
+    // Agent usage analytics endpoint
+    this.app.get('/api/agents', async (req, res) => {
+      try {
+        const startDate = req.query.startDate;
+        const endDate = req.query.endDate;
+        const dateRange = (startDate || endDate) ? { startDate, endDate } : null;
+        
+        const agentAnalysis = await this.agentAnalyzer.analyzeAgentUsage(this.data.conversations, dateRange);
+        const agentSummary = this.agentAnalyzer.generateSummary(agentAnalysis);
+        
+        res.json({
+          ...agentAnalysis,
+          summary: agentSummary,
+          dateRange,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('Error getting agent analytics:', error);
+        res.status(500).json({ error: 'Failed to get agent analytics' });
+      }
+    });
+
     this.app.get('/api/realtime', async (req, res) => {
       const realtimeWithTimestamp = {
         ...this.data.realtimeStats,
@@ -1661,12 +1685,88 @@ class ClaudeAnalytics {
       const timeSinceLastUpdate = now - lastUpdate;
       const timeSinceLastUpdateMinutes = Math.floor(timeSinceLastUpdate / (1000 * 60));
       
-      // Based on observed pattern: ~2 hours and 21 minutes session limit
-      const sessionLimitMs = 2 * 60 * 60 * 1000 + 21 * 60 * 1000; // 2h 21m
-      const timeRemaining = sessionLimitMs - sessionDuration;
-      const timeRemainingMinutes = Math.floor(timeRemaining / (1000 * 60));
-      const timeRemainingHours = Math.floor(timeRemainingMinutes / 60);
-      const remainingMinutesDisplay = timeRemainingMinutes % 60;
+      // CORRECTED: Calculate next reset time based on scheduled reset hours
+      // Claude sessions reset at specific times, not fixed durations
+      const resetHours = [1, 7, 13, 19]; // 1am, 7am, 1pm, 7pm local time
+      const sessionStartDate = new Date(startTime);
+      
+      // Find next reset time after session start
+      let nextResetTime = new Date(sessionStartDate);
+      nextResetTime.setMinutes(0, 0, 0); // Set to exact hour
+      
+      // Find the next reset hour
+      let foundReset = false;
+      for (let i = 0; i < resetHours.length * 2; i++) { // Check up to 2 full days
+        const currentDay = Math.floor(i / resetHours.length);
+        const hourIndex = i % resetHours.length;
+        const resetHour = resetHours[hourIndex];
+        
+        const testResetTime = new Date(sessionStartDate);
+        testResetTime.setDate(testResetTime.getDate() + currentDay);
+        testResetTime.setHours(resetHour, 0, 0, 0);
+        
+        if (testResetTime > sessionStartDate) {
+          nextResetTime = testResetTime;
+          foundReset = true;
+          break;
+        }
+      }
+      
+      if (!foundReset) {
+        // Fallback: assume next day 7am if no pattern found
+        nextResetTime.setDate(nextResetTime.getDate() + 1);
+        nextResetTime.setHours(7, 0, 0, 0);
+      }
+      
+      const sessionLimitMs = nextResetTime.getTime() - startTime;
+      let timeRemaining = nextResetTime.getTime() - now;
+      let timeRemainingMinutes = Math.floor(timeRemaining / (1000 * 60));
+      let timeRemainingHours = Math.floor(timeRemainingMinutes / 60);
+      let remainingMinutesDisplay = timeRemainingMinutes % 60;
+      
+      // If session is expired but has recent activity, calculate next reset time
+      if (timeRemaining <= 0) {
+        const RECENT_ACTIVITY_THRESHOLD = 5 * 60 * 1000; // 5 minutes
+        const timeSinceLastUpdate = now - lastUpdate;
+        
+        if (timeSinceLastUpdate < RECENT_ACTIVITY_THRESHOLD) {
+          // Session was renewed, find the NEXT reset time
+          let nextNextResetTime = new Date(nextResetTime);
+          let foundNextReset = false;
+          
+          for (let i = 0; i < resetHours.length; i++) {
+            const resetHour = resetHours[i];
+            const testResetTime = new Date(nextResetTime);
+            
+            if (resetHour > nextResetTime.getHours()) {
+              // Same day, later hour
+              testResetTime.setHours(resetHour, 0, 0, 0);
+            } else {
+              // Next day
+              testResetTime.setDate(testResetTime.getDate() + 1);
+              testResetTime.setHours(resetHour, 0, 0, 0);
+            }
+            
+            if (testResetTime > nextResetTime) {
+              nextNextResetTime = testResetTime;
+              foundNextReset = true;
+              break;
+            }
+          }
+          
+          if (!foundNextReset) {
+            // Default to next day 1am
+            nextNextResetTime.setDate(nextNextResetTime.getDate() + 1);
+            nextNextResetTime.setHours(1, 0, 0, 0);
+          }
+          
+          timeRemaining = nextNextResetTime.getTime() - now;
+          timeRemainingMinutes = Math.floor(timeRemaining / (1000 * 60));
+          timeRemainingHours = Math.floor(timeRemainingMinutes / 60);
+          remainingMinutesDisplay = timeRemainingMinutes % 60;
+          nextResetTime = nextNextResetTime;
+        }
+      }
       
       return {
         hasSession: true,
@@ -1691,13 +1791,15 @@ class ClaudeAnalytics {
           hours: timeRemainingHours,
           remainingMinutes: remainingMinutesDisplay,
           formatted: timeRemaining > 0 ? `${timeRemainingHours}h ${remainingMinutesDisplay}m` : 'Session expired',
-          isExpired: timeRemaining <= 0
+          isExpired: timeRemaining <= 0 && timeSinceLastUpdate >= (5 * 60 * 1000) // Expired only if past reset time AND no recent activity
         },
         sessionLimit: {
           ms: sessionLimitMs,
-          hours: 2,
-          minutes: 21,
-          formatted: '2h 21m'
+          hours: Math.floor(sessionLimitMs / (1000 * 60 * 60)),
+          minutes: Math.floor((sessionLimitMs % (1000 * 60 * 60)) / (1000 * 60)),
+          formatted: `${Math.floor(sessionLimitMs / (1000 * 60 * 60))}h ${Math.floor((sessionLimitMs % (1000 * 60 * 60)) / (1000 * 60))}m`,
+          nextResetTime: nextResetTime.toISOString(),
+          resetHour: nextResetTime.getHours()
         }
       };
     } catch (error) {

package/src/index.js

@@ -80,6 +80,22 @@ async function showMainMenu() {
 async function createClaudeConfig(options = {}) {
   const targetDir = options.directory || process.cwd();
   
+  // Handle individual component installation
+  if (options.agent) {
+    await installIndividualAgent(options.agent, targetDir, options);
+    return;
+  }
+  
+  if (options.command) {
+    await installIndividualCommand(options.command, targetDir, options);
+    return;
+  }
+  
+  if (options.mcp) {
+    await installIndividualMCP(options.mcp, targetDir, options);
+    return;
+  }
+  
   // Handle command stats analysis (both singular and plural)
   if (options.commandStats || options.commandsStats) {
     await runCommandStats(options);
@@ -253,4 +269,171 @@ async function createClaudeConfig(options = {}) {
   }
 }
 
+// Individual component installation functions
+async function installIndividualAgent(agentName, targetDir, options) {
+  console.log(chalk.blue(`🤖 Installing agent: ${agentName}`));
+  
+  try {
+    // Check if components directory exists
+    const componentsPath = path.join(__dirname, '..', 'components', 'agents');
+    const agentFile = path.join(componentsPath, `${agentName}.md`);
+    
+    if (!await fs.pathExists(agentFile)) {
+      console.log(chalk.red(`❌ Agent "${agentName}" not found`));
+      console.log(chalk.yellow('Available agents:'));
+      
+      // List available agents
+      if (await fs.pathExists(componentsPath)) {
+        const agents = await fs.readdir(componentsPath);
+        agents.filter(f => f.endsWith('.md')).forEach(agent => {
+          console.log(chalk.cyan(`  - ${agent.replace('.md', '')}`));
+        });
+      }
+      return;
+    }
+    
+    // For agents, they are typically part of templates, so we need to determine
+    // the appropriate language/framework and install the complete template
+    const agentContent = await fs.readFile(agentFile, 'utf8');
+    const language = extractLanguageFromAgent(agentContent, agentName);
+    const framework = extractFrameworkFromAgent(agentContent, agentName);
+    
+    console.log(chalk.yellow(`📝 Agent "${agentName}" is part of ${language}/${framework} template`));
+    console.log(chalk.blue('🚀 Installing complete template with this agent...'));
+    
+    // Install the template that contains this agent (avoid recursion)
+    const setupOptions = {
+      ...options,
+      language,
+      framework,
+      yes: true,
+      targetDirectory: targetDir,
+      agent: null // Remove agent to avoid recursion
+    };
+    delete setupOptions.agent;
+    await createClaudeConfig(setupOptions);
+    
+    console.log(chalk.green(`✅ Agent "${agentName}" installed successfully!`));
+    
+  } catch (error) {
+    console.log(chalk.red(`❌ Error installing agent: ${error.message}`));
+  }
+}
+
+async function installIndividualCommand(commandName, targetDir, options) {
+  console.log(chalk.blue(`⚡ Installing command: ${commandName}`));
+  
+  try {
+    // Check if components directory exists
+    const componentsPath = path.join(__dirname, '..', 'components', 'commands');
+    const commandFile = path.join(componentsPath, `${commandName}.md`);
+    
+    if (!await fs.pathExists(commandFile)) {
+      console.log(chalk.red(`❌ Command "${commandName}" not found`));
+      console.log(chalk.yellow('Available commands:'));
+      
+      // List available commands
+      if (await fs.pathExists(componentsPath)) {
+        const commands = await fs.readdir(componentsPath);
+        commands.filter(f => f.endsWith('.md')).forEach(command => {
+          console.log(chalk.cyan(`  - ${command.replace('.md', '')}`));
+        });
+      }
+      return;
+    }
+    
+    // Create .claude/commands directory if it doesn't exist
+    const commandsDir = path.join(targetDir, '.claude', 'commands');
+    await fs.ensureDir(commandsDir);
+    
+    // Copy the command file
+    const targetFile = path.join(commandsDir, `${commandName}.md`);
+    await fs.copy(commandFile, targetFile);
+    
+    console.log(chalk.green(`✅ Command "${commandName}" installed successfully!`));
+    console.log(chalk.cyan(`📁 Installed to: ${path.relative(targetDir, targetFile)}`));
+    
+  } catch (error) {
+    console.log(chalk.red(`❌ Error installing command: ${error.message}`));
+  }
+}
+
+async function installIndividualMCP(mcpName, targetDir, options) {
+  console.log(chalk.blue(`🔌 Installing MCP: ${mcpName}`));
+  
+  try {
+    // Check if components directory exists
+    const componentsPath = path.join(__dirname, '..', 'components', 'mcps');
+    const mcpFile = path.join(componentsPath, `${mcpName}.json`);
+    
+    if (!await fs.pathExists(mcpFile)) {
+      console.log(chalk.red(`❌ MCP "${mcpName}" not found`));
+      console.log(chalk.yellow('Available MCPs:'));
+      
+      // List available MCPs
+      if (await fs.pathExists(componentsPath)) {
+        const mcps = await fs.readdir(componentsPath);
+        mcps.filter(f => f.endsWith('.json')).forEach(mcp => {
+          console.log(chalk.cyan(`  - ${mcp.replace('.json', '')}`));
+        });
+      }
+      return;
+    }
+    
+    // Read the MCP configuration
+    const mcpConfig = await fs.readJson(mcpFile);
+    
+    // Check if .mcp.json exists in target directory
+    const targetMcpFile = path.join(targetDir, '.mcp.json');
+    let existingConfig = {};
+    
+    if (await fs.pathExists(targetMcpFile)) {
+      existingConfig = await fs.readJson(targetMcpFile);
+      console.log(chalk.yellow('📝 Existing .mcp.json found, merging configurations...'));
+    }
+    
+    // Merge configurations
+    const mergedConfig = {
+      ...existingConfig,
+      ...mcpConfig
+    };
+    
+    // Write the merged configuration
+    await fs.writeJson(targetMcpFile, mergedConfig, { spaces: 2 });
+    
+    console.log(chalk.green(`✅ MCP "${mcpName}" installed successfully!`));
+    console.log(chalk.cyan(`📁 Configuration merged into: ${path.relative(targetDir, targetMcpFile)}`));
+    
+  } catch (error) {
+    console.log(chalk.red(`❌ Error installing MCP: ${error.message}`));
+  }
+}
+
+// Helper functions to extract language/framework from agent content
+function extractLanguageFromAgent(content, agentName) {
+  // Try to determine language from agent content or filename
+  if (agentName.includes('react') || content.includes('React')) return 'javascript-typescript';
+  if (agentName.includes('django') || content.includes('Django')) return 'python';
+  if (agentName.includes('fastapi') || content.includes('FastAPI')) return 'python';
+  if (agentName.includes('flask') || content.includes('Flask')) return 'python';
+  if (agentName.includes('rails') || content.includes('Rails')) return 'ruby';
+  if (agentName.includes('api-security') || content.includes('API security')) return 'javascript-typescript';
+  if (agentName.includes('database') || content.includes('database')) return 'javascript-typescript';
+  
+  // Default to javascript-typescript for general agents
+  return 'javascript-typescript';
+}
+
+function extractFrameworkFromAgent(content, agentName) {
+  // Try to determine framework from agent content or filename
+  if (agentName.includes('react') || content.includes('React')) return 'react';
+  if (agentName.includes('django') || content.includes('Django')) return 'django';
+  if (agentName.includes('fastapi') || content.includes('FastAPI')) return 'fastapi';
+  if (agentName.includes('flask') || content.includes('Flask')) return 'flask';
+  if (agentName.includes('rails') || content.includes('Rails')) return 'rails';
+  
+  // For general agents, return none to install the base template
+  return 'none';
+}
+
 module.exports = { createClaudeConfig, showMainMenu };