@codemafia0000/d0/src/lib/commands/analysis-commands.js

Claude Multi-Agent Automated Development AI - Revolutionary development environment where multiple AI agents collaborate to automate software development

const fs = require('fs');
const path = require('path');
const chalk = require('chalk');
const CONSTANTS = require('../constants');
const { isProjectSetup } = require('../setup/project-setup');
const { logAgentMessage, logTaskAction, getProjectHistory, displayHistory, generateAnalytics } = require('../history/session-history');

// Project analysis function
function analyzeProjectStructure(projectPath = CONSTANTS.PROJECT_ROOT) {
  const analysis = {
    hasPackageJson: false,
    hasGitRepo: false,
    framework: 'unknown',
    language: 'unknown',
    structure: {},
    suggestedRoles: []
  };
  
  try {
    // Check for package.json
    const packageJsonPath = path.join(projectPath, 'package.json');
    if (fs.existsSync(packageJsonPath)) {
      analysis.hasPackageJson = true;
      try {
        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
        
        // Detect framework
        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
        if (deps.react || deps['@types/react']) analysis.framework = 'React';
        else if (deps.vue || deps['@vue/core']) analysis.framework = 'Vue.js';
        else if (deps.angular || deps['@angular/core']) analysis.framework = 'Angular';
        else if (deps.next || deps['next']) analysis.framework = 'Next.js';
        else if (deps.express) analysis.framework = 'Express.js';
        else if (deps.fastify) analysis.framework = 'Fastify';
        
        // Detect language
        if (deps.typescript || deps['@types/node']) analysis.language = 'TypeScript';
        else if (packageJson.type === 'module' || deps.node) analysis.language = 'JavaScript';
      } catch (error) {
        console.warn(chalk.yellow('Warning: Could not parse package.json'));
      }
    }
    
    // Check for Git repository
    if (fs.existsSync(path.join(projectPath, '.git'))) {
      analysis.hasGitRepo = true;
    }
    
    // Analyze directory structure
    const commonDirs = ['src', 'lib', 'components', 'pages', 'api', 'server', 'client', 'public', 'assets'];
    for (const dir of commonDirs) {
      const dirPath = path.join(projectPath, dir);
      if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
        const files = fs.readdirSync(dirPath).slice(0, 10); // Limit to first 10 files
        analysis.structure[dir] = files;
      }
    }
    
    // Generate suggested roles
    analysis.suggestedRoles = generateSuggestedRoles(analysis);
    
  } catch (error) {
    console.warn(chalk.yellow(`Warning: Could not analyze project: ${error.message}`));
  }
  
  return analysis;
}

function generateSuggestedRoles(analysis) {
  const suggestions = [];
  
  // Frontend suggestions
  if (analysis.framework.includes('React') || analysis.framework.includes('Vue') || analysis.framework.includes('Angular')) {
    suggestions.push({
      role: 'Frontend Developer',
      reason: `${analysis.framework} framework detected`,
      priority: 'high'
    });
  }
  
  // Backend suggestions
  if (analysis.framework.includes('Express') || analysis.framework.includes('Fastify') || analysis.structure.api) {
    suggestions.push({
      role: 'Backend Developer',
      reason: 'Server-side framework or API directory detected',
      priority: 'high'
    });
  }
  
  // Full-stack suggestions
  if (analysis.framework.includes('Next.js') || (analysis.structure.pages && analysis.structure.api)) {
    suggestions.push({
      role: 'Full Stack Developer',
      reason: 'Full-stack framework detected',
      priority: 'high'
    });
  }
  
  // DevOps suggestions
  if (analysis.hasGitRepo) {
    suggestions.push({
      role: 'DevOps Engineer',
      reason: 'Git repository suggests need for CI/CD',
      priority: 'medium'
    });
  }
  
  // QA suggestions (always useful)
  suggestions.push({
    role: 'QA Engineer',
    reason: 'Testing and quality assurance needed',
    priority: 'medium'
  });
  
  return suggestions;
}

// Analyze project command handler
function handleAnalyzeProject() {
  if (!isProjectSetup()) {
    console.log(chalk.red('❌ Claude agents environment not found.'));
    console.log(chalk.yellow('Run "d0 init" first.'));
    return;
  }
  
  console.log(chalk.blue('🔍 Analyzing Project Structure...'));
  console.log('─'.repeat(50));
  
  const analysis = analyzeProjectStructure();
  
  // Display basic info
  console.log(chalk.green('📋 Project Information:'));
  console.log(`  Language: ${analysis.language}`);
  console.log(`  Framework: ${analysis.framework}`);
  console.log(`  Package.json: ${analysis.hasPackageJson ? '✓' : '✗'}`);
  console.log(`  Git repo: ${analysis.hasGitRepo ? '✓' : '✗'}`);
  
  // Display structure
  if (Object.keys(analysis.structure).length > 0) {
    console.log(chalk.blue('\n📁 Directory Structure:'));
    for (const [dir, files] of Object.entries(analysis.structure)) {
      console.log(chalk.cyan(`  ${dir}/`));
      files.slice(0, 3).forEach(file => {
        console.log(chalk.gray(`    ${file}`));
      });
      if (files.length > 3) {
        console.log(chalk.gray(`    ... and ${files.length - 3} more`));
      }
    }
  }
  
  // Display suggestions
  if (analysis.suggestedRoles.length > 0) {
    console.log(chalk.yellow('\n💡 Suggested Agent Roles:'));
    analysis.suggestedRoles.forEach(suggestion => {
      const priority = suggestion.priority === 'high' ? chalk.red('HIGH') : chalk.blue('MED');
      console.log(`  ${priority} ${suggestion.role}`);
      console.log(chalk.gray(`      ${suggestion.reason}`));
    });
  }
  
  console.log(chalk.blue('\n🚀 Next Steps:'));
  console.log(chalk.gray('  1. Review suggested roles above'));
  console.log(chalk.gray('  2. Adjust worker count if needed: d0 init --workers N'));
  console.log(chalk.gray('  3. Start agents: d0 start'));
  console.log(chalk.gray('  4. Begin project: d0 tell "Your project description"'));
}

// Auto setup command handler
async function handleAutoSetup() {
  console.log(chalk.blue('🤖 Auto Setup - Intelligent Environment Configuration'));
  console.log('─'.repeat(60));
  
  // Analyze project first
  const analysis = analyzeProjectStructure();
  
  console.log(chalk.green('📊 Analysis Results:'));
  console.log(`  Framework: ${analysis.framework}`);
  console.log(`  Language: ${analysis.language}`);
  
  // Determine optimal worker count
  let optimalWorkers = CONSTANTS.DEFAULT_WORKERS;
  if (analysis.suggestedRoles.length >= 4) {
    optimalWorkers = Math.min(5, analysis.suggestedRoles.length);
  } else if (analysis.framework === 'unknown') {
    optimalWorkers = 2; // Minimal setup for unknown projects
  }
  
  console.log(chalk.yellow(`\n🎯 Recommended Setup: ${optimalWorkers} workers`));
  
  // Show what will be set up
  console.log(chalk.blue('\n📋 Setup Plan:'));
  analysis.suggestedRoles.slice(0, optimalWorkers).forEach((role, index) => {
    console.log(`  Worker${index + 1}: ${role.role}`);
    console.log(chalk.gray(`    ${role.reason}`));
  });
  
  // Perform auto setup
  try {
    console.log(chalk.blue('\n🔄 Executing auto setup...'));
    const { setupProject } = require('../setup/project-setup');
    await setupProject({ workers: optimalWorkers.toString(), force: false });
    
    console.log(chalk.green('\n✅ Auto setup completed successfully!'));
    console.log(chalk.yellow('🚀 Ready to start with optimized configuration.'));
    
  } catch (error) {
    console.error(chalk.red('❌ Auto setup failed:'), error.message);
    process.exit(1);
  }
}

// History command handler
async function handleHistory(options) {
  if (!isProjectSetup()) {
    console.log(chalk.red('❌ Claude agents environment not found.'));
    console.log(chalk.yellow('Run "d0 init" first.'));
    return;
  }
  
  const type = options.type || 'all';
  const agent = options.agent || null;
  const days = parseInt(options.days) || CONSTANTS.DEFAULT_HISTORY_DAYS;
  
  try {
    const history = await getProjectHistory(type, agent, days);
    displayHistory(history, type);
  } catch (error) {
    console.error(chalk.red('❌ Error retrieving history:'), error.message);
    process.exit(1);
  }
}

// Analytics command handler
function handleAnalytics(options) {
  if (!isProjectSetup()) {
    console.log(chalk.red('❌ Claude agents environment not found.'));
    console.log(chalk.yellow('Run "d0 init" first.'));
    return;
  }
  
  const days = parseInt(options.days) || CONSTANTS.DEFAULT_ANALYTICS_DAYS;
  
  try {
    console.log(chalk.blue(`📈 Project Analytics (Last ${days} days)`));
    console.log('─'.repeat(50));
    
    const analytics = generateAnalytics(days);
    
    console.log(chalk.green(`📊 Overview:`));
    console.log(`  Total Events: ${analytics.totalEvents}`);
    console.log(`  Messages: ${analytics.messageCount}`);
    console.log(`  Tasks: ${analytics.taskCount}`);
    
    if (Object.keys(analytics.agentActivity).length > 0) {
      console.log(chalk.blue('\n👥 Agent Activity:'));
      Object.entries(analytics.agentActivity)
        .sort(([,a], [,b]) => b - a)
        .forEach(([agent, count]) => {
          const bar = '█'.repeat(Math.min(20, Math.ceil(count / Math.max(...Object.values(analytics.agentActivity)) * 20)));
          console.log(`  ${agent.padEnd(10)} ${bar} (${count})`);
        });
    }
    
    const peakHour = analytics.hourlyActivity.indexOf(Math.max(...analytics.hourlyActivity));
    console.log(chalk.yellow(`\n⏰ Peak Activity: ${peakHour}:00 (${analytics.hourlyActivity[peakHour]} events)`));
    
  } catch (error) {
    console.error(chalk.red('❌ Error generating analytics:'), error.message);
    process.exit(1);
  }
}

// Log message command handler
async function handleLogMessage(from, to, message) {
  try {
    await logAgentMessage(from, to, message);
    console.log(chalk.green('✅ Message logged successfully'));
  } catch (error) {
    console.error(chalk.red('❌ Error logging message:'), error.message);
    process.exit(1);
  }
}

// Log task command handler
async function handleLogTask(action, agent, task) {
  try {
    await logTaskAction(action, agent, task);
    console.log(chalk.green('✅ Task logged successfully'));
  } catch (error) {
    console.error(chalk.red('❌ Error logging task:'), error.message);
    process.exit(1);
  }
}

module.exports = {
  handleAnalyzeProject,
  handleAutoSetup,
  handleHistory,
  handleAnalytics,
  handleLogMessage,
  handleLogTask,
  analyzeProjectStructure,
  generateSuggestedRoles
};