claude-flow 2.0.0-alpha.87 → 2.0.0-alpha.89

package/src/cli/simple-commands/analysis.js

@@ -15,10 +15,94 @@ import {
   getBottleneckAnalysis,
   exportMetrics
 } from './performance-metrics.js';
+import {
+  getRealTokenUsage,
+  calculateCost,
+  generateOptimizationSuggestions,
+  generateTokenUsageReport,
+  getAgentIcon,
+  trackTokens
+} from './token-tracker.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+async function setupTelemetry() {
+  console.log(`\n🔧 TELEMETRY SETUP FOR TOKEN TRACKING\n`);
+  console.log(`${'═'.repeat(60)}\n`);
+  
+  // Check current status
+  const currentValue = process.env.CLAUDE_CODE_ENABLE_TELEMETRY;
+  const isEnabled = currentValue === '1';
+  
+  console.log(`📊 Current Status: ${isEnabled ? '✅ ENABLED' : '❌ DISABLED'}`);
+  console.log(`   Environment Variable: CLAUDE_CODE_ENABLE_TELEMETRY=${currentValue || 'not set'}\n`);
+  
+  if (!isEnabled) {
+    // Set the environment variable for current session
+    process.env.CLAUDE_CODE_ENABLE_TELEMETRY = '1';
+    
+    console.log(`✅ Telemetry ENABLED for this session!\n`);
+    
+    // Create or update .env file
+    const envPath = path.join(process.cwd(), '.env');
+    let envContent = '';
+    
+    try {
+      envContent = await fs.readFile(envPath, 'utf-8');
+    } catch (err) {
+      // .env doesn't exist yet
+    }
+    
+    // Check if telemetry is already in .env
+    if (!envContent.includes('CLAUDE_CODE_ENABLE_TELEMETRY')) {
+      envContent += `\n# Enable token tracking for Claude API calls\nCLAUDE_CODE_ENABLE_TELEMETRY=1\n`;
+      
+      try {
+        await fs.writeFile(envPath, envContent);
+        console.log(`📝 Updated .env file with telemetry setting`);
+      } catch (err) {
+        console.log(`⚠️  Could not update .env file: ${err.message}`);
+      }
+    }
+    
+    // Also add to shell profile for persistence
+    console.log(`\n📌 To make this permanent, add to your shell profile:`);
+    console.log(`   ${'-'.repeat(50)}`);
+    console.log(`   echo 'export CLAUDE_CODE_ENABLE_TELEMETRY=1' >> ~/.bashrc`);
+    console.log(`   ${'-'.repeat(50)}\n`);
+  }
+  
+  // Initialize token tracking directory
+  const metricsDir = path.join(process.cwd(), '.claude-flow', 'metrics');
+  try {
+    await fs.mkdir(metricsDir, { recursive: true });
+    console.log(`📁 Token tracking directory: ${metricsDir}`);
+  } catch (err) {
+    // Directory already exists
+  }
+  
+  // Check for existing token data
+  const tokenFile = path.join(metricsDir, 'token-usage.json');
+  try {
+    const data = await fs.readFile(tokenFile, 'utf-8');
+    const tokenData = JSON.parse(data);
+    console.log(`\n📊 Existing token data found:`);
+    console.log(`   • Total tokens tracked: ${tokenData.totals?.total || 0}`);
+    console.log(`   • Sessions recorded: ${Object.keys(tokenData.sessions || {}).length}`);
+  } catch (err) {
+    console.log(`\n📊 No existing token data (will be created on first use)`);
+  }
+  
+  console.log(`\n🚀 NEXT STEPS:`);
+  console.log(`   1. Run Claude commands with --claude flag`);
+  console.log(`   2. Example: ./claude-flow swarm "analyze code" --claude`);
+  console.log(`   3. Check usage: ./claude-flow analysis token-usage --breakdown`);
+  
+  console.log(`\n${'═'.repeat(60)}`);
+  printSuccess(`Telemetry setup complete!`);
+}
+
 export async function analysisAction(subArgs, flags) {
   const subcommand = subArgs[0];
   const options = flags;
@@ -28,6 +112,12 @@ export async function analysisAction(subArgs, flags) {
     return;
   }
 
+  // Handle telemetry setup
+  if (subcommand === 'setup-telemetry' || options['enable-telemetry']) {
+    await setupTelemetry();
+    if (subcommand === 'setup-telemetry') return;
+  }
+
   try {
     switch (subcommand) {
       case 'bottleneck-detect':
@@ -39,6 +129,12 @@ export async function analysisAction(subArgs, flags) {
       case 'token-usage':
         await tokenUsageCommand(subArgs, flags);
         break;
+      case 'claude-monitor':
+        await claudeMonitorCommand(subArgs, flags);
+        break;
+      case 'claude-cost':
+        await claudeCostCommand(subArgs, flags);
+        break;
       default:
         printError(`Unknown analysis command: ${subcommand}`);
         showAnalysisHelp();
@@ -207,43 +303,53 @@ async function tokenUsageCommand(subArgs, flags) {
     
     printSuccess(`✅ Token usage analysis completed`);
 
-    // Display real token usage
-    console.log(`\n🔢 TOKEN USAGE SUMMARY:`);
-    console.log(`  📝 Total tokens consumed: ${tokenData.total.toLocaleString()}`);
-    console.log(`  📥 Input tokens: ${tokenData.input.toLocaleString()} (${((tokenData.input / tokenData.total) * 100).toFixed(1)}%)`);
-    console.log(`  📤 Output tokens: ${tokenData.output.toLocaleString()} (${((tokenData.output / tokenData.total) * 100).toFixed(1)}%)`);
-    
-    if (costAnalysis) {
-      const cost = calculateCost(tokenData);
-      console.log(`  💰 Estimated cost: $${cost.total.toFixed(2)}`);
-      console.log(`     Input cost: $${cost.input.toFixed(2)}`);
-      console.log(`     Output cost: $${cost.output.toFixed(2)}`);
-    }
+    // Check if we have any data
+    if (tokenData.total === 0) {
+      // Show instructions when no data available
+      await showSimulatedTokenUsage(breakdown, costAnalysis);
+      
+      // Still generate empty report for consistency
+      const reportPath = await generateTokenUsageReport(tokenData, agent);
+      console.log(`\n📄 Detailed usage log: ${reportPath}`);
+    } else {
+      // Display real token usage
+      console.log(`\n🔢 TOKEN USAGE SUMMARY:`);
+      console.log(`  📝 Total tokens consumed: ${tokenData.total.toLocaleString()}`);
+      console.log(`  📥 Input tokens: ${tokenData.input.toLocaleString()} (${((tokenData.input / tokenData.total) * 100).toFixed(1)}%)`);
+      console.log(`  📤 Output tokens: ${tokenData.output.toLocaleString()} (${((tokenData.output / tokenData.total) * 100).toFixed(1)}%)`);
+      
+      if (costAnalysis) {
+        const cost = calculateCost(tokenData);
+        console.log(`  💰 Estimated cost: $${cost.total.toFixed(2)}`);
+        console.log(`     Input cost: $${cost.input.toFixed(2)}`);
+        console.log(`     Output cost: $${cost.output.toFixed(2)}`);
+      }
 
-    if (breakdown && tokenData.byAgent) {
-      console.log(`\n📊 BREAKDOWN BY AGENT TYPE:`);
-      Object.entries(tokenData.byAgent).forEach(([agentType, usage]) => {
-        const percentage = ((usage / tokenData.total) * 100).toFixed(1);
-        const icon = getAgentIcon(agentType);
-        console.log(`  ${icon} ${agentType}: ${usage.toLocaleString()} tokens (${percentage}%)`);
-      });
+      if (breakdown && tokenData.byAgent) {
+        console.log(`\n📊 BREAKDOWN BY AGENT TYPE:`);
+        Object.entries(tokenData.byAgent).forEach(([agentType, usage]) => {
+          const percentage = ((usage / tokenData.total) * 100).toFixed(1);
+          const icon = getAgentIcon(agentType);
+          console.log(`  ${icon} ${agentType}: ${usage.toLocaleString()} tokens (${percentage}%)`);
+        });
 
-      console.log(`\n💡 OPTIMIZATION OPPORTUNITIES:`);
-      const opportunities = generateOptimizationSuggestions(tokenData);
-      opportunities.forEach(suggestion => {
-        console.log(`  • ${suggestion}`);
-      });
-    }
+        console.log(`\n💡 OPTIMIZATION OPPORTUNITIES:`);
+        const opportunities = generateOptimizationSuggestions(tokenData);
+        opportunities.forEach(suggestion => {
+          console.log(`  • ${suggestion}`);
+        });
+      }
 
-    // Generate real CSV report
-    const reportPath = await generateTokenUsageReport(tokenData, agent);
-    console.log(`\n📄 Detailed usage log: ${reportPath}`);
+      // Generate real CSV report
+      const reportPath = await generateTokenUsageReport(tokenData, agent);
+      console.log(`\n📄 Detailed usage log: ${reportPath}`);
+    }
     
   } catch (err) {
     printError(`Failed to get real token usage: ${err.message}`);
-    printWarning('Falling back to simulated data...');
+    printWarning('Falling back to help instructions...');
     
-    // Fallback to simulated data
+    // Fallback to instructions
     await showSimulatedTokenUsage(breakdown, costAnalysis);
   }
 }
@@ -256,9 +362,25 @@ USAGE:
   claude-flow analysis <command> [options]
 
 COMMANDS:
+  setup-telemetry      Configure token tracking for Claude API calls
   bottleneck-detect    Detect performance bottlenecks in the system
   performance-report   Generate comprehensive performance reports
   token-usage          Analyze token consumption and costs
+  claude-monitor       Monitor Claude session for real-time token usage
+  claude-cost          Get current Claude session cost and usage
+
+GLOBAL OPTIONS:
+  --enable-telemetry   Enable token tracking for this session
+  --help, -h           Show this help message
+
+TELEMETRY SETUP:
+  claude-flow analysis setup-telemetry
+  
+  This command will:
+  • Set CLAUDE_CODE_ENABLE_TELEMETRY=1 in your environment
+  • Create .env file with telemetry settings
+  • Initialize token tracking directory
+  • Show current telemetry status
 
 BOTTLENECK DETECT OPTIONS:
   --scope <scope>      Analysis scope (default: system)
@@ -276,233 +398,163 @@ TOKEN USAGE OPTIONS:
   --agent <agent>      Filter by agent type or ID (default: all)
   --breakdown          Include detailed breakdown by agent type
   --cost-analysis      Include cost projections and optimization
+  --enable-telemetry   Enable token tracking for this session
+
+CLAUDE MONITOR OPTIONS:
+  --interval <ms>      Update interval in milliseconds (default: 5000)
+  
+  Usage: claude-flow analysis claude-monitor [session-id] [--interval 3000]
+  
+  Monitors a Claude session for real-time token usage updates.
+  Session ID defaults to 'current' if not specified.
+
+CLAUDE COST OPTIONS:
+  Usage: claude-flow analysis claude-cost
+  
+  Retrieves the current Claude session's token usage and cost estimate.
+  Works best when run during or immediately after a Claude session.
 
 EXAMPLES:
+  # First-time setup for token tracking
+  claude-flow analysis setup-telemetry
+
+  # Token usage with telemetry enabled
+  claude-flow analysis token-usage --enable-telemetry --breakdown
+
   # Detect system-wide bottlenecks
   claude-flow analysis bottleneck-detect --scope system
 
-  # Agent-specific bottleneck analysis
-  claude-flow analysis bottleneck-detect --scope agent --target coordinator-1
-
   # Weekly performance report
   claude-flow analysis performance-report --timeframe 7d --format detailed
 
-  # Token usage with breakdown
+  # Token usage with full analysis
   claude-flow analysis token-usage --breakdown --cost-analysis
 
-  # Swarm-specific analysis
-  claude-flow analysis bottleneck-detect --scope swarm --target swarm-123
+  # Monitor Claude session in real-time
+  claude-flow analysis claude-monitor
+
+  # Get current Claude session cost
+  claude-flow analysis claude-cost
+
+  # Run Claude with automatic token tracking
+  CLAUDE_CODE_ENABLE_TELEMETRY=1 claude-flow swarm "task" --claude
 
 🎯 Analysis helps with:
+  • Token usage tracking & cost management
   • Performance optimization
-  • Cost management
   • Resource allocation
   • Bottleneck identification
   • Trend analysis
+
+💡 TIP: Run 'analysis setup-telemetry' first to enable token tracking!
 `);
 }
 
-// Helper functions for real token tracking
+// Helper functions for real token tracking are now imported from token-tracker.js
 
-async function getRealTokenUsage(agent) {
-  // Check if Claude Code OpenTelemetry is configured
-  const isOTelEnabled = process.env.CLAUDE_CODE_ENABLE_TELEMETRY === '1';
+async function claudeMonitorCommand(subArgs, flags) {
+  const sessionId = subArgs[1] || 'current';
+  const interval = flags.interval || 5000;
   
-  if (!isOTelEnabled) {
-    // Try to read from local metrics file if OTel is not enabled
-    return await getLocalTokenMetrics(agent);
-  }
-  
-  // Get metrics from OpenTelemetry
-  return await getOTelTokenMetrics(agent);
-}
-
-async function getLocalTokenMetrics(agent) {
-  // Look for Claude Code metrics in standard locations
-  const metricsPath = path.join(process.env.HOME || '', '.claude', 'metrics', 'usage.json');
+  console.log(`📊 Starting Claude session monitor...`);
+  console.log(`   Session ID: ${sessionId}`);
+  console.log(`   Update interval: ${interval / 1000}s`);
+  console.log(`   Press Ctrl+C to stop monitoring\n`);
   
   try {
-    const data = await fs.readFile(metricsPath, 'utf8');
-    const metrics = JSON.parse(data);
+    // Import the telemetry module
+    const { monitorClaudeSession } = await import('./claude-telemetry.js');
     
-    // Extract token usage from metrics
-    const tokenData = {
-      total: 0,
-      input: 0,
-      output: 0,
-      byAgent: {}
-    };
+    // Start monitoring
+    const stopMonitor = await monitorClaudeSession(sessionId, interval);
     
-    // Process metrics based on Claude Code format
-    if (metrics.sessions) {
-      metrics.sessions.forEach(session => {
-        if (session.tokenUsage) {
-          tokenData.total += session.tokenUsage.total || 0;
-          tokenData.input += session.tokenUsage.input || 0;
-          tokenData.output += session.tokenUsage.output || 0;
-          
-          // Track by agent if available
-          if (session.agentType && (agent === 'all' || session.agentType === agent)) {
-            tokenData.byAgent[session.agentType] = 
-              (tokenData.byAgent[session.agentType] || 0) + (session.tokenUsage.total || 0);
-          }
-        }
-      });
-    }
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+      stopMonitor();
+      process.exit(0);
+    });
     
-    return tokenData;
-  } catch (err) {
-    // Fallback to environment variables or defaults
-    return getEnvironmentTokenMetrics(agent);
+    // Keep process running
+    await new Promise(() => {});
+  } catch (error) {
+    printError(`Failed to start Claude monitor: ${error.message}`);
+    console.log('\n💡 TIP: Make sure Claude is installed and accessible');
   }
 }
 
-async function getEnvironmentTokenMetrics(agent) {
-  // Check for token tracking in environment or config
-  const configPath = path.join(process.cwd(), '.claude-flow', 'token-usage.json');
+async function claudeCostCommand(subArgs, flags) {
+  console.log(`💰 Retrieving Claude session cost information...`);
   
   try {
-    const data = await fs.readFile(configPath, 'utf8');
-    return JSON.parse(data);
-  } catch (err) {
-    // Return empty data structure
-    return {
-      total: 0,
-      input: 0,
-      output: 0,
-      byAgent: {}
-    };
-  }
-}
-
-async function getOTelTokenMetrics(agent) {
-  // This would integrate with OpenTelemetry exporters
-  // For now, return placeholder implementation
-  return {
-    total: 0,
-    input: 0,
-    output: 0,
-    byAgent: {}
-  };
-}
-
-function calculateCost(tokenData) {
-  // Anthropic Claude pricing (as of knowledge cutoff)
-  // Claude 3 Opus: $15/$75 per million tokens (input/output)
-  // Claude 3 Sonnet: $3/$15 per million tokens
-  // Claude 3 Haiku: $0.25/$1.25 per million tokens
-  
-  // Default to Sonnet pricing for Claude Code
-  const inputPricePerMillion = 3.00;
-  const outputPricePerMillion = 15.00;
-  
-  return {
-    input: (tokenData.input / 1000000) * inputPricePerMillion,
-    output: (tokenData.output / 1000000) * outputPricePerMillion,
-    total: ((tokenData.input / 1000000) * inputPricePerMillion) + 
-           ((tokenData.output / 1000000) * outputPricePerMillion)
-  };
-}
-
-function getAgentIcon(agentType) {
-  const icons = {
-    'coordinator': '🎯',
-    'developer': '👨‍💻',
-    'researcher': '🔍',
-    'analyzer': '📊',
-    'tester': '🧪',
-    'architect': '🏗️',
-    'reviewer': '👁️'
-  };
-  return icons[agentType.toLowerCase()] || '🤖';
-}
-
-function generateOptimizationSuggestions(tokenData) {
-  const suggestions = [];
-  
-  // Analyze token usage patterns
-  if (tokenData.byAgent) {
-    Object.entries(tokenData.byAgent).forEach(([agentType, usage]) => {
-      const percentage = (usage / tokenData.total) * 100;
-      
-      if (percentage > 40) {
-        suggestions.push(`${agentType} agents: Consider prompt optimization (-15% potential)`);
-      }
-      if (percentage > 25) {
-        suggestions.push(`${agentType} agents: Implement response caching (-8% potential)`);
-      }
-    });
-  }
-  
-  // General suggestions based on total usage
-  if (tokenData.total > 100000) {
-    suggestions.push('Consider using Claude Haiku for non-critical tasks (-90% cost)');
-  }
-  
-  if (tokenData.output > tokenData.input * 2) {
-    suggestions.push('High output ratio: Consider more concise prompts');
+    // Import the telemetry module
+    const { extractCostCommand } = await import('./claude-telemetry.js');
+    
+    // Get cost data
+    const costData = await extractCostCommand();
+    
+    console.log('\n📊 Current Session Usage:');
+    console.log(`   Input Tokens:  ${costData.tokens.input || 0}`);
+    console.log(`   Output Tokens: ${costData.tokens.output || 0}`);
+    console.log(`   Total Tokens:  ${costData.tokens.total || 0}`);
+    
+    if (costData.costs.length > 0) {
+      console.log(`   Estimated Cost: $${costData.costs[0]}`);
+    }
+    
+    // Also show pricing info
+    console.log('\n💰 Claude 3 Pricing:');
+    console.log('   • Opus:   $15/1M input, $75/1M output');
+    console.log('   • Sonnet: $3/1M input, $15/1M output');
+    console.log('   • Haiku:  $0.25/1M input, $1.25/1M output');
+    
+  } catch (error) {
+    printError(`Failed to retrieve cost data: ${error.message}`);
+    console.log('\n💡 TIP: Run this while Claude is active or immediately after');
   }
-  
-  return suggestions.length > 0 ? suggestions : ['Token usage is within optimal range'];
 }
 
-async function generateTokenUsageReport(tokenData, agent) {
-  const reportsDir = path.join(process.cwd(), 'analysis-reports');
+async function showSimulatedTokenUsage(breakdown, costAnalysis) {
+  // Show honest message about no data instead of fake numbers
+  console.log(`\n🔢 TOKEN USAGE ANALYSIS:`);
+  console.log(`  ℹ️ No token usage data available yet.`);
   
-  // Create reports directory if it doesn't exist
-  try {
-    await fs.mkdir(reportsDir, { recursive: true });
-  } catch (err) {
-    // Directory might already exist
-  }
+  console.log(`\n📋 QUICK SETUP - Choose one option:`);
+  console.log(`\n  Option 1: Enable Telemetry (Recommended)`);
+  console.log(`  ┌────────────────────────────────────────────────────────┐`);
+  console.log(`  │ ./claude-flow analysis setup-telemetry                │`);
+  console.log(`  └────────────────────────────────────────────────────────┘`);
   
-  const timestamp = Date.now();
-  const reportPath = path.join(reportsDir, `token-usage-${timestamp}.csv`);
+  console.log(`\n  Option 2: Manual Environment Variable`);
+  console.log(`  ┌────────────────────────────────────────────────────────┐`);
+  console.log(`  │ export CLAUDE_CODE_ENABLE_TELEMETRY=1                 │`);
+  console.log(`  └────────────────────────────────────────────────────────┘`);
   
-  // Generate CSV content
-  let csvContent = 'Timestamp,Agent,Input Tokens,Output Tokens,Total Tokens,Cost\\n';
+  console.log(`\n  Option 3: Use --enable-telemetry Flag`);
+  console.log(`  ┌────────────────────────────────────────────────────────┐`);
+  console.log(`  │ ./claude-flow analysis token-usage --enable-telemetry │`);
+  console.log(`  └────────────────────────────────────────────────────────┘`);
   
-  if (tokenData.byAgent) {
-    Object.entries(tokenData.byAgent).forEach(([agentType, usage]) => {
-      const agentInput = Math.floor(usage * 0.6); // Estimate 60% input
-      const agentOutput = usage - agentInput;
-      const agentCost = calculateCost({ input: agentInput, output: agentOutput, total: usage });
-      
-      csvContent += `${new Date().toISOString()},${agentType},${agentInput},${agentOutput},${usage},$${agentCost.total.toFixed(4)}\\n`;
-    });
-  } else {
-    const cost = calculateCost(tokenData);
-    csvContent += `${new Date().toISOString()},${agent},${tokenData.input},${tokenData.output},${tokenData.total},$${cost.total.toFixed(4)}\\n`;
-  }
-  
-  // Write CSV file
-  await fs.writeFile(reportPath, csvContent);
-  
-  return reportPath;
-}
-
-async function showSimulatedTokenUsage(breakdown, costAnalysis) {
-  // Existing simulated data as fallback
-  console.log(`\n🔢 TOKEN USAGE SUMMARY (Simulated):`);
-  console.log(`  📝 Total tokens consumed: 45,231`);
-  console.log(`  📥 Input tokens: 28,567 (63.2%)`);
-  console.log(`  📤 Output tokens: 16,664 (36.8%)`);
+  console.log(`\n✅ AFTER SETUP:`);
+  console.log(`  1. Run Claude commands: ./claude-flow swarm "task" --claude`);
+  console.log(`  2. Token usage will be automatically tracked`);
+  console.log(`  3. Return here to see real metrics`);
   
   if (costAnalysis) {
-    console.log(`  💰 Estimated cost: $0.23`);
+    console.log(`\n💰 COST TRACKING:`);
+    console.log(`  • Claude 3 Opus: $15/1M input, $75/1M output tokens`);
+    console.log(`  • Claude 3 Sonnet: $3/1M input, $15/1M output tokens`);
+    console.log(`  • Claude 3 Haiku: $0.25/1M input, $1.25/1M output tokens`);
   }
 
   if (breakdown) {
-    console.log(`\\n📊 BREAKDOWN BY AGENT TYPE:`);
-    console.log(`  🎯 Coordinator: 12,430 tokens (27.5%)`);
-    console.log(`  👨‍💻 Developer: 18,965 tokens (41.9%)`);
-    console.log(`  🔍 Researcher: 8,734 tokens (19.3%)`);
-    console.log(`  📊 Analyzer: 5,102 tokens (11.3%)`);
-
-    console.log(`\\n💡 OPTIMIZATION OPPORTUNITIES:`);
-    console.log(`  • Developer agents: Consider prompt optimization (-15% potential)`);
-    console.log(`  • Coordinator agents: Implement response caching (-8% potential)`);
+    console.log(`\n📊 AGENT BREAKDOWN:`);
+    console.log(`  • Each agent type's usage tracked separately`);
+    console.log(`  • Identifies high-consumption agents`);
+    console.log(`  • Provides optimization recommendations`);
   }
 
-  console.log(`\\n📄 Note: Enable CLAUDE_CODE_ENABLE_TELEMETRY=1 for real metrics`);
+  console.log(`\n❓ TROUBLESHOOTING:`);
+  console.log(`  • Check telemetry status: echo $CLAUDE_CODE_ENABLE_TELEMETRY`);
+  console.log(`  • View raw data: cat .claude-flow/metrics/token-usage.json`);
+  console.log(`  • Reset tracking: rm -rf .claude-flow/metrics/token-usage.json`);
 }