ruvector/packages/agentic-synth/bin/cli.js

#!/usr/bin/env node

/**
 * Agentic Synth CLI
 * Production-ready CLI for synthetic data generation
 */

import { Command } from 'commander';
import { AgenticSynth } from '../dist/index.js';
import { readFileSync, writeFileSync, existsSync } from 'fs';
import { resolve, dirname } from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

const program = new Command();

// Helper to load JSON config file
function loadConfig(configPath) {
  try {
    if (!existsSync(configPath)) {
      throw new Error(`Config file not found: ${configPath}`);
    }
    const content = readFileSync(configPath, 'utf8');
    return JSON.parse(content);
  } catch (error) {
    if (error.message.includes('not found')) {
      throw error;
    }
    throw new Error(`Invalid JSON in config file: ${error.message}`);
  }
}

// Helper to load schema file
function loadSchema(schemaPath) {
  try {
    if (!existsSync(schemaPath)) {
      throw new Error(`Schema file not found: ${schemaPath}`);
    }
    const content = readFileSync(schemaPath, 'utf8');
    return JSON.parse(content);
  } catch (error) {
    if (error.message.includes('not found')) {
      throw error;
    }
    throw new Error(`Invalid JSON in schema file: ${error.message}`);
  }
}

program
  .name('agentic-synth')
  .description('AI-powered synthetic data generation for agentic systems')
  .version('0.1.0')
  .addHelpText('after', `
Examples:
  $ agentic-synth generate --count 100 --schema schema.json
  $ agentic-synth init --provider gemini
  $ agentic-synth doctor --verbose

Advanced Examples (via @ruvector/agentic-synth-examples):
  $ npx @ruvector/agentic-synth-examples dspy train --models gemini,claude
  $ npx @ruvector/agentic-synth-examples self-learn --task code-generation
  $ npx @ruvector/agentic-synth-examples list

Learn more:
  https://www.npmjs.com/package/@ruvector/agentic-synth-examples
  https://github.com/ruvnet/ruvector/tree/main/packages/agentic-synth
`);

program
  .command('generate')
  .description('Generate synthetic structured data')
  .option('-c, --count <number>', 'Number of records to generate', '10')
  .option('-s, --schema <path>', 'Path to JSON schema file')
  .option('-o, --output <path>', 'Output file path (JSON format)')
  .option('--seed <value>', 'Random seed for reproducibility')
  .option('-p, --provider <provider>', 'Model provider (gemini, openrouter)', 'gemini')
  .option('-m, --model <model>', 'Model name to use')
  .option('--format <format>', 'Output format (json, csv, array)', 'json')
  .option('--config <path>', 'Path to config file with provider settings')
  .action(async (options) => {
    try {
      // Load configuration
      let config = {
        provider: options.provider,
        model: options.model
      };

      // Load config file if provided
      if (options.config) {
        const fileConfig = loadConfig(resolve(options.config));
        config = { ...config, ...fileConfig };
      }

      // Ensure API key is set
      if (!config.apiKey && !process.env.GEMINI_API_KEY && !process.env.OPENROUTER_API_KEY) {
        console.error('Error: API key not found. Set GEMINI_API_KEY or OPENROUTER_API_KEY environment variable, or provide --config file.');
        process.exit(1);
      }

      // Initialize AgenticSynth
      const synth = new AgenticSynth(config);

      // Load schema if provided
      let schema = undefined;
      if (options.schema) {
        schema = loadSchema(resolve(options.schema));
      }

      // Parse count
      const count = parseInt(options.count, 10);
      if (isNaN(count) || count < 1) {
        throw new Error('Count must be a positive integer');
      }

      // Parse seed
      let seed = options.seed;
      if (seed) {
        const seedNum = parseInt(seed, 10);
        seed = isNaN(seedNum) ? seed : seedNum;
      }

      console.log(`Generating ${count} records...`);
      const startTime = Date.now();

      // Generate data using AgenticSynth
      const result = await synth.generateStructured({
        count,
        schema,
        seed,
        format: options.format
      });

      const duration = Date.now() - startTime;

      // Output results
      if (options.output) {
        const outputPath = resolve(options.output);
        writeFileSync(outputPath, JSON.stringify(result.data, null, 2));
        console.log(`✓ Generated ${result.metadata.count} records to ${outputPath}`);
      } else {
        console.log(JSON.stringify(result.data, null, 2));
      }

      // Display metadata
      console.error(`\nMetadata:`);
      console.error(`  Provider: ${result.metadata.provider}`);
      console.error(`  Model: ${result.metadata.model}`);
      console.error(`  Cached: ${result.metadata.cached}`);
      console.error(`  Duration: ${duration}ms`);
      console.error(`  Generated: ${result.metadata.generatedAt}`);

    } catch (error) {
      console.error('Error:', error.message);
      if (error.stack && process.env.DEBUG) {
        console.error('\nStack trace:');
        console.error(error.stack);
      }
      process.exit(1);
    }
  });

program
  .command('config')
  .description('Display or test configuration')
  .option('-f, --file <path>', 'Config file path to load')
  .option('-t, --test', 'Test configuration by initializing AgenticSynth')
  .action(async (options) => {
    try {
      let config = {};

      // Load config file if provided
      if (options.file) {
        config = loadConfig(resolve(options.file));
      }

      // Create instance to validate config
      const synth = new AgenticSynth(config);
      const currentConfig = synth.getConfig();

      console.log('Current Configuration:');
      console.log(JSON.stringify(currentConfig, null, 2));

      if (options.test) {
        console.log('\n✓ Configuration is valid and AgenticSynth initialized successfully');
      }

      // Check for API keys
      console.log('\nEnvironment Variables:');
      console.log(`  GEMINI_API_KEY: ${process.env.GEMINI_API_KEY ? '✓ Set' : '✗ Not set'}`);
      console.log(`  OPENROUTER_API_KEY: ${process.env.OPENROUTER_API_KEY ? '✓ Set' : '✗ Not set'}`);

    } catch (error) {
      console.error('Configuration error:', error.message);
      if (error.stack && process.env.DEBUG) {
        console.error('\nStack trace:');
        console.error(error.stack);
      }
      process.exit(1);
    }
  });

program
  .command('validate')
  .description('Validate configuration and dependencies')
  .option('-f, --file <path>', 'Config file path to validate')
  .action(async (options) => {
    try {
      let config = {};

      // Load config file if provided
      if (options.file) {
        config = loadConfig(resolve(options.file));
        console.log('✓ Config file is valid JSON');
      }

      // Validate by creating instance
      const synth = new AgenticSynth(config);
      console.log('✓ Configuration schema is valid');

      // Check provider settings
      const currentConfig = synth.getConfig();
      console.log(`✓ Provider: ${currentConfig.provider}`);
      console.log(`✓ Model: ${currentConfig.model || 'default'}`);
      console.log(`✓ Cache strategy: ${currentConfig.cacheStrategy}`);
      console.log(`✓ Max retries: ${currentConfig.maxRetries}`);
      console.log(`✓ Timeout: ${currentConfig.timeout}ms`);

      // Validate API key
      if (!currentConfig.apiKey && !process.env.GEMINI_API_KEY && !process.env.OPENROUTER_API_KEY) {
        console.warn('⚠ Warning: No API key found. Set GEMINI_API_KEY or OPENROUTER_API_KEY environment variable.');
      } else {
        console.log('✓ API key is configured');
      }

      console.log('\n✓ All validations passed');

    } catch (error) {
      console.error('Validation error:', error.message);
      if (error.stack && process.env.DEBUG) {
        console.error('\nStack trace:');
        console.error(error.stack);
      }
      process.exit(1);
    }
  });

program
  .command('init')
  .description('Initialize a new agentic-synth configuration file')
  .option('-f, --force', 'Overwrite existing config file')
  .option('-p, --provider <provider>', 'Model provider (gemini, openrouter)', 'gemini')
  .option('-o, --output <path>', 'Output config file path', '.agentic-synth.json')
  .action(async (options) => {
    try {
      const configPath = resolve(options.output);

      // Check if file exists
      if (existsSync(configPath) && !options.force) {
        console.error(`Error: Config file already exists at ${configPath}`);
        console.error('Use --force to overwrite');
        process.exit(1);
      }

      // Create default configuration
      const defaultConfig = {
        provider: options.provider,
        model: options.provider === 'gemini' ? 'gemini-2.0-flash-exp' : 'anthropic/claude-3-opus',
        cacheStrategy: 'memory',
        maxRetries: 3,
        timeout: 30000,
        debug: false
      };

      // Write config file
      writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
      console.log(`✓ Created configuration file: ${configPath}`);
      console.log('\nNext steps:');
      console.log('1. Set your API key:');
      if (options.provider === 'gemini') {
        console.log('   export GEMINI_API_KEY="your-api-key"');
      } else {
        console.log('   export OPENROUTER_API_KEY="your-api-key"');
      }
      console.log('2. Edit the config file to customize settings');
      console.log('3. Run: agentic-synth doctor');
      console.log('4. Generate data: agentic-synth generate --config .agentic-synth.json');

    } catch (error) {
      console.error('Error creating config:', error.message);
      if (error.stack && process.env.DEBUG) {
        console.error('\nStack trace:');
        console.error(error.stack);
      }
      process.exit(1);
    }
  });

program
  .command('doctor')
  .description('Run comprehensive diagnostics on environment and configuration')
  .option('-f, --file <path>', 'Config file path to check')
  .option('-v, --verbose', 'Show detailed diagnostic information')
  .action(async (options) => {
    try {
      console.log('🔍 Running diagnostics...\n');

      let errorCount = 0;
      let warningCount = 0;

      // Check 1: Node.js version
      console.log('1. Node.js Environment:');
      const nodeVersion = process.version;
      const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
      if (majorVersion >= 18) {
        console.log(`   ✓ Node.js ${nodeVersion} (compatible)`);
      } else {
        console.log(`   ✗ Node.js ${nodeVersion} (requires >= 18.0.0)`);
        errorCount++;
      }

      // Check 2: Environment variables
      console.log('\n2. API Keys:');
      const hasGeminiKey = !!process.env.GEMINI_API_KEY;
      const hasOpenRouterKey = !!process.env.OPENROUTER_API_KEY;

      if (hasGeminiKey) {
        console.log('   ✓ GEMINI_API_KEY is set');
        if (options.verbose) {
          console.log(`     Value: ${process.env.GEMINI_API_KEY.substring(0, 10)}...`);
        }
      } else {
        console.log('   ✗ GEMINI_API_KEY not set');
        warningCount++;
      }

      if (hasOpenRouterKey) {
        console.log('   ✓ OPENROUTER_API_KEY is set');
        if (options.verbose) {
          console.log(`     Value: ${process.env.OPENROUTER_API_KEY.substring(0, 10)}...`);
        }
      } else {
        console.log('   ✗ OPENROUTER_API_KEY not set');
        warningCount++;
      }

      if (!hasGeminiKey && !hasOpenRouterKey) {
        console.log('   ⚠ Warning: No API keys configured. At least one is required.');
        errorCount++;
      }

      // Check 3: Configuration file
      console.log('\n3. Configuration:');
      let config = {};
      if (options.file) {
        try {
          config = loadConfig(resolve(options.file));
          console.log(`   ✓ Config file loaded: ${options.file}`);
          if (options.verbose) {
            console.log(`     Content: ${JSON.stringify(config, null, 6)}`);
          }
        } catch (error) {
          console.log(`   ✗ Failed to load config: ${error.message}`);
          errorCount++;
        }
      } else {
        const defaultPaths = ['.agentic-synth.json', 'agentic-synth.json', 'config.json'];
        let found = false;
        for (const path of defaultPaths) {
          if (existsSync(path)) {
            config = loadConfig(path);
            console.log(`   ✓ Auto-detected config: ${path}`);
            found = true;
            break;
          }
        }
        if (!found) {
          console.log('   ⚠ No config file found (using defaults)');
          warningCount++;
        }
      }

      // Check 4: AgenticSynth initialization
      console.log('\n4. Package Initialization:');
      try {
        const synth = new AgenticSynth(config);
        const currentConfig = synth.getConfig();
        console.log('   ✓ AgenticSynth initialized successfully');
        console.log(`   ✓ Provider: ${currentConfig.provider}`);
        console.log(`   ✓ Model: ${currentConfig.model || 'default'}`);
        console.log(`   ✓ Cache: ${currentConfig.cacheStrategy}`);
        console.log(`   ✓ Max retries: ${currentConfig.maxRetries}`);
        console.log(`   ✓ Timeout: ${currentConfig.timeout}ms`);
      } catch (error) {
        console.log(`   ✗ Failed to initialize: ${error.message}`);
        errorCount++;
      }

      // Check 5: Dependencies
      console.log('\n5. Dependencies:');
      try {
        // Check if required packages are available
        const packages = [
          '@google/generative-ai',
          'commander',
          'dotenv',
          'zod'
        ];

        for (const pkg of packages) {
          try {
            await import(pkg);
            console.log(`   ✓ ${pkg}`);
          } catch (err) {
            console.log(`   ✗ ${pkg} not found`);
            errorCount++;
          }
        }
      } catch (error) {
        console.log(`   ✗ Dependency check failed: ${error.message}`);
        errorCount++;
      }

      // Check 6: File system permissions
      console.log('\n6. File System:');
      try {
        const testPath = resolve('.agentic-synth-test.tmp');
        writeFileSync(testPath, 'test');
        readFileSync(testPath);
        // Clean up
        import('fs').then(fs => fs.unlinkSync(testPath));
        console.log('   ✓ Read/write permissions OK');
      } catch (error) {
        console.log('   ✗ File system permissions issue');
        errorCount++;
      }

      // Summary
      console.log('\n' + '='.repeat(50));
      if (errorCount === 0 && warningCount === 0) {
        console.log('✓ All checks passed! Your environment is ready.');
      } else {
        if (errorCount > 0) {
          console.log(`✗ Found ${errorCount} error(s)`);
        }
        if (warningCount > 0) {
          console.log(`⚠ Found ${warningCount} warning(s)`);
        }
        console.log('\nRecommendations:');
        if (!hasGeminiKey && !hasOpenRouterKey) {
          console.log('- Set at least one API key (GEMINI_API_KEY or OPENROUTER_API_KEY)');
        }
        if (errorCount > 0) {
          console.log('- Fix errors above before using agentic-synth');
        }
        if (!options.file && warningCount > 0) {
          console.log('- Run: agentic-synth init');
          console.log('- Then: agentic-synth doctor --file .agentic-synth.json');
        }
      }
      console.log('='.repeat(50));

      process.exit(errorCount > 0 ? 1 : 0);

    } catch (error) {
      console.error('Doctor command error:', error.message);
      if (error.stack && process.env.DEBUG) {
        console.error('\nStack trace:');
        console.error(error.stack);
      }
      process.exit(1);
    }
  });

// Error handler for unknown commands
program.on('command:*', function () {
  console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
  process.exit(1);
});

// Show help if no command provided
if (process.argv.length === 2) {
  program.help();
}

program.parse();