@devilsdev/rag-pipeline-utils 2.3.1 → 2.4.0

package/src/cli/commands/ai-ml.js

@@ -1,19 +1,18 @@
 /**
  * Advanced AI/ML CLI Commands
  * Command-line interface for model training, adaptive retrieval, multi-modal processing, and federated learning
+ *
+ * This module is a thin aggregator that delegates to domain-specific modules
+ * in the ai-ml/ directory.
  */
 
-const chalk = require('chalk');
+const chalk = require("chalk");
 // eslint-disable-line global-require
-const ora = require('ora');
+const ora = require("ora");
 // eslint-disable-line global-require
-const inquirer = require('inquirer');
+const Table = require("cli-table3");
 // eslint-disable-line global-require
-const Table = require('cli-table3');
-// eslint-disable-line global-require
-const fs = require('fs').promises;
-// eslint-disable-line global-require
-const _path = require('path');
+const fs = require("fs").promises;
 // eslint-disable-line global-require
 
 const {
@@ -21,9 +20,18 @@ const {
   AdaptiveRetrievalEngine,
   MultiModalProcessor,
   FederatedLearningCoordinator,
-} = require('../../ai');
+} = require("../../ai");
 // eslint-disable-line global-require
 
+const {
+  trainingCommands,
+  adaptiveCommands,
+  multimodalCommands,
+  federatedCommands,
+} = require("./ai-ml/index");
+
+const { colorizeStatus, detectContentType } = require("./ai-ml/shared");
+
 class AIMLCommands {
   constructor() {
     this.modelTrainer = new ModelTrainingOrchestrator();
@@ -37,844 +45,280 @@ class AIMLCommands {
    */
   registerCommands(program) {
     const aiCommand = program
-      .command('ai')
-      .description('Advanced AI/ML capabilities');
+      .command("ai")
+      .description("Advanced AI/ML capabilities");
 
     // Model Training Commands
     const trainCommand = aiCommand
-      .command('train')
-      .description('Model training and fine-tuning');
+      .command("train")
+      .description("Model training and fine-tuning");
 
     trainCommand
-      .command('embedding')
-      .description('Train custom embedding model')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-d, --dataset <path>', 'Dataset path')
-      .option('-a, --architecture <arch>', 'Model architecture', 'transformer')
-      .option('-e, --epochs <num>', 'Number of epochs', '10')
-      .option('-b, --batch-size <size>', 'Batch size', '32')
-      .option('-l, --learning-rate <rate>', 'Learning rate', '0.001')
-      .option('--optimize', 'Enable hyperparameter optimization')
+      .command("embedding")
+      .description("Train custom embedding model")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-d, --dataset <path>", "Dataset path")
+      .option("-a, --architecture <arch>", "Model architecture", "transformer")
+      .option("-e, --epochs <num>", "Number of epochs", "10")
+      .option("-b, --batch-size <size>", "Batch size", "32")
+      .option("-l, --learning-rate <rate>", "Learning rate", "0.001")
+      .option("--optimize", "Enable hyperparameter optimization")
       .action(this.trainEmbeddingModel.bind(this));
 
     trainCommand
-      .command('llm')
-      .description('Fine-tune language model')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-d, --dataset <path>', 'Dataset path')
-      .option('-m, --base-model <model>', 'Base model', 'gpt-3.5-turbo')
-      .option('-e, --epochs <num>', 'Number of epochs', '5')
-      .option('--lora', 'Use LoRA fine-tuning')
+      .command("llm")
+      .description("Fine-tune language model")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-d, --dataset <path>", "Dataset path")
+      .option("-m, --base-model <model>", "Base model", "gpt-3.5-turbo")
+      .option("-e, --epochs <num>", "Number of epochs", "5")
+      .option("--lora", "Use LoRA fine-tuning")
       .action(this.fineTuneLLM.bind(this));
 
     trainCommand
-      .command('status <jobId>')
-      .description('Check training job status')
+      .command("status <jobId>")
+      .description("Check training job status")
       .action(this.checkTrainingStatus.bind(this));
 
     trainCommand
-      .command('deploy <jobId>')
-      .description('Deploy trained model')
-      .option('-e, --environment <env>', 'Deployment environment', 'staging')
-      .option('--auto-scale', 'Enable auto-scaling')
+      .command("deploy <jobId>")
+      .description("Deploy trained model")
+      .option("-e, --environment <env>", "Deployment environment", "staging")
+      .option("--auto-scale", "Enable auto-scaling")
       .action(this.deployModel.bind(this));
 
     // Adaptive Retrieval Commands
     const adaptiveCommand = aiCommand
-      .command('adaptive')
-      .description('Adaptive retrieval system');
+      .command("adaptive")
+      .description("Adaptive retrieval system");
 
     adaptiveCommand
-      .command('profile <userId>')
-      .description('Initialize or view user profile')
-      .option('-i, --interests <interests>', 'User interests (comma-separated)')
-      .option('-e, --expertise <level>', 'Expertise level', 'intermediate')
+      .command("profile <userId>")
+      .description("Initialize or view user profile")
+      .option("-i, --interests <interests>", "User interests (comma-separated)")
+      .option("-e, --expertise <level>", "Expertise level", "intermediate")
       .action(this.manageUserProfile.bind(this));
 
     adaptiveCommand
-      .command('search <userId> <query>')
-      .description('Perform adaptive search')
-      .option('-n, --max-results <num>', 'Maximum results', '10')
-      .option('--explain', 'Show adaptation explanation')
+      .command("search <userId> <query>")
+      .description("Perform adaptive search")
+      .option("-n, --max-results <num>", "Maximum results", "10")
+      .option("--explain", "Show adaptation explanation")
       .action(this.adaptiveSearch.bind(this));
 
     adaptiveCommand
-      .command('feedback <userId>')
-      .description('Provide feedback for learning')
-      .option('-q, --query <query>', 'Original query')
-      .option('-r, --ratings <ratings>', 'Result ratings (comma-separated)')
+      .command("feedback <userId>")
+      .description("Provide feedback for learning")
+      .option("-q, --query <query>", "Original query")
+      .option("-r, --ratings <ratings>", "Result ratings (comma-separated)")
       .action(this.provideFeedback.bind(this));
 
     // Multi-modal Processing Commands
     const multimodalCommand = aiCommand
-      .command('multimodal')
-      .description('Multi-modal content processing');
+      .command("multimodal")
+      .description("Multi-modal content processing");
 
     multimodalCommand
-      .command('process <contentPath>')
-      .description('Process multi-modal content')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-o, --output <path>', 'Output path for results')
-      .option('--extract-text', 'Extract text from images/videos')
+      .command("process <contentPath>")
+      .description("Process multi-modal content")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-o, --output <path>", "Output path for results")
+      .option("--extract-text", "Extract text from images/videos")
       .action(this.processMultiModalContent.bind(this));
 
     multimodalCommand
-      .command('search <tenantId>')
-      .description('Multi-modal search')
-      .option('-q, --query <query>', 'Text query')
-      .option('-i, --image <path>', 'Image query path')
-      .option('-a, --audio <path>', 'Audio query path')
-      .option('-n, --max-results <num>', 'Maximum results', '10')
+      .command("search <tenantId>")
+      .description("Multi-modal search")
+      .option("-q, --query <query>", "Text query")
+      .option("-i, --image <path>", "Image query path")
+      .option("-a, --audio <path>", "Audio query path")
+      .option("-n, --max-results <num>", "Maximum results", "10")
       .action(this.multiModalSearch.bind(this));
 
     multimodalCommand
-      .command('describe <contentId>')
-      .description('Generate content description')
-      .option('--detailed', 'Generate detailed description')
+      .command("describe <contentId>")
+      .description("Generate content description")
+      .option("--detailed", "Generate detailed description")
       .action(this.describeContent.bind(this));
 
     // Federated Learning Commands
     const federatedCommand = aiCommand
-      .command('federated')
-      .description('Federated learning coordination');
+      .command("federated")
+      .description("Federated learning coordination");
 
     federatedCommand
-      .command('create-federation')
-      .description('Create federated learning session')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-m, --model-_type <_type>', 'Model _type', 'embedding')
-      .option('-a, --architecture <arch>', 'Model architecture', 'transformer')
-      .option('--min-participants <num>', 'Minimum participants', '3')
-      .option('--max-participants <num>', 'Maximum participants', '10')
+      .command("create-federation")
+      .description("Create federated learning session")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-m, --model-_type <_type>", "Model _type", "embedding")
+      .option("-a, --architecture <arch>", "Model architecture", "transformer")
+      .option("--min-participants <num>", "Minimum participants", "3")
+      .option("--max-participants <num>", "Maximum participants", "10")
       .action(this.createFederation.bind(this));
 
     federatedCommand
-      .command('join <federationId>')
-      .description('Join federated learning session')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-d, --data-size <size>', 'Data size')
-      .option('-c, --compute-capacity <capacity>', 'Compute capacity (0-1)')
-      .option('-p, --privacy-level <level>', 'Privacy level', 'standard')
+      .command("join <federationId>")
+      .description("Join federated learning session")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-d, --data-size <size>", "Data size")
+      .option("-c, --compute-capacity <capacity>", "Compute capacity (0-1)")
+      .option("-p, --privacy-level <level>", "Privacy level", "standard")
       .action(this.joinFederation.bind(this));
 
     federatedCommand
-      .command('start-round <federationId>')
-      .description('Start federated learning round')
+      .command("start-round <federationId>")
+      .description("Start federated learning round")
       .action(this.startFederatedRound.bind(this));
 
     federatedCommand
-      .command('stats <federationId>')
-      .description('Show federation statistics')
-      .option('--detailed', 'Show detailed statistics')
+      .command("stats <federationId>")
+      .description("Show federation statistics")
+      .option("--detailed", "Show detailed statistics")
       .action(this.showFederationStats.bind(this));
 
     // General AI Commands
     aiCommand
-      .command('benchmark')
-      .description('Run AI/ML benchmarks')
-      .option('-t, --tenant <id>', 'Tenant ID')
-      .option('-m, --models <models>', 'Models to benchmark (comma-separated)')
-      .option('-o, --output <path>', 'Output path for results')
+      .command("benchmark")
+      .description("Run AI/ML benchmarks")
+      .option("-t, --tenant <id>", "Tenant ID")
+      .option("-m, --models <models>", "Models to benchmark (comma-separated)")
+      .option("-o, --output <path>", "Output path for results")
       .action(this.runBenchmarks.bind(this));
 
     aiCommand
-      .command('dashboard')
-      .description('Launch AI/ML dashboard')
-      .option('-p, --port <port>', 'Dashboard port', '3001')
-      .option('--open', 'Open browser automatically')
+      .command("dashboard")
+      .description("Launch AI/ML dashboard")
+      .option("-p, --port <port>", "Dashboard port", "3001")
+      .option("--open", "Open browser automatically")
       .action(this.launchDashboard.bind(this));
   }
 
+  // --- Delegating methods ---
+
   // Model Training Commands
   async trainEmbeddingModel(_options) {
-    const spinner = ora('Initializing embedding model training...').start();
-
-    try {
-      if (!_options.tenant) {
-        spinner.fail('Tenant ID is required');
-        return;
-      }
-
-      const trainingConfig = {
-        modelType: 'embedding',
-        architecture: _options.architecture,
-        dataset: {
-          path: _options.dataset,
-          _type: 'text_pairs',
-        },
-        hyperparameters: {
-          epochs: parseInt(_options.epochs),
-          batchSize: parseInt(_options.batchSize),
-          learningRate: parseFloat(_options.learningRate),
-        },
-      };
-
-      spinner.text = 'Creating training job...';
-      const jobId = await this.modelTrainer.createTrainingJob(
-        _options.tenant,
-        trainingConfig,
-      );
-
-      if (_options.optimize) {
-        spinner.text = 'Starting hyperparameter optimization...';
-        const optimizationConfig = {
-          ...trainingConfig,
-          hyperparameters: {
-            learningRate: [0.0001, 0.001, 0.01],
-            batchSize: [16, 32, 64],
-            hiddenSize: [256, 512, 768],
-          },
-          optimization: {
-            strategy: 'bayesian',
-            maxTrials: 10,
-            metric: 'accuracy',
-          },
-        };
-
-        const optimizationId = await this.modelTrainer.optimizeHyperparameters(
-          _options.tenant,
-          optimizationConfig,
-        );
-
-        spinner.succeed(
-          `Hyperparameter optimization started: ${optimizationId}`,
-        );
-      } else {
-        spinner.text = 'Starting training...';
-        await this.modelTrainer.startTraining(jobId);
-        spinner.succeed(`Training started: ${jobId}`);
-      }
-
-      console.log(chalk.green('\n✓ Training initiated successfully'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Job ID: ${jobId}`));
-      // eslint-disable-line no-console
-      console.log(
-        chalk.gray(
-          `Use 'rag-pipeline ai train status ${jobId}' to check progress`,
-        ),
-      );
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Training failed: ${error.message}`);
-    }
+    return trainingCommands.trainEmbeddingModel(this.modelTrainer, _options);
   }
 
   async fineTuneLLM(_options) {
-    const spinner = ora('Initializing LLM fine-tuning...').start();
-
-    try {
-      if (!_options.tenant) {
-        spinner.fail('Tenant ID is required');
-        return;
-      }
-
-      const trainingConfig = {
-        modelType: 'llm',
-        baseModel: _options.baseModel,
-        dataset: {
-          path: _options.dataset,
-          _type: 'instruction_following',
-        },
-        fineTuning: {
-          method: _options.lora ? 'lora' : 'full',
-          epochs: parseInt(_options.epochs),
-          learningRate: 0.0001,
-        },
-      };
-
-      spinner.text = 'Creating fine-tuning job...';
-      const jobId = await this.modelTrainer.createTrainingJob(
-        _options.tenant,
-        trainingConfig,
-      );
-
-      spinner.text = 'Starting fine-tuning...';
-      await this.modelTrainer.startTraining(jobId);
-
-      spinner.succeed(`Fine-tuning started: ${jobId}`);
-      console.log(chalk.green('\n✓ LLM fine-tuning initiated'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Job ID: ${jobId}`));
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Fine-tuning failed: ${error.message}`);
-    }
+    return trainingCommands.fineTuneLLM(this.modelTrainer, _options);
   }
 
   async checkTrainingStatus(jobId) {
-    const spinner = ora('Checking training status...').start();
-
-    try {
-      const status = await this.modelTrainer.getTrainingStatus(jobId);
-      spinner.stop();
-
-      const table = new Table({
-        head: ['Property', 'Value'],
-        colWidths: [20, 50],
-      });
-
-      table.push(
-        ['Job ID', jobId],
-        ['Status', this._colorizeStatus(status.status)],
-        ['Progress', `${status.progress}%`],
-        ['Current Epoch', `${status.currentEpoch}/${status.totalEpochs}`],
-        ['Accuracy', status.metrics?.accuracy?.toFixed(4) || 'N/A'],
-        ['Loss', status.metrics?.loss?.toFixed(4) || 'N/A'],
-        ['Estimated Time', status.estimatedTimeRemaining || 'N/A'],
-      );
-
-      console.log(table.toString());
-      // eslint-disable-line no-console
-
-      if (status.status === 'completed') {
-        console.log(chalk.green('\n✓ Training completed successfully!'));
-        // eslint-disable-line no-console
-        console.log(
-          chalk.blue(
-            `Use 'rag-pipeline ai train deploy ${jobId}' to deploy the model`,
-          ),
-        );
-        // eslint-disable-line no-console
-      } else if (status.status === 'failed') {
-        console.log(chalk.red('\n✗ Training failed'));
-        // eslint-disable-line no-console
-        if (status.error) {
-          console.log(chalk.gray(`Error: ${status.error}`));
-          // eslint-disable-line no-console
-        }
-      }
-    } catch (error) {
-      spinner.fail(`Failed to get status: ${error.message}`);
-    }
+    return trainingCommands.checkTrainingStatus(this.modelTrainer, jobId);
   }
 
   async deployModel(jobId, _options) {
-    const spinner = ora('Deploying model...').start();
-
-    try {
-      const deploymentConfig = {
-        environment: _options.environment,
-        scalingConfig: {
-          minInstances: 1,
-          maxInstances: _options.autoScale ? 5 : 1,
-          autoScale: !!_options.autoScale,
-        },
-      };
-
-      const deploymentId = await this.modelTrainer.deployModel(
-        jobId,
-        deploymentConfig,
-      );
-
-      spinner.succeed(`Model deployed: ${deploymentId}`);
-      console.log(chalk.green('\n✓ Model deployment successful'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Deployment ID: ${deploymentId}`));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Environment: ${_options.environment}`));
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Deployment failed: ${error.message}`);
-    }
+    return trainingCommands.deployModel(this.modelTrainer, jobId, _options);
   }
 
   // Adaptive Retrieval Commands
   async manageUserProfile(userId, _options) {
-    const spinner = ora('Managing user profile...').start();
-
-    try {
-      let profile;
-
-      try {
-        profile = await this.adaptiveRetrieval.getUserProfile(userId);
-        spinner.succeed('User profile found');
-      } catch {
-        // Profile doesn't exist, create new one
-        const profileData = {};
-
-        if (_options.interests) {
-          profileData.interests = _options.interests
-            .split(',')
-            .map((i) => i.trim());
-        }
-
-        if (_options.expertise) {
-          profileData.expertise = _options.expertise;
-        }
-
-        profile = await this.adaptiveRetrieval.initializeUserProfile(
-          userId,
-          profileData,
-        );
-        spinner.succeed('User profile created');
-      }
-
-      const table = new Table({
-        head: ['Property', 'Value'],
-        colWidths: [20, 50],
-      });
-
-      table.push(
-        ['User ID', profile.userId],
-        ['Interests', profile.preferences?.interests?.join(', ') || 'None'],
-        ['Expertise', profile.preferences?.expertise || 'Not set'],
-        [
-          'Learning History',
-          `${profile.learningHistory?.length || 0} interactions`,
-        ],
-        ['Created', profile.createdAt || 'Unknown'],
-      );
-
-      console.log(table.toString());
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Profile management failed: ${error.message}`);
-    }
+    return adaptiveCommands.manageUserProfile(
+      this.adaptiveRetrieval,
+      userId,
+      _options,
+    );
   }
 
   async adaptiveSearch(userId, query, _options) {
-    const spinner = ora('Performing adaptive search...').start();
-
-    try {
-      const searchOptions = {
-        maxResults: parseInt(_options.maxResults),
-        explain: !!_options.explain,
-      };
-
-      const results = await this.adaptiveRetrieval.adaptiveRetrieve(
-        userId,
-        query,
-        searchOptions,
-      );
-
-      spinner.succeed(`Found ${results.documents.length} results`);
-
-      // Display results
-      console.log(chalk.blue(`\nSearch Results for: "${query}"`));
-      // eslint-disable-line no-console
-      console.log(chalk.gray('='.repeat(50)));
-      // eslint-disable-line no-console
-
-      results.documents.forEach((doc, index) => {
-        console.log(chalk.green(`\n${index + 1}. ${doc.title || doc.id}`));
-        // eslint-disable-line no-console
-        console.log(chalk.gray(`   Score: ${doc.score?.toFixed(4) || 'N/A'}`));
-        // eslint-disable-line no-console
-        console.log(
-          chalk.gray(
-            `   Personalized Score: ${doc.personalizedScore?.toFixed(4) || 'N/A'}`,
-          ),
-        );
-        // eslint-disable-line no-console
-        console.log(`   ${doc.content?.substring(0, 200)}...`);
-        // eslint-disable-line no-console
-      });
-
-      if (_options.explain && results.adaptationMetadata) {
-        console.log(chalk.blue('\nAdaptation Explanation:'));
-        // eslint-disable-line no-console
-        console.log(
-          chalk.gray(JSON.stringify(results.adaptationMetadata, null, 2)),
-        );
-        // eslint-disable-line no-console
-      }
-    } catch (error) {
-      spinner.fail(`Adaptive search failed: ${error.message}`);
-    }
+    return adaptiveCommands.adaptiveSearch(
+      this.adaptiveRetrieval,
+      userId,
+      query,
+      _options,
+    );
   }
 
   async provideFeedback(userId, _options) {
-    if (!_options.query) {
-      const answers = await inquirer.prompt([
-        {
-          _type: 'input',
-          name: 'query',
-          message: 'Enter the original query:',
-        },
-        {
-          _type: 'input',
-          name: 'ratings',
-          message: 'Enter ratings for results (comma-separated, 1-5):',
-        },
-      ]);
-      _options.query = answers.query;
-      _options.ratings = answers.ratings;
-    }
-
-    const spinner = ora('Processing feedback...').start();
-
-    try {
-      const ratings = _options.ratings
-        .split(',')
-        .map((r) => parseInt(r.trim()));
-
-      const feedback = {
-        query: _options.query,
-        ratings,
-        clickedResults: [0], // Assume first result was clicked
-        dwellTime: [120], // Assume 2 minutes dwell time
-      };
-
-      await this.adaptiveRetrieval.processFeedback(userId, feedback);
-
-      spinner.succeed('Feedback processed successfully');
-      console.log(chalk.green('\n✓ User profile updated with feedback'));
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Feedback processing failed: ${error.message}`);
-    }
+    return adaptiveCommands.provideFeedback(
+      this.adaptiveRetrieval,
+      userId,
+      _options,
+    );
   }
 
   // Multi-modal Processing Commands
   async processMultiModalContent(contentPath, _options) {
-    const spinner = ora('Processing multi-modal content...').start();
-
-    try {
-      if (!_options.tenant) {
-        spinner.fail('Tenant ID is required');
-        return;
-      }
-
-      // Read content file
-      const stats = await fs.stat(contentPath);
-      const content = {
-        _type: this._detectContentType(contentPath),
-        size: stats.size,
-        path: contentPath,
-      };
-
-      // Add additional content based on type
-      if (content._type.startsWith('text/')) {
-        content.text = await fs.readFile(contentPath, 'utf-8');
-      }
-
-      spinner.text = 'Processing content...';
-      const result = await this.multiModalProcessor.processContent(
-        _options.tenant,
-        content,
-      );
-
-      spinner.succeed('Content processed successfully');
-
-      console.log(chalk.green('\n✓ Multi-modal processing completed'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Content ID: ${result.id}`));
-      // eslint-disable-line no-console
-      console.log(
-        chalk.blue(
-          `Modalities detected: ${Object.keys(result.modalities).join(', ')}`,
-        ),
-      );
-      // eslint-disable-line no-console
-      console.log(
-        chalk.blue(`Processing time: ${result.metadata.processingTime}ms`),
-      );
-      // eslint-disable-line no-console
-
-      if (_options.output) {
-        await fs.writeFile(_options.output, JSON.stringify(result, null, 2));
-        console.log(chalk.gray(`Results saved to: ${_options.output}`));
-        // eslint-disable-line no-console
-      }
-    } catch (error) {
-      spinner.fail(`Content processing failed: ${error.message}`);
-    }
+    return multimodalCommands.processMultiModalContent(
+      this.multiModalProcessor,
+      contentPath,
+      _options,
+    );
   }
 
   async multiModalSearch(tenantId, _options) {
-    const spinner = ora('Performing multi-modal search...').start();
-
-    try {
-      const query = {};
-
-      if (_options.query) {
-        query.text = _options.query;
-        query._type = 'text';
-      }
-
-      if (_options.image) {
-        query.image = await fs.readFile(_options.image);
-        query._type = 'image';
-      }
-
-      if (_options.audio) {
-        query.audio = await fs.readFile(_options.audio);
-        query._type = 'audio';
-      }
-
-      if (Object.keys(query).length === 0) {
-        spinner.fail('At least one query _type must be provided');
-        return;
-      }
-
-      const searchOptions = {
-        maxResults: parseInt(_options.maxResults),
-      };
-
-      const results = await this.multiModalProcessor.multiModalSearch(
-        tenantId,
-        query,
-        searchOptions,
-      );
-
-      spinner.succeed(`Found ${results.results.length} results`);
-
-      console.log(chalk.blue('\nMulti-modal Search Results:'));
-      // eslint-disable-line no-console
-      console.log(chalk.gray('='.repeat(50)));
-      // eslint-disable-line no-console
-
-      results.results.forEach((result, index) => {
-        console.log(
-          chalk.green(`\n${index + 1}. Content ID: ${result.contentId}`),
-        );
-        // eslint-disable-line no-console
-        console.log(
-          chalk.gray(
-            `   Multi-modal Score: ${result.multiModalScore?.toFixed(4)}`,
-          ),
-        );
-        // eslint-disable-line no-console
-        console.log(
-          chalk.gray(`   Modalities: ${result.modalities?.join(', ')}`),
-        );
-        // eslint-disable-line no-console
-        console.log(chalk.gray(`   Rank: ${result.rank}`));
-        // eslint-disable-line no-console
-      });
-    } catch (error) {
-      spinner.fail(`Multi-modal search failed: ${error.message}`);
-    }
+    return multimodalCommands.multiModalSearch(
+      this.multiModalProcessor,
+      tenantId,
+      _options,
+    );
   }
 
   async describeContent(contentId, _options) {
-    const spinner = ora('Generating content description...').start();
-
-    try {
-      const descriptions =
-        await this.multiModalProcessor.generateContentDescription(contentId, {
-          detailed: !!_options.detailed,
-        });
-
-      spinner.succeed('Description generated');
-
-      console.log(chalk.blue('\nContent Descriptions:'));
-      // eslint-disable-line no-console
-      console.log(chalk.gray('='.repeat(50)));
-      // eslint-disable-line no-console
-
-      for (const [modality, description] of Object.entries(descriptions)) {
-        console.log(chalk.green(`\n${modality.toUpperCase()}:`));
-        // eslint-disable-line no-console
-        console.log(description);
-        // eslint-disable-line no-console
-      }
-    } catch (error) {
-      spinner.fail(`Description generation failed: ${error.message}`);
-    }
+    return multimodalCommands.describeContent(
+      this.multiModalProcessor,
+      contentId,
+      _options,
+    );
   }
 
   // Federated Learning Commands
   async createFederation(_options) {
-    const spinner = ora('Creating federated learning session...').start();
-
-    try {
-      if (!_options.tenant) {
-        spinner.fail('Tenant ID is required');
-        return;
-      }
-
-      const modelConfig = {
-        _type: _options.modelType,
-        architecture: _options.architecture,
-      };
-
-      const federationOptions = {
-        minParticipants: parseInt(_options.minParticipants),
-        maxParticipants: parseInt(_options.maxParticipants),
-      };
-
-      const federationId = await this.federatedLearning.createFederation(
-        _options.tenant,
-        modelConfig,
-        federationOptions,
-      );
-
-      spinner.succeed('Federation created successfully');
-
-      console.log(chalk.green('\n✓ Federated learning session created'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Federation ID: ${federationId}`));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Model Type: ${_options.modelType}`));
-      // eslint-disable-line no-console
-      console.log(
-        chalk.blue(
-          `Min/Max Participants: ${_options.minParticipants}/${_options.maxParticipants}`,
-        ),
-      );
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Federation creation failed: ${error.message}`);
-    }
+    return federatedCommands.createFederation(this.federatedLearning, _options);
   }
 
   async joinFederation(federationId, _options) {
-    const spinner = ora('Joining federated learning session...').start();
-
-    try {
-      if (!_options.tenant) {
-        spinner.fail('Tenant ID is required');
-        return;
-      }
-
-      const participantInfo = {
-        tenantId: _options.tenant,
-        dataSize: parseInt(_options.dataSize) || 1000,
-        computeCapacity: parseFloat(_options.computeCapacity) || 0.8,
-        networkBandwidth: 100,
-        privacyLevel: _options.privacyLevel,
-      };
-
-      const participantId = await this.federatedLearning.registerParticipant(
-        federationId,
-        participantInfo,
-      );
-
-      spinner.succeed('Successfully joined federation');
-
-      console.log(chalk.green('\n✓ Joined federated learning session'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Participant ID: ${participantId}`));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Federation ID: ${federationId}`));
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Failed to join federation: ${error.message}`);
-    }
+    return federatedCommands.joinFederation(
+      this.federatedLearning,
+      federationId,
+      _options,
+    );
   }
 
   async startFederatedRound(federationId) {
-    const spinner = ora('Starting federated learning round...').start();
-
-    try {
-      const result =
-        await this.federatedLearning.startFederatedRound(federationId);
-
-      spinner.succeed('Federated round completed');
-
-      console.log(chalk.green('\n✓ Federated learning round completed'));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Round: ${result.round}`));
-      // eslint-disable-line no-console
-      console.log(chalk.blue(`Participants: ${result.participants}`));
-      // eslint-disable-line no-console
-      console.log(
-        chalk.blue(`Converged: ${result.convergence.converged ? 'Yes' : 'No'}`),
-      );
-      // eslint-disable-line no-console
-      console.log(
-        chalk.blue(
-          `Global Accuracy: ${result.convergence.globalAccuracy?.toFixed(4)}`,
-        ),
-      );
-      // eslint-disable-line no-console
-    } catch (error) {
-      spinner.fail(`Federated round failed: ${error.message}`);
-    }
+    return federatedCommands.startFederatedRound(
+      this.federatedLearning,
+      federationId,
+    );
   }
 
   async showFederationStats(federationId, _options) {
-    const spinner = ora('Fetching federation statistics...').start();
-
-    try {
-      const stats =
-        await this.federatedLearning.getFederationStats(federationId);
-
-      spinner.succeed('Statistics retrieved');
-
-      const table = new Table({
-        head: ['Property', 'Value'],
-        colWidths: [25, 40],
-      });
-
-      table.push(
-        ['Federation ID', stats.federation.id],
-        ['Status', this._colorizeStatus(stats.federation.status)],
-        ['Current Round', stats.federation.currentRound],
-        ['Total Participants', stats.federation.totalParticipants],
-        ['Active Participants', stats.federation.activeParticipants],
-        ['Model Type', stats.federation.modelType],
-        [
-          'Average Accuracy',
-          stats.performance.averageAccuracy?.toFixed(4) || 'N/A',
-        ],
-        ['Total Data Size', stats.performance.totalDataSize],
-        [
-          'Privacy Enabled',
-          stats.privacy.differentialPrivacyEnabled ? 'Yes' : 'No',
-        ],
-      );
-
-      console.log(table.toString());
-      // eslint-disable-line no-console
-
-      if (_options.detailed && stats.participants.length > 0) {
-        console.log(chalk.blue('\nParticipant Details:'));
-        // eslint-disable-line no-console
-
-        const participantTable = new Table({
-          head: ['Tenant ID', 'Data Size', 'Accuracy', 'Rounds', 'Status'],
-          colWidths: [15, 12, 12, 8, 12],
-        });
-
-        stats.participants.forEach((participant) => {
-          participantTable.push([
-            participant.tenantId,
-            participant.dataSize,
-            participant.performance.accuracy?.toFixed(4) || 'N/A',
-            participant.performance.rounds,
-            participant.status,
-          ]);
-        });
-
-        console.log(participantTable.toString());
-        // eslint-disable-line no-console
-      }
-    } catch (error) {
-      spinner.fail(`Failed to get statistics: ${error.message}`);
-    }
+    return federatedCommands.showFederationStats(
+      this.federatedLearning,
+      federationId,
+      _options,
+    );
   }
 
-  // Utility Commands
+  // Utility Commands (kept in aggregator as they don't belong to a specific domain)
   async runBenchmarks(_options) {
-    const spinner = ora('Running AI/ML benchmarks...').start();
+    const spinner = ora("Running AI/ML benchmarks...").start();
 
     try {
       // Mock benchmark implementation
       const benchmarks = {
         embedding: {
-          latency: '45ms',
-          throughput: '2000 docs/sec',
+          latency: "45ms",
+          throughput: "2000 docs/sec",
           accuracy: 0.89,
         },
         retrieval: {
-          latency: '12ms',
-          throughput: '5000 queries/sec',
+          latency: "12ms",
+          throughput: "5000 queries/sec",
           recall: 0.92,
         },
         generation: {
-          latency: '150ms',
-          throughput: '500 tokens/sec',
+          latency: "150ms",
+          throughput: "500 tokens/sec",
           quality: 0.85,
         },
       };
 
-      spinner.succeed('Benchmarks completed');
+      spinner.succeed("Benchmarks completed");
 
       const table = new Table({
-        head: ['Model', 'Latency', 'Throughput', 'Quality Score'],
+        head: ["Model", "Latency", "Throughput", "Quality Score"],
         colWidths: [15, 15, 20, 15],
       });
 
@@ -904,63 +348,38 @@ class AIMLCommands {
   }
 
   async launchDashboard(_options) {
-    console.log(chalk.blue('🚀 Launching AI/ML Dashboard...'));
+    console.log(chalk.blue("🚀 Launching AI/ML Dashboard..."));
     // eslint-disable-line no-console
     console.log(chalk.gray(`Port: ${_options.port}`));
     // eslint-disable-line no-console
     console.log(chalk.gray(`URL: http://localhost:${_options.port}`)); // eslint-disable-line no-console
 
     if (_options.open) {
-      console.log(chalk.green('Opening browser...'));
+      console.log(chalk.green("Opening browser..."));
       // eslint-disable-line no-console
     }
 
-    console.log(chalk.yellow('\nDashboard features:'));
+    console.log(chalk.yellow("\nDashboard features:"));
     // eslint-disable-line no-console
-    console.log('• Model training monitoring');
+    console.log("• Model training monitoring");
     // eslint-disable-line no-console
-    console.log('• Adaptive retrieval analytics');
+    console.log("• Adaptive retrieval analytics");
     // eslint-disable-line no-console
-    console.log('• Multi-modal content explorer');
+    console.log("• Multi-modal content explorer");
     // eslint-disable-line no-console
-    console.log('• Federated learning coordinator');
+    console.log("• Federated learning coordinator");
     // eslint-disable-line no-console
-    console.log('• Performance benchmarks');
+    console.log("• Performance benchmarks");
     // eslint-disable-line no-console
   }
 
-  // Helper methods
+  // Helper methods (delegated to shared module, kept here for backward compatibility)
   _colorizeStatus(status) {
-    switch (status) {
-      case 'completed':
-      case 'ready':
-      case 'active':
-        return chalk.green(status);
-      case 'failed':
-      case 'error':
-        return chalk.red(status);
-      case 'running':
-      case 'training':
-        return chalk.yellow(status);
-      default:
-        return chalk.gray(status);
-    }
+    return colorizeStatus(status);
   }
 
-  _detectContentType(_filePath) {
-    const ext = _path.extname(_filePath).toLowerCase();
-
-    if (['.jpg', '.jpeg', '.png', '.gif', '.webp'].includes(ext)) {
-      return 'image/jpeg';
-    } else if (['.mp3', '.wav', '.flac', '.ogg'].includes(ext)) {
-      return 'audio/mpeg';
-    } else if (['.mp4', '.avi', '.mov', '.webm'].includes(ext)) {
-      return 'video/mp4';
-    } else if (['.txt', '.md', '.json'].includes(ext)) {
-      return 'text/plain';
-    }
-
-    return 'application/octet-stream';
+  _detectContentType(filePath) {
+    return detectContentType(filePath);
   }
 }