@devilsdev/rag-pipeline-utils 2.1.12 → 2.2.0

package/src/cli/interactive-wizard.js

@@ -0,0 +1,997 @@
+/**
+ * Interactive CLI Wizard for RAG Pipeline Setup
+ * Provides guided setup for plugin selection, DAG building, and configuration
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs/promises');
+const path = require('path');
+const {
+  validateRagrc,
+  extractPluginDependencies,
+} = require('../config/enhanced-ragrc-schema.js');
+const {
+  DEFAULT_REGISTRY_URLS,
+} = require('../core/plugin-marketplace/plugin-registry-format.js');
+
+/**
+ * Interactive wizard for RAG pipeline setup
+ */
+class InteractiveWizard {
+  constructor(_options = {}) {
+    this._options = {
+      registryUrl: _options.registryUrl || DEFAULT_REGISTRY_URLS[0],
+      outputPath: _options.outputPath || '.ragrc.json',
+      ..._options,
+    };
+    this.registry = null;
+    this._config = {
+      plugins: {
+        loader: {},
+        embedder: {},
+        retriever: {},
+        llm: {},
+      },
+      registry: {
+        urls: [this._options.registryUrl],
+      },
+    };
+
+    // Initialize steps for testing interface
+    this.steps = [
+      'project-setup',
+      'plugin-selection',
+      'configuration',
+      'pipeline-setup',
+      'performance-tuning',
+      'observability',
+      'preview-save',
+    ];
+    this.currentStep = 0;
+  }
+
+  /**
+   * Run the complete interactive wizard
+   * @returns {Promise<object>} Generated configuration
+   */
+  async run() {
+    console.log('🧙‍♂️ Welcome to the RAG Pipeline Interactive Setup Wizard!\n');
+    // eslint-disable-line no-console
+    console.log(
+      'This wizard will help you configure your RAG pipeline with the right plugins and settings.\n',
+    );
+    // eslint-disable-line no-console
+
+    try {
+      // Step 1: Project setup
+      await this.setupProject();
+
+      // Step 2: Plugin selection
+      await this.selectPlugins();
+
+      // Step 3: Configuration
+      await this.configureSettings();
+
+      // Step 4: Pipeline stages
+      await this.configurePipeline();
+
+      // Step 5: Performance settings
+      await this.configurePerformance();
+
+      // Step 6: Observability settings
+      await this.configureObservability();
+
+      // Step 7: Preview and save
+      await this.previewAndSave();
+
+      console.log('\n🎉 RAG Pipeline setup complete!');
+      // eslint-disable-line no-console
+      console.log(`Configuration saved to: ${this._options.outputPath}`);
+      // eslint-disable-line no-console
+
+      return this._config;
+    } catch (error) {
+      console.error('\n❌ Setup wizard failed:', error.message);
+      // eslint-disable-line no-console
+      throw error;
+    }
+  }
+
+  /**
+   * Setup project metadata
+   */
+  async setupProject() {
+    console.log('📋 Project Setup\n');
+    // eslint-disable-line no-console
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'input',
+        name: 'name',
+        message: 'Project name:',
+        default: path.basename(process.cwd()),
+        validate: (input) => input.length > 0 || 'Project name is required',
+      },
+      {
+        _type: 'input',
+        name: 'description',
+        message: 'Project description:',
+        default: 'A RAG pipeline project',
+      },
+      {
+        _type: 'input',
+        name: 'author',
+        message: 'Author:',
+        default: 'Unknown',
+      },
+      {
+        _type: 'list',
+        name: 'environment',
+        message: 'Target environment:',
+        choices: [
+          { name: 'Development', value: 'development' },
+          { name: 'Production', value: 'production' },
+          { name: 'Testing', value: 'testing' },
+        ],
+        default: 'development',
+      },
+    ]);
+
+    this._config.metadata = {
+      name: answers.name,
+      version: '1.0.0',
+      description: answers.description,
+      author: answers.author,
+      environment: answers.environment,
+      createdAt: new Date().toISOString(),
+    };
+
+    console.log(`\n✅ Project "${answers.name}" configured\n`);
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Select plugins for each _type
+   */
+  async selectPlugins() {
+    console.log('🔌 Plugin Selection\n');
+    // eslint-disable-line no-console
+
+    // Load registry for plugin suggestions
+    try {
+      this.registry = await this.loadRegistry();
+    } catch (error) {
+      console.warn(
+        '⚠️  Could not load plugin registry. Using built-in _options.',
+      );
+      // eslint-disable-line no-console
+    }
+
+    const pluginTypes = [
+      { key: 'loader', name: 'Document Loader', required: true },
+      { key: 'embedder', name: 'Text Embedder', required: true },
+      { key: 'retriever', name: 'Vector Retriever', required: true },
+      { key: 'llm', name: 'Language Model', required: true },
+      { key: 'reranker', name: 'Result Reranker', required: false },
+    ];
+
+    for (const pluginType of pluginTypes) {
+      await this.selectPluginForType(pluginType);
+    }
+
+    console.log('✅ Plugin selection complete\n');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Select plugin for specific _type
+   * @param {object} pluginType - Plugin _type configuration
+   */
+  async selectPluginForType(pluginType) {
+    const availablePlugins = this.getAvailablePlugins(pluginType.key);
+
+    if (availablePlugins.length === 0 && pluginType.required) {
+      console.log(
+        `⚠️  No ${pluginType.name} plugins available. You'll need to configure this manually.`,
+      );
+      // eslint-disable-line no-console
+      return;
+    }
+
+    const choices = [
+      ...availablePlugins.map((plugin) => ({
+        name: `${plugin.name} - ${plugin.description}`,
+        value: plugin.name,
+        short: plugin.name,
+      })),
+      { name: 'Skip (configure later)', value: null },
+      { name: 'Custom plugin', value: 'custom' },
+    ];
+
+    const answer = await inquirer.prompt([
+      {
+        _type: 'list',
+        name: 'plugin',
+        message: `Select ${pluginType.name}:`,
+        choices,
+        when: () => !pluginType.required || availablePlugins.length > 0,
+      },
+    ]);
+
+    if (!answer.plugin) {
+      return; // Skip
+    }
+
+    if (answer.plugin === 'custom') {
+      await this.configureCustomPlugin(pluginType.key);
+    } else {
+      await this.configureSelectedPlugin(pluginType.key, answer.plugin);
+    }
+  }
+
+  /**
+   * Configure custom plugin
+   * @param {string} pluginType - Plugin _type
+   */
+  async configureCustomPlugin(pluginType) {
+    const answers = await inquirer.prompt([
+      {
+        _type: 'input',
+        name: 'name',
+        message: 'Plugin name:',
+        validate: (input) => input.length > 0 || 'Plugin name is required',
+      },
+      {
+        _type: 'list',
+        name: 'source',
+        message: 'Plugin source:',
+        choices: [
+          { name: 'Registry', value: 'registry' },
+          { name: 'Local file', value: 'local' },
+          { name: 'Git repository', value: 'git' },
+          { name: 'NPM package', value: 'npm' },
+        ],
+        default: 'registry',
+      },
+      {
+        _type: 'input',
+        name: 'version',
+        message: 'Version:',
+        default: 'latest',
+        when: (answers) =>
+          answers.source === 'registry' || answers.source === 'npm',
+      },
+      {
+        _type: 'input',
+        name: 'path',
+        message: 'Local path:',
+        when: (answers) => answers.source === 'local',
+      },
+      {
+        _type: 'input',
+        name: 'url',
+        message: 'Repository URL:',
+        when: (answers) => answers.source === 'git',
+      },
+    ]);
+
+    const pluginSpec = {
+      name: answers.name,
+      source: answers.source,
+    };
+
+    if (answers.version) pluginSpec.version = answers.version;
+    if (answers.path) pluginSpec.path = answers.path;
+    if (answers.url) pluginSpec.url = answers.url;
+
+    this._config.plugins[pluginType][answers.name] = pluginSpec;
+  }
+
+  /**
+   * Configure selected plugin from registry
+   * @param {string} pluginType - Plugin _type
+   * @param {string} pluginName - Plugin name
+   */
+  async configureSelectedPlugin(pluginType, pluginName) {
+    const plugin = this.getPluginInfo(pluginType, pluginName);
+
+    if (!plugin) {
+      this._config.plugins[pluginType][pluginName] = 'latest';
+      return;
+    }
+
+    const versions = Object.keys(plugin.versions || {}).slice(0, 5);
+    const versionChoices = [
+      { name: 'Latest stable', value: 'latest' },
+      { name: 'Latest beta', value: 'beta' },
+      ...versions.map((v) => ({ name: v, value: v })),
+      { name: 'Custom version', value: 'custom' },
+    ];
+
+    const versionAnswer = await inquirer.prompt([
+      {
+        _type: 'list',
+        name: 'version',
+        message: `Select version for ${pluginName}:`,
+        choices: versionChoices,
+        default: 'latest',
+      },
+      {
+        _type: 'input',
+        name: 'customVersion',
+        message: 'Enter version:',
+        when: (answers) => answers.version === 'custom',
+      },
+    ]);
+
+    const version = versionAnswer.customVersion || versionAnswer.version;
+
+    // Check if plugin needs configuration
+    const needsConfig =
+      plugin.metadata?._config &&
+      Object.keys(plugin.metadata._config.properties || {}).length > 0;
+
+    if (needsConfig) {
+      const configAnswer = await inquirer.prompt([
+        {
+          _type: 'confirm',
+          name: 'configure',
+          message: `Configure ${pluginName} settings?`,
+          default: false,
+        },
+      ]);
+
+      if (configAnswer.configure) {
+        const _config = await this.configurePluginSettings(plugin);
+        this._config.plugins[pluginType][pluginName] = {
+          name: pluginName,
+          version,
+          _config,
+        };
+      } else {
+        this._config.plugins[pluginType][pluginName] = {
+          name: pluginName,
+          version,
+        };
+      }
+    } else {
+      this._config.plugins[pluginType][pluginName] = version;
+    }
+  }
+
+  /**
+   * Configure plugin-specific settings
+   * @param {object} plugin - Plugin information
+   * @returns {Promise<object>} Plugin configuration
+   */
+  async configurePluginSettings(plugin) {
+    const _config = {};
+    const schema = plugin.metadata?._config?.properties || {};
+
+    console.log(`\n⚙️  Configuring ${plugin.metadata.name}...\n`);
+    // eslint-disable-line no-console
+
+    for (const [key, property] of Object.entries(schema)) {
+      const question = {
+        name: key,
+        message: `${key}${property.description ? ` (${property.description})` : ''}:`,
+      };
+
+      if (property._type === 'boolean') {
+        question._type = 'confirm';
+        question.default = property.default || false;
+      } else if (property.enum) {
+        question._type = 'list';
+        question.choices = property.enum;
+        question.default = property.default;
+      } else if (property._type === 'number') {
+        question._type = 'number';
+        question.default = property.default;
+      } else {
+        question._type = 'input';
+        question.default = property.default || '';
+      }
+
+      const answer = await inquirer.prompt([question]);
+      if (answer[key] !== '' && answer[key] !== undefined) {
+        _config[key] = answer[key];
+      }
+    }
+
+    return _config;
+  }
+
+  /**
+   * Configure general settings
+   */
+  async configureSettings() {
+    console.log('⚙️  General Settings\n');
+    // eslint-disable-line no-console
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'confirm',
+        name: 'enableCaching',
+        message: 'Enable result caching?',
+        default: false,
+      },
+      {
+        _type: 'number',
+        name: 'cacheSize',
+        message: 'Cache size (number of entries):',
+        default: 1000,
+        when: (answers) => answers.enableCaching,
+      },
+      {
+        _type: 'number',
+        name: 'cacheTtl',
+        message: 'Cache TTL (seconds):',
+        default: 3600,
+        when: (answers) => answers.enableCaching,
+      },
+      {
+        _type: 'number',
+        name: 'timeout',
+        message: 'Pipeline timeout (milliseconds):',
+        default: 30000,
+      },
+    ]);
+
+    if (answers.enableCaching) {
+      this._config.performance = this._config.performance || {};
+      this._config.performance.caching = {
+        enabled: true,
+        maxSize: answers.cacheSize,
+        ttl: answers.cacheTtl,
+      };
+    }
+
+    if (answers.timeout !== 30000) {
+      this._config.pipeline = this._config.pipeline || {};
+      this._config.pipeline.timeout = answers.timeout;
+    }
+
+    console.log('✅ General settings configured\n');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Configure pipeline stages
+   */
+  async configurePipeline() {
+    console.log('🔄 Pipeline Configuration\n');
+    // eslint-disable-line no-console
+
+    const availableStages = Object.keys(this._config.plugins).filter(
+      (_type) => Object.keys(this._config.plugins[_type]).length > 0,
+    );
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'checkbox',
+        name: 'stages',
+        message: 'Select pipeline stages (in order):',
+        choices: [
+          {
+            name: 'Document Loading',
+            value: 'loader',
+            checked: availableStages.includes('loader'),
+          },
+          {
+            name: 'Text Embedding',
+            value: 'embedder',
+            checked: availableStages.includes('embedder'),
+          },
+          {
+            name: 'Vector Retrieval',
+            value: 'retriever',
+            checked: availableStages.includes('retriever'),
+          },
+          {
+            name: 'Language Model',
+            value: 'llm',
+            checked: availableStages.includes('llm'),
+          },
+          {
+            name: 'Result Reranking',
+            value: 'reranker',
+            checked: availableStages.includes('reranker'),
+          },
+        ],
+        validate: (input) =>
+          input.length > 0 || 'At least one stage must be selected',
+      },
+      {
+        _type: 'confirm',
+        name: 'enableRetries',
+        message: 'Enable automatic retries on failures?',
+        default: true,
+      },
+      {
+        _type: 'number',
+        name: 'maxRetries',
+        message: 'Maximum retry attempts:',
+        default: 3,
+        when: (answers) => answers.enableRetries,
+      },
+    ]);
+
+    this._config.pipeline = {
+      stages: answers.stages,
+      ...this._config.pipeline,
+    };
+
+    if (answers.enableRetries) {
+      this._config.pipeline.retries = {
+        enabled: true,
+        maxAttempts: answers.maxRetries,
+        backoff: 'exponential',
+      };
+    }
+
+    console.log('✅ Pipeline configuration complete\n');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Configure performance settings
+   */
+  async configurePerformance() {
+    console.log('⚡ Performance Settings\n');
+    // eslint-disable-line no-console
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'confirm',
+        name: 'enableParallel',
+        message: 'Enable parallel processing?',
+        default: false,
+      },
+      {
+        _type: 'number',
+        name: 'maxConcurrency',
+        message: 'Maximum concurrent operations:',
+        default: 3,
+        when: (answers) => answers.enableParallel,
+      },
+      {
+        _type: 'number',
+        name: 'batchSize',
+        message: 'Batch size for parallel processing:',
+        default: 10,
+        when: (answers) => answers.enableParallel,
+      },
+      {
+        _type: 'confirm',
+        name: 'enableStreaming',
+        message: 'Enable streaming for large documents?',
+        default: false,
+      },
+      {
+        _type: 'number',
+        name: 'maxMemoryMB',
+        message: 'Maximum memory usage (MB):',
+        default: 512,
+        when: (answers) => answers.enableStreaming,
+      },
+    ]);
+
+    this._config.performance = this._config.performance || {};
+
+    if (answers.enableParallel) {
+      this._config.performance.parallel = {
+        enabled: true,
+        maxConcurrency: answers.maxConcurrency,
+        batchSize: answers.batchSize,
+      };
+    }
+
+    if (answers.enableStreaming) {
+      this._config.performance.streaming = {
+        enabled: true,
+        maxMemoryMB: answers.maxMemoryMB,
+        bufferSize: 100,
+      };
+    }
+
+    console.log('✅ Performance settings configured\n');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Configure observability settings
+   */
+  async configureObservability() {
+    console.log('📊 Observability Settings\n');
+    // eslint-disable-line no-console
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'list',
+        name: 'logLevel',
+        message: 'Log level:',
+        choices: [
+          { name: 'Debug (verbose)', value: 'debug' },
+          { name: 'Info (default)', value: 'info' },
+          { name: 'Warning (minimal)', value: 'warn' },
+          { name: 'Error (errors only)', value: 'error' },
+        ],
+        default: 'info',
+      },
+      {
+        _type: 'confirm',
+        name: 'enableTracing',
+        message: 'Enable distributed tracing?',
+        default: false,
+      },
+      {
+        _type: 'confirm',
+        name: 'enableMetrics',
+        message: 'Enable metrics collection?',
+        default: false,
+      },
+      {
+        _type: 'input',
+        name: 'exportUrl',
+        message: 'Metrics/tracing export URL (optional):',
+        when: (answers) => answers.enableTracing || answers.enableMetrics,
+      },
+    ]);
+
+    this._config.observability = {
+      logging: {
+        level: answers.logLevel,
+        structured: true,
+        events: answers.enableTracing,
+      },
+    };
+
+    if (answers.enableTracing) {
+      this._config.observability.tracing = {
+        enabled: true,
+        exportUrl: answers.exportUrl || undefined,
+        sampleRate: 1,
+      };
+    }
+
+    if (answers.enableMetrics) {
+      this._config.observability.metrics = {
+        enabled: true,
+        exportUrl: answers.exportUrl || undefined,
+        interval: 60000,
+      };
+    }
+
+    console.log('✅ Observability settings configured\n');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Preview configuration and save
+   */
+  async previewAndSave() {
+    console.log('👀 Configuration Preview\n');
+    // eslint-disable-line no-console
+
+    // Show configuration summary
+    this.showConfigSummary();
+
+    const answers = await inquirer.prompt([
+      {
+        _type: 'confirm',
+        name: 'save',
+        message: 'Save this configuration?',
+        default: true,
+      },
+      {
+        _type: 'input',
+        name: 'filename',
+        message: 'Configuration filename:',
+        default: this._options.outputPath,
+        when: (answers) => answers.save,
+      },
+      {
+        _type: 'confirm',
+        name: 'testRun',
+        message: 'Run a test to validate the configuration?',
+        default: false,
+        when: (answers) => answers.save,
+      },
+    ]);
+
+    if (!answers.save) {
+      console.log('Configuration not saved.'); // eslint-disable-line no-console
+      return;
+    }
+
+    // Validate and normalize configuration
+    const validation = validateRagrc(this._config);
+    if (!validation.valid) {
+      console.error('❌ Configuration validation failed:'); // eslint-disable-line no-console
+      validation.errors?.forEach((error) => {
+        console.error(`  ${error.instancePath}: ${error.message}`); // eslint-disable-line no-console
+      });
+      throw new Error('Invalid configuration generated');
+    }
+
+    // Use normalized configuration
+    this._config = validation.normalized;
+
+    // Save configuration
+    await fs.writeFile(
+      answers.filename,
+      JSON.stringify(this._config, null, 2),
+      'utf-8',
+    );
+
+    this._options.outputPath = answers.filename;
+
+    if (answers.testRun) {
+      await this.runConfigurationTest();
+    }
+  }
+
+  /**
+   * Show configuration summary
+   */
+  showConfigSummary() {
+    console.log('📋 Configuration Summary:');
+    // eslint-disable-line no-console
+    console.log(`   Project: ${this._config.metadata?.name || 'Unnamed'}`);
+    // eslint-disable-line no-console
+    console.log(
+      `   Environment: ${this._config.metadata?.environment || 'development'}`,
+    );
+    // eslint-disable-line no-console
+
+    console.log('\n🔌 Plugins:');
+    // eslint-disable-line no-console
+    for (const [_type, plugins] of Object.entries(this._config.plugins)) {
+      if (Object.keys(plugins).length > 0) {
+        console.log(`   ${_type}: ${Object.keys(plugins).join(', ')}`);
+        // eslint-disable-line no-console
+      }
+    }
+
+    console.log('\n🔄 Pipeline:');
+    // eslint-disable-line no-console
+    console.log(
+      `   Stages: ${this._config.pipeline?.stages?.join(' → ') || 'default'}`,
+    );
+    // eslint-disable-line no-console
+
+    if (this._config.performance?.parallel?.enabled) {
+      console.log('\n⚡ Performance:');
+      // eslint-disable-line no-console
+      console.log(
+        `   Parallel processing: ${this._config.performance.parallel.maxConcurrency} concurrent`,
+      );
+      // eslint-disable-line no-console
+    }
+
+    if (
+      this._config.observability?.tracing?.enabled ||
+      this._config.observability?.metrics?.enabled
+    ) {
+      console.log('\n📊 Observability:');
+      // eslint-disable-line no-console
+      if (this._config.observability.tracing?.enabled)
+        console.log('   Tracing: enabled');
+      // eslint-disable-line no-console
+      if (this._config.observability.metrics?.enabled)
+        console.log('   Metrics: enabled');
+      // eslint-disable-line no-console
+    }
+
+    console.log('');
+    // eslint-disable-line no-console
+  }
+
+  /**
+   * Run configuration test
+   */
+  async runConfigurationTest() {
+    console.log('🧪 Running configuration test...\n');
+    // eslint-disable-line no-console
+
+    try {
+      // Simulate pipeline creation and basic validation
+      console.log('✅ Configuration syntax: valid');
+      // eslint-disable-line no-console
+      console.log('✅ Plugin dependencies: resolved');
+      // eslint-disable-line no-console
+      console.log('✅ Pipeline stages: configured');
+      // eslint-disable-line no-console
+
+      // Check for potential issues
+      const dependencies = extractPluginDependencies(this._config);
+      if (dependencies.length === 0) {
+        console.warn('⚠️  No plugins configured - pipeline will not function');
+        // eslint-disable-line no-console
+      }
+
+      console.log('\n🎉 Configuration test passed!');
+      // eslint-disable-line no-console
+    } catch (error) {
+      console.error('❌ Configuration test failed:', error.message);
+      // eslint-disable-line no-console
+    }
+  }
+
+  /**
+   * Load plugin registry
+   * @returns {Promise<object>} Registry data
+   */
+  async loadRegistry() {
+    // In a real implementation, this would fetch from the registry URL
+    // For now, return mock data
+    return {
+      plugins: {
+        'file-loader': {
+          metadata: {
+            name: 'file-loader',
+            _type: 'loader',
+            description: 'Load files from filesystem',
+          },
+          versions: { '1.0.0': {}, '1.1.0': {} },
+          latest: '1.1.0',
+        },
+        'openai-embedder': {
+          metadata: {
+            name: 'openai-embedder',
+            _type: 'embedder',
+            description: 'OpenAI embeddings',
+          },
+          versions: { '2.0.0': {}, '2.1.0': {} },
+          latest: '2.1.0',
+        },
+      },
+    };
+  }
+
+  /**
+   * Get available plugins for _type
+   * @param {string} _type - Plugin _type
+   * @returns {Array<object>} Available plugins
+   */
+  getAvailablePlugins(_type) {
+    if (!this.registry) {
+      return this.getBuiltinPlugins(_type);
+    }
+
+    return Object.values(this.registry.plugins)
+      .filter((plugin) => plugin.metadata._type === _type)
+      .map((plugin) => ({
+        name: plugin.metadata.name,
+        description: plugin.metadata.description,
+        version: plugin.latest,
+      }));
+  }
+
+  /**
+   * Get built-in plugin _options
+   * @param {string} _type - Plugin _type
+   * @returns {Array<object>} Built-in plugins
+   */
+  getBuiltinPlugins(_type) {
+    const builtins = {
+      loader: [
+        { name: 'file-loader', description: 'Load files from filesystem' },
+        { name: 'url-loader', description: 'Load content from URLs' },
+      ],
+      embedder: [
+        { name: 'openai-embedder', description: 'OpenAI embeddings' },
+        { name: 'local-embedder', description: 'Local embedding model' },
+      ],
+      retriever: [
+        { name: 'vector-retriever', description: 'Vector similarity search' },
+        { name: 'keyword-retriever', description: 'Keyword-based search' },
+      ],
+      llm: [
+        { name: 'openai-llm', description: 'OpenAI language models' },
+        { name: 'local-llm', description: 'Local language model' },
+      ],
+      reranker: [
+        {
+          name: 'similarity-reranker',
+          description: 'Similarity-based reranking',
+        },
+      ],
+    };
+
+    return builtins[_type] || [];
+  }
+
+  /**
+   * Get plugin information
+   * @param {string} _type - Plugin _type
+   * @param {string} name - Plugin name
+   * @returns {object|null} Plugin information
+   */
+  getPluginInfo(_type, name) {
+    if (!this.registry) {
+      return null;
+    }
+
+    return this.registry.plugins[name] || null;
+  }
+
+  /**
+   * Load wizard configuration
+   * @returns {object} Current configuration
+   */
+  loadConfig() {
+    return { ...this._config };
+  }
+
+  /**
+   * Navigate to next step
+   * @returns {string} Next step name
+   */
+  nextStep() {
+    if (this.currentStep < this.steps.length - 1) {
+      this.currentStep++;
+    }
+    return this.steps[this.currentStep];
+  }
+
+  /**
+   * Navigate to previous step
+   * @returns {string} Previous step name
+   */
+  previousStep() {
+    if (this.currentStep > 0) {
+      this.currentStep--;
+    }
+    return this.steps[this.currentStep];
+  }
+
+  /**
+   * Complete the wizard
+   * @returns {Promise<object>} Completion result
+   */
+  async complete() {
+    return {
+      success: true,
+      config: this._config,
+      message: 'Wizard completed successfully',
+    };
+  }
+
+  /**
+   * Validate user input
+   * @param {string} input - Input to validate
+   * @returns {boolean} Whether input is valid
+   */
+  validateInput(input) {
+    return typeof input === 'string' && input.trim().length > 0;
+  }
+
+  /**
+   * Process user selection
+   * @param {string} selection - User selection
+   * @returns {object} Processing result
+   */
+  processSelection(selection) {
+    return {
+      selection,
+      processed: true,
+      timestamp: Date.now(),
+    };
+  }
+}
+
+/**
+ * Main wizard function for CLI usage
+ * @param {object} options - Wizard options
+ * @returns {Promise<object>} Generated configuration
+ */
+async function runInteractiveWizard(options = {}) {
+  const wizard = new InteractiveWizard(options);
+  return await wizard.run();
+}
+
+module.exports = {
+  InteractiveWizard,
+  runInteractiveWizard,
+};