claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/batch-manager.js

@@ -0,0 +1,338 @@
+// batch-manager.js - Batch configuration management utility
+import { printSuccess, printError, printInfo, printWarning } from '../utils.js';
+import { promises as fs } from 'fs';
+import { PROJECT_TEMPLATES, ENVIRONMENT_CONFIGS } from './init/batch-init.js';
+import { cwd, exit, existsSync } from '../node-compat.js';
+
+export async function batchManagerCommand(subArgs, flags) {
+  const command = subArgs[0];
+
+  switch (command) {
+    case 'create-config':
+      return await createBatchConfig(subArgs.slice(1), flags);
+    case 'validate-config':
+      return await validateBatchConfig(subArgs.slice(1), flags);
+    case 'list-templates':
+      return listTemplates();
+    case 'list-environments':
+      return listEnvironments();
+    case 'estimate':
+      return await estimateBatchOperation(subArgs.slice(1), flags);
+    case 'help':
+    default:
+      return showBatchManagerHelp();
+  }
+}
+
+async function createBatchConfig(args, flags) {
+  const outputFile = args[0] || 'batch-config.json';
+  const interactive = flags.interactive || flags.i;
+
+  if (interactive) {
+    return await createInteractiveConfig(outputFile);
+  }
+
+  // Create basic template
+  const config = {
+    projects: ['project1', 'project2', 'project3'],
+    baseOptions: {
+      sparc: true,
+      parallel: true,
+      maxConcurrency: 5,
+      template: 'web-api',
+      environments: ['dev'],
+    },
+  };
+
+  try {
+    await fs.writeFile(outputFile, JSON.stringify(config, null, 2, 'utf8'));
+    printSuccess(`Created batch configuration template: ${outputFile}`);
+    console.log('Edit the file to customize your batch initialization setup.');
+  } catch (error) {
+    printError(`Failed to create config file: ${error.message}`);
+  }
+}
+
+async function createInteractiveConfig(outputFile) {
+  console.log('🚀 Interactive Batch Configuration Creator');
+  console.log('==========================================\n');
+
+  // This would require a proper CLI prompt library in a real implementation
+  // For now, we'll create a comprehensive template with comments
+  const config = {
+    _comment: 'Batch initialization configuration',
+    _templates: Object.keys(PROJECT_TEMPLATES),
+    _environments: Object.keys(ENVIRONMENT_CONFIGS),
+
+    baseOptions: {
+      sparc: true,
+      parallel: true,
+      maxConcurrency: 5,
+      force: false,
+      minimal: false,
+      progressTracking: true,
+    },
+
+    projects: {
+      _simple_list: ['project1', 'project2', 'project3'],
+      _or_use_projectConfigs_below: 'for individual customization',
+    },
+
+    projectConfigs: {
+      'example-api': {
+        template: 'web-api',
+        environment: 'dev',
+        customConfig: {
+          database: 'postgresql',
+          auth: 'jwt',
+        },
+      },
+      'example-frontend': {
+        template: 'react-app',
+        environment: 'dev',
+        customConfig: {
+          ui: 'material-ui',
+          state: 'redux',
+        },
+      },
+    },
+  };
+
+  try {
+    await fs.writeFile(outputFile, JSON.stringify(config, null, 2, 'utf8'));
+    printSuccess(`Created interactive batch configuration: ${outputFile}`);
+    console.log('\nNext steps:');
+    console.log('1. Edit the configuration file to match your needs');
+    console.log('2. Remove the "_comment" and example entries');
+    console.log('3. Use either "projects" array OR "projectConfigs" object');
+    console.log(`4. Run: claude-flow init --config ${outputFile}`);
+  } catch (error) {
+    printError(`Failed to create interactive config: ${error.message}`);
+  }
+}
+
+async function validateBatchConfig(args, flags) {
+  const configFile = args[0];
+
+  if (!configFile) {
+    printError('Please specify a configuration file to validate');
+    return;
+  }
+
+  try {
+    const content = await fs.readFile(configFile, 'utf8');
+    const config = JSON.parse(content);
+
+    console.log(`📋 Validating batch configuration: ${configFile}`);
+    console.log('================================================\n');
+
+    const issues = [];
+    const warnings = [];
+
+    // Validate structure
+    if (!config.projects && !config.projectConfigs) {
+      issues.push('Missing "projects" array or "projectConfigs" object');
+    }
+
+    if (config.projects && config.projectConfigs) {
+      warnings.push(
+        'Both "projects" and "projectConfigs" specified. "projectConfigs" will take precedence.',
+      );
+    }
+
+    // Validate base options
+    if (config.baseOptions) {
+      const { maxConcurrency, template, environments } = config.baseOptions;
+
+      if (maxConcurrency && (maxConcurrency < 1 || maxConcurrency > 20)) {
+        issues.push('maxConcurrency must be between 1 and 20');
+      }
+
+      if (template && !PROJECT_TEMPLATES[template]) {
+        issues.push(
+          `Unknown template: ${template}. Available: ${Object.keys(PROJECT_TEMPLATES).join(', ')}`,
+        );
+      }
+
+      if (environments) {
+        for (const env of environments) {
+          if (!ENVIRONMENT_CONFIGS[env]) {
+            issues.push(
+              `Unknown environment: ${env}. Available: ${Object.keys(ENVIRONMENT_CONFIGS).join(', ')}`,
+            );
+          }
+        }
+      }
+    }
+
+    // Validate project configs
+    if (config.projectConfigs) {
+      for (const [projectName, projectConfig] of Object.entries(config.projectConfigs)) {
+        if (projectConfig.template && !PROJECT_TEMPLATES[projectConfig.template]) {
+          issues.push(`Project ${projectName}: Unknown template ${projectConfig.template}`);
+        }
+
+        if (projectConfig.environment && !ENVIRONMENT_CONFIGS[projectConfig.environment]) {
+          issues.push(`Project ${projectName}: Unknown environment ${projectConfig.environment}`);
+        }
+      }
+    }
+
+    // Report results
+    if (issues.length === 0) {
+      printSuccess('✅ Configuration is valid!');
+
+      if (warnings.length > 0) {
+        console.log('\n⚠️  Warnings:');
+        warnings.forEach((warning) => console.log(`  - ${warning}`));
+      }
+
+      // Summary
+      console.log('\n📊 Configuration Summary:');
+      const projectCount = config.projects
+        ? config.projects.length
+        : config.projectConfigs
+          ? Object.keys(config.projectConfigs).length
+          : 0;
+      console.log(`  Projects: ${projectCount}`);
+
+      if (config.baseOptions) {
+        console.log(`  Parallel: ${config.baseOptions.parallel ? 'Yes' : 'No'}`);
+        console.log(`  Max Concurrency: ${config.baseOptions.maxConcurrency || 5}`);
+        console.log(`  SPARC: ${config.baseOptions.sparc ? 'Enabled' : 'Disabled'}`);
+        console.log(`  Template: ${config.baseOptions.template || 'default'}`);
+      }
+    } else {
+      printError('❌ Configuration has issues:');
+      issues.forEach((issue) => console.error(`  - ${issue}`));
+
+      if (warnings.length > 0) {
+        console.log('\n⚠️  Warnings:');
+        warnings.forEach((warning) => console.log(`  - ${warning}`));
+      }
+    }
+  } catch (error) {
+    if (error instanceof Deno.errors.NotFound) {
+      printError(`Configuration file not found: ${configFile}`);
+    } else if (error instanceof SyntaxError) {
+      printError(`Invalid JSON in configuration file: ${error.message}`);
+    } else {
+      printError(`Failed to validate configuration: ${error.message}`);
+    }
+  }
+}
+
+function listTemplates() {
+  console.log('📋 Available Project Templates');
+  console.log('==============================\n');
+
+  for (const [key, template] of Object.entries(PROJECT_TEMPLATES)) {
+    console.log(`🏗️  ${key}`);
+    console.log(`   Name: ${template.name}`);
+    console.log(`   Description: ${template.description}`);
+    console.log(`   Extra Directories: ${template.extraDirs ? template.extraDirs.length : 0}`);
+    console.log(
+      `   Extra Files: ${template.extraFiles ? Object.keys(template.extraFiles).length : 0}`,
+    );
+    console.log();
+  }
+}
+
+function listEnvironments() {
+  console.log('🌍 Available Environment Configurations');
+  console.log('=======================================\n');
+
+  for (const [key, env] of Object.entries(ENVIRONMENT_CONFIGS)) {
+    console.log(`⚙️  ${key}`);
+    console.log(`   Name: ${env.name}`);
+    console.log(`   Features: ${env.features.join(', ')}`);
+    console.log(`   Config Variables: ${Object.keys(env.config).length}`);
+    console.log();
+  }
+}
+
+async function estimateBatchOperation(args, flags) {
+  const configFile = args[0];
+
+  if (!configFile) {
+    printError('Please specify a configuration file to estimate');
+    return;
+  }
+
+  try {
+    const content = await fs.readFile(configFile, 'utf8');
+    const config = JSON.parse(content);
+
+    console.log('⏱️  Batch Operation Estimation');
+    console.log('=============================\n');
+
+    let projectCount = 0;
+    let totalEnvironments = 0;
+
+    if (config.projects) {
+      projectCount = config.projects.length;
+      const environments = config.baseOptions?.environments || ['dev'];
+      totalEnvironments = projectCount * environments.length;
+    } else if (config.projectConfigs) {
+      projectCount = Object.keys(config.projectConfigs).length;
+      totalEnvironments = projectCount; // Each project has its own environment
+    }
+
+    const parallel = config.baseOptions?.parallel !== false;
+    const maxConcurrency = config.baseOptions?.maxConcurrency || 5;
+    const avgTimePerProject = 15; // seconds estimate
+
+    const sequentialTime = totalEnvironments * avgTimePerProject;
+    const parallelTime = parallel
+      ? Math.ceil(totalEnvironments / maxConcurrency) * avgTimePerProject
+      : sequentialTime;
+
+    console.log(`📊 Project Count: ${projectCount}`);
+    console.log(`🌍 Total Environments: ${totalEnvironments}`);
+    console.log(`⚡ Parallel Processing: ${parallel ? 'Enabled' : 'Disabled'}`);
+    console.log(`🔄 Max Concurrency: ${maxConcurrency}`);
+    console.log();
+    console.log(`⏱️  Estimated Time:`);
+    console.log(`   Sequential: ~${Math.ceil(sequentialTime / 60)} minutes`);
+    console.log(`   Parallel: ~${Math.ceil(parallelTime / 60)} minutes`);
+    console.log(`   Time Savings: ${Math.ceil((sequentialTime - parallelTime) / 60)} minutes`);
+    console.log();
+    console.log(`💾 Estimated Disk Usage:`);
+    console.log(`   Per Project: ~50-200 MB`);
+    console.log(`   Total: ~${Math.ceil((totalEnvironments * 125) / 1024)} GB`);
+  } catch (error) {
+    printError(`Failed to estimate batch operation: ${error.message}`);
+  }
+}
+
+function showBatchManagerHelp() {
+  console.log('🛠️  Batch Manager - Configuration and Estimation Tools');
+  console.log('====================================================\n');
+
+  console.log('USAGE:');
+  console.log('  claude-flow batch <command> [options]\n');
+
+  console.log('COMMANDS:');
+  console.log('  create-config [file]     Create batch configuration template');
+  console.log('  validate-config <file>   Validate batch configuration file');
+  console.log('  list-templates          Show available project templates');
+  console.log('  list-environments       Show available environment configs');
+  console.log('  estimate <config>       Estimate time and resources for batch operation');
+  console.log('  help                    Show this help message\n');
+
+  console.log('OPTIONS:');
+  console.log('  --interactive, -i       Create interactive configuration');
+  console.log('  --help, -h             Show command help\n');
+
+  console.log('EXAMPLES:');
+  console.log('  claude-flow batch create-config my-batch.json');
+  console.log('  claude-flow batch create-config --interactive');
+  console.log('  claude-flow batch validate-config my-batch.json');
+  console.log('  claude-flow batch estimate my-batch.json');
+  console.log('  claude-flow batch list-templates');
+  console.log('  claude-flow batch list-environments\n');
+
+  console.log('INTEGRATION:');
+  console.log('  Use created configs with: claude-flow init --config <file>');
+  console.log('  Or batch init directly: claude-flow init --batch-init project1,project2');
+}

package/src/cli/simple-commands/claude-telemetry.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Code Telemetry Integration
+ * Captures real token usage from Claude Code CLI
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+import { trackTokens } from './token-tracker.js';
+
+// Claude session data locations (platform-specific)
+const CLAUDE_DATA_PATHS = [
+  path.join(os.homedir(), '.claude', 'sessions'),
+  path.join(os.homedir(), '.config', 'claude', 'sessions'),
+  path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'sessions'),
+];
+
+/**
+ * Parse Claude session JSONL files for token usage
+ */
+async function parseClaudeSessionData(sessionId) {
+  for (const dataPath of CLAUDE_DATA_PATHS) {
+    try {
+      const sessionFile = path.join(dataPath, `${sessionId}.jsonl`);
+      const exists = await fs
+        .access(sessionFile)
+        .then(() => true)
+        .catch(() => false);
+
+      if (!exists) continue;
+
+      const content = await fs.readFile(sessionFile, 'utf-8');
+      const lines = content.trim().split('\n');
+
+      let totalInput = 0;
+      let totalOutput = 0;
+
+      for (const line of lines) {
+        try {
+          const data = JSON.parse(line);
+          if (data.usage) {
+            totalInput += data.usage.input_tokens || 0;
+            totalOutput += data.usage.output_tokens || 0;
+          }
+        } catch (e) {
+          // Skip invalid JSON lines
+        }
+      }
+
+      return { inputTokens: totalInput, outputTokens: totalOutput };
+    } catch (error) {
+      // Continue to next path
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract token usage from Claude CLI output
+ */
+function parseClaudeOutput(output) {
+  const tokenRegex = /(\d+)\s+tokens?\s+\((input|output|total)\)/gi;
+  const costRegex = /\$(\d+\.\d+)/g;
+
+  const tokens = { input: 0, output: 0, total: 0 };
+  const costs = [];
+
+  let match;
+  while ((match = tokenRegex.exec(output)) !== null) {
+    const count = parseInt(match[1]);
+    const type = match[2].toLowerCase();
+    tokens[type] = count;
+  }
+
+  while ((match = costRegex.exec(output)) !== null) {
+    costs.push(parseFloat(match[1]));
+  }
+
+  return { tokens, costs };
+}
+
+/**
+ * Wrap Claude CLI execution with telemetry
+ */
+export async function runClaudeWithTelemetry(args, options = {}) {
+  const sessionId = options.sessionId || `claude-${Date.now()}`;
+  const agentType = options.agentType || 'claude-cli';
+  const command = args.join(' ');
+
+  // Enable telemetry environment variables
+  const env = {
+    ...process.env,
+    CLAUDE_CODE_ENABLE_TELEMETRY: '1',
+    OTEL_METRICS_EXPORTER: process.env.OTEL_METRICS_EXPORTER || 'console',
+    OTEL_LOGS_EXPORTER: process.env.OTEL_LOGS_EXPORTER || 'console',
+  };
+
+  return new Promise((resolve, reject) => {
+    const claude = spawn('claude', args, {
+      env,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    // Create readline interface for real-time output
+    const rlOut = readline.createInterface({
+      input: claude.stdout,
+      terminal: false,
+    });
+
+    const rlErr = readline.createInterface({
+      input: claude.stderr,
+      terminal: false,
+    });
+
+    rlOut.on('line', (line) => {
+      console.log(line);
+      stdout += line + '\n';
+
+      // Look for token usage in real-time
+      const usage = parseClaudeOutput(line);
+      if (usage.tokens.input > 0 || usage.tokens.output > 0) {
+        trackTokens({
+          sessionId,
+          agentType,
+          command,
+          inputTokens: usage.tokens.input,
+          outputTokens: usage.tokens.output,
+          metadata: { costs: usage.costs },
+        }).catch(console.error);
+      }
+    });
+
+    rlErr.on('line', (line) => {
+      console.error(line);
+      stderr += line + '\n';
+    });
+
+    claude.on('exit', async (code) => {
+      // Try to parse session data after completion
+      const sessionData = await parseClaudeSessionData(sessionId);
+      if (sessionData) {
+        await trackTokens({
+          sessionId,
+          agentType,
+          command,
+          inputTokens: sessionData.inputTokens,
+          outputTokens: sessionData.outputTokens,
+          metadata: { source: 'session_file' },
+        });
+      }
+
+      // Also parse full output for any missed tokens
+      const fullUsage = parseClaudeOutput(stdout + stderr);
+      if (fullUsage.tokens.input > 0 || fullUsage.tokens.output > 0) {
+        await trackTokens({
+          sessionId,
+          agentType,
+          command,
+          inputTokens: fullUsage.tokens.input,
+          outputTokens: fullUsage.tokens.output,
+          metadata: { source: 'output_parse', costs: fullUsage.costs },
+        });
+      }
+
+      resolve({ code, stdout, stderr });
+    });
+
+    claude.on('error', reject);
+  });
+}
+
+/**
+ * Monitor Claude session for token usage
+ */
+export async function monitorClaudeSession(sessionId, interval = 5000) {
+  console.log(`📊 Monitoring Claude session: ${sessionId}`);
+  console.log(`   Checking every ${interval / 1000} seconds for token updates...\n`);
+
+  let lastTokens = { input: 0, output: 0 };
+
+  const monitor = setInterval(async () => {
+    const data = await parseClaudeSessionData(sessionId);
+
+    if (data) {
+      const inputDiff = data.inputTokens - lastTokens.input;
+      const outputDiff = data.outputTokens - lastTokens.output;
+
+      if (inputDiff > 0 || outputDiff > 0) {
+        console.log(`🔄 Token Update Detected:`);
+        console.log(`   Input:  +${inputDiff} (Total: ${data.inputTokens})`);
+        console.log(`   Output: +${outputDiff} (Total: ${data.outputTokens})`);
+
+        await trackTokens({
+          sessionId,
+          agentType: 'claude-monitor',
+          command: 'session_monitor',
+          inputTokens: inputDiff,
+          outputTokens: outputDiff,
+          metadata: {
+            totalInput: data.inputTokens,
+            totalOutput: data.outputTokens,
+          },
+        });
+
+        lastTokens = data;
+      }
+    }
+  }, interval);
+
+  // Return stop function
+  return () => {
+    clearInterval(monitor);
+    console.log(`\n✅ Stopped monitoring session: ${sessionId}`);
+  };
+}
+
+/**
+ * Extract token usage from /cost command
+ */
+export async function extractCostCommand() {
+  return new Promise((resolve, reject) => {
+    const claude = spawn('claude', ['/cost'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    claude.stdin.write('\n');
+    claude.stdin.end();
+
+    let output = '';
+
+    claude.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    claude.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+
+    claude.on('exit', () => {
+      const usage = parseClaudeOutput(output);
+      resolve(usage);
+    });
+
+    claude.on('error', reject);
+  });
+}
+
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'wrap':
+      // Wrap Claude command with telemetry
+      const claudeArgs = process.argv.slice(3);
+      runClaudeWithTelemetry(claudeArgs)
+        .then((result) => process.exit(result.code))
+        .catch((error) => {
+          console.error('Error:', error);
+          process.exit(1);
+        });
+      break;
+
+    case 'monitor':
+      // Monitor a session
+      const sessionId = process.argv[3] || 'current';
+      const stopMonitor = await monitorClaudeSession(sessionId);
+
+      // Handle graceful shutdown
+      process.on('SIGINT', () => {
+        stopMonitor();
+        process.exit(0);
+      });
+      break;
+
+    case 'cost':
+      // Extract current session cost
+      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]}`);
+      }
+      break;
+
+    default:
+      console.log(`
+Claude Telemetry Integration
+
+Usage:
+  claude-telemetry wrap <claude-args>    Run Claude with telemetry
+  claude-telemetry monitor [session-id]  Monitor session for tokens
+  claude-telemetry cost                  Get current session cost
+
+Examples:
+  claude-telemetry wrap chat "Hello"
+  claude-telemetry monitor claude-123456
+  claude-telemetry cost
+`);
+  }
+}