gemini-flow/bin/gemini-flow-cli.js

🧠 Gemini Flow - AI-Powered Development Orchestration with Google Gemini API Integration

#!/usr/bin/env node

/**
 * 🧠 Gemini Flow CLI - Production-Ready Entry Point
 * AI-Powered Development Orchestration with Google Gemini API
 * 
 * This is the main executable for the gemini-flow NPM package
 */

const { program } = require('commander');
const chalk = require('chalk');
const figlet = require('figlet');
const boxen = require('boxen');
const ora = require('ora');
const fs = require('fs');
const path = require('path');

// Import core modules
const { GeminiClient } = require('../dist/api/gemini-client');
const { CoordinationEngine } = require('../dist/coordination/coordination-engine');
const { AgentManager } = require('../dist/managers/agent-manager');

// Version from package.json
const packageJson = require('../package.json');
const VERSION = packageJson.version;

/**
 * Display fancy CLI banner
 */
function showBanner() {
  console.log(
    chalk.cyan(
      figlet.textSync('Gemini Flow', {
        font: 'ANSI Shadow',
        horizontalLayout: 'default',
        verticalLayout: 'default'
      })
    )
  );
  
  console.log(
    boxen(
      chalk.white(`🧠 AI-Powered Development Orchestration\n`) +
      chalk.gray(`Version: ${VERSION}\n`) +
      chalk.gray(`Google Gemini API Integration\n`) +
      chalk.yellow(`Ready for multi-agent coordination!`),
      {
        padding: 1,
        margin: 1,
        borderStyle: 'round',
        borderColor: 'cyan'
      }
    )
  );
}

/**
 * Initialize Gemini Flow in current directory
 */
async function initializeProject() {
  const spinner = ora('Initializing Gemini Flow project...').start();
  
  try {
    // Create .gemini-flow directory
    const geminiDir = path.join(process.cwd(), '.gemini-flow');
    if (!fs.existsSync(geminiDir)) {
      fs.mkdirSync(geminiDir, { recursive: true });
      fs.mkdirSync(path.join(geminiDir, 'memory'), { recursive: true });
      fs.mkdirSync(path.join(geminiDir, 'agents'), { recursive: true });
      fs.mkdirSync(path.join(geminiDir, 'coordination'), { recursive: true });
    }
    
    // Create default config
    const defaultConfig = {
      features: {
        autoTopologySelection: true,
        parallelExecution: true,
        neuralTraining: true,
        smartAutoSpawning: true,
        crossSessionMemory: true,
        githubIntegration: true
      },
      performance: {
        maxAgents: 10,
        defaultTopology: "hierarchical",
        executionStrategy: "parallel",
        tokenOptimization: true,
        cacheEnabled: true,
        telemetryLevel: "detailed"
      },
      gemini: {
        model: "gemini-1.5-pro",
        maxTokens: 8192,
        temperature: 0.7,
        apiEndpoint: "https://generativelanguage.googleapis.com/v1beta"
      }
    };
    
    fs.writeFileSync(
      path.join(geminiDir, 'config.json'),
      JSON.stringify(defaultConfig, null, 2)
    );
    
    // Create GEMINI.md if it doesn't exist
    const geminiMdPath = path.join(process.cwd(), 'GEMINI.md');
    if (!fs.existsSync(geminiMdPath)) {
      const geminiMdContent = fs.readFileSync(
        path.join(__dirname, '..', 'GEMINI.md'),
        'utf8'
      );
      fs.writeFileSync(geminiMdPath, geminiMdContent);
    }
    
    spinner.succeed('Gemini Flow initialized successfully!');
    
    console.log(chalk.green('\n✅ Project initialized with:'));
    console.log(chalk.gray('   📁 .gemini-flow/ - Configuration directory'));
    console.log(chalk.gray('   📄 GEMINI.md - Project documentation'));
    console.log(chalk.gray('   ⚙️  config.json - Performance settings'));
    console.log(chalk.yellow('\n🔑 Next: Set your GEMINI_API_KEY environment variable'));
    console.log(chalk.cyan('   export GEMINI_API_KEY="your-api-key-here"'));
    
  } catch (error) {
    spinner.fail(`Initialization failed: ${error.message}`);
    process.exit(1);
  }
}

/**
 * Main CLI setup
 */
function setupCLI() {
  program
    .name('gemini-flow')
    .description('🧠 Gemini Flow - AI-Powered Development Orchestration')
    .version(VERSION)
    .option('-v, --verbose', 'Enable verbose logging')
    .option('--no-banner', 'Disable startup banner')
    .hook('preAction', (thisCommand) => {
      if (!thisCommand.opts().noBanner) {
        showBanner();
      }
    });

  // Initialize command
  program
    .command('init')
    .description('Initialize Gemini Flow in current project')
    .option('--force', 'Force initialization even if already exists')
    .action(initializeProject);

  // MCP Server command
  program
    .command('mcp')
    .description('Start MCP server for Claude Code integration')
    .option('-p, --port <port>', 'Server port', '3000')
    .option('--stdio', 'Use stdio transport instead of HTTP')
    .action(async (options) => {
      const spinner = ora('Starting MCP server...').start();
      try {
        // Import and start MCP server
        const { startMCPServer } = require('../dist/mcp/server');
        await startMCPServer(options);
        spinner.succeed(`MCP server running on port ${options.port}`);
      } catch (error) {
        spinner.fail(`MCP server failed: ${error.message}`);
        process.exit(1);
      }
    });

  // Swarm management
  program
    .command('swarm')
    .description('Manage agent swarms')
    .argument('[action]', 'Action: init, status, list, destroy')
    .option('-t, --topology <type>', 'Swarm topology', 'hierarchical')
    .option('-a, --agents <count>', 'Maximum agents', '5')
    .option('--strategy <strategy>', 'Execution strategy', 'parallel')
    .action(async (action = 'status', options) => {
      // Import swarm manager and execute action
      const { SwarmManager } = require('../dist/managers/swarm-manager');
      const manager = new SwarmManager();
      await manager.execute(action, options);
    });

  // Agent management  
  program
    .command('agent')
    .description('Manage individual agents')
    .argument('[action]', 'Action: spawn, list, metrics, terminate')
    .argument('[type]', 'Agent type: researcher, coder, analyst, etc.')
    .option('-c, --capabilities <caps>', 'Agent capabilities (comma-separated)')
    .option('-n, --name <name>', 'Custom agent name')
    .action(async (action = 'list', type, options) => {
      const { AgentManager } = require('../dist/managers/agent-manager');
      const manager = new AgentManager();
      await manager.execute(action, type, options);
    });

  // Memory management
  program
    .command('memory')
    .description('Manage persistent memory')
    .argument('[action]', 'Action: store, retrieve, list, clear')
    .option('-k, --key <key>', 'Memory key')
    .option('-v, --value <value>', 'Memory value')
    .option('-n, --namespace <ns>', 'Memory namespace', 'default')
    .action(async (action = 'list', options) => {
      const { MemoryManager } = require('../dist/managers/memory-manager');  
      const manager = new MemoryManager();
      await manager.execute(action, options);
    });

  // Hooks system
  program
    .command('hooks')
    .description('Execute coordination hooks')
    .argument('<event>', 'Hook event: pre-task, post-edit, notify, etc.')
    .option('--data <data>', 'Hook data (JSON string)')
    .option('--agent <id>', 'Target agent ID')
    .action(async (event, options) => {
      const { HooksManager } = require('../dist/managers/hooks-manager');
      const manager = new HooksManager();
      await manager.execute(event, options);
    });

  // SPARC workflows
  program
    .command('sparc')
    .description('Execute SPARC development workflows')
    .argument('[mode]', 'SPARC mode: spec, arch, code, test, refine')
    .argument('[task]', 'Task description')
    .option('--parallel', 'Enable parallel execution')
    .option('--agents <count>', 'Number of agents to use')
    .action(async (mode = 'help', task, options) => {
      const { SPARCManager } = require('../dist/managers/sparc-manager');
      const manager = new SPARCManager();
      await manager.execute(mode, task, options);
    });

  // Test command
  program
    .command('test')
    .description('Run Gemini Flow tests')
    .option('--integration', 'Run integration tests')
    .option('--mcp', 'Test MCP tools')
    .option('--performance', 'Run performance benchmarks')
    .action(async (options) => {
      const { TestManager } = require('../dist/managers/test-manager');
      const manager = new TestManager();
      await manager.execute(options);
    });

  // Health check
  program
    .command('health')
    .description('Check system health and dependencies')
    .option('--fix', 'Attempt to fix issues')
    .action(async (options) => {
      const { HealthManager } = require('../dist/managers/health-manager');
      const manager = new HealthManager();
      await manager.execute(options);
    });

  // Version info
  program
    .command('version')
    .description('Show detailed version information')
    .action(() => {
      console.log(chalk.cyan(`Gemini Flow v${VERSION}`));
      console.log(chalk.gray(`Node.js: ${process.version}`));
      console.log(chalk.gray(`Platform: ${process.platform} ${process.arch}`));
      console.log(chalk.gray(`NPM Package: gemini-flow@${VERSION}`));
    });

  return program;
}

/**
 * Main execution
 */
async function main() {
  try {
    const cli = setupCLI();
    await cli.parseAsync(process.argv);
  } catch (error) {
    console.error(chalk.red(`❌ Error: ${error.message}`));
    if (process.env.GEMINI_FLOW_DEBUG) {
      console.error(error.stack);
    }
    process.exit(1);
  }
}

// Handle unhandled rejections
process.on('unhandledRejection', (reason, promise) => {
  console.error(chalk.red('🔴 Unhandled Rejection:'), reason);
  process.exit(1);
});

process.on('uncaughtException', (error) => {
  console.error(chalk.red('🔴 Uncaught Exception:'), error);
  process.exit(1);
});

// Export for testing
if (require.main === module) {
  main();
} else {
  module.exports = { main, setupCLI };
}