myaidev-method 0.2.22 → 0.2.24-1

package/src/scripts/init/configure.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+
+/**
+ * Configure Script
+ * Interactive configuration wizard for MyAIDev Method
+ * Handles: WordPress, OpenStack, Content, and General settings
+ */
+
+import inquirer from 'inquirer';
+import { ConfigManager, SCHEMAS } from '../../lib/config-manager.js';
+import { WordPressClient } from '../../lib/wordpress-client.js';
+import { logger, createSpinner } from '../utils/logger.js';
+import chalk from 'chalk';
+
+/**
+ * Configuration Wizard Class
+ */
+class ConfigurationWizard {
+  constructor() {
+    this.configManager = new ConfigManager();
+  }
+
+  /**
+   * Run the configuration wizard
+   * @param {string} [section] - Specific section to configure
+   */
+  async run(section) {
+    logger.header('MyAIDev Method Configuration');
+
+    if (section) {
+      await this.configureSection(section);
+    } else {
+      await this.showMainMenu();
+    }
+  }
+
+  /**
+   * Show the main configuration menu
+   */
+  async showMainMenu() {
+    const config = await this.configManager.loadAll();
+
+    // Check which sections are configured
+    const wpStatus = this.getConfigStatus(config, 'wordpress');
+    const osStatus = this.getConfigStatus(config, 'openstack');
+    const contentStatus = this.getConfigStatus(config, 'content');
+
+    const { section } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'section',
+        message: 'What would you like to configure?',
+        choices: [
+          {
+            name: `WordPress ${wpStatus}`,
+            value: 'wordpress'
+          },
+          {
+            name: `OpenStack ${osStatus}`,
+            value: 'openstack'
+          },
+          {
+            name: `Content Settings ${contentStatus}`,
+            value: 'content'
+          },
+          {
+            name: 'General Settings',
+            value: 'general'
+          },
+          {
+            name: 'View Current Configuration',
+            value: 'view'
+          },
+          new inquirer.Separator(),
+          {
+            name: 'Exit',
+            value: 'exit'
+          }
+        ]
+      }
+    ]);
+
+    if (section === 'exit') {
+      logger.info('Configuration complete.');
+      return;
+    }
+
+    if (section === 'view') {
+      await this.viewConfiguration();
+      await this.showMainMenu();
+      return;
+    }
+
+    await this.configureSection(section);
+
+    // Ask if user wants to continue
+    const { continueConfig } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'continueConfig',
+        message: 'Would you like to configure something else?',
+        default: false
+      }
+    ]);
+
+    if (continueConfig) {
+      await this.showMainMenu();
+    }
+  }
+
+  /**
+   * Get status indicator for a configuration section
+   * @param {Object} config - Current configuration
+   * @param {string} section - Section name
+   * @returns {string} Status indicator
+   */
+  getConfigStatus(config, section) {
+    const validation = this.configManager.validateConfig(config, section);
+    if (validation.valid) {
+      return chalk.green('✓ Configured');
+    } else if (validation.missing.length < SCHEMAS[section]?.required?.length) {
+      return chalk.yellow('◐ Partial');
+    }
+    return chalk.gray('○ Not configured');
+  }
+
+  /**
+   * Configure a specific section
+   * @param {string} section - Section to configure
+   */
+  async configureSection(section) {
+    switch (section) {
+      case 'wordpress':
+        await this.configureWordPress();
+        break;
+      case 'openstack':
+        await this.configureOpenStack();
+        break;
+      case 'content':
+        await this.configureContent();
+        break;
+      case 'general':
+        await this.configureGeneral();
+        break;
+      default:
+        logger.error(`Unknown section: ${section}`);
+    }
+  }
+
+  /**
+   * Configure WordPress settings
+   */
+  async configureWordPress() {
+    logger.section('WordPress Configuration');
+    logger.info('Configure your WordPress site for content publishing.');
+    logger.blank();
+
+    const config = await this.configManager.loadAll();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'WORDPRESS_URL',
+        message: 'WordPress site URL:',
+        default: config.WORDPRESS_URL || '',
+        validate: (input) => {
+          if (!input) return 'URL is required';
+          if (!input.includes('.')) return 'Please enter a valid URL';
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'WORDPRESS_USERNAME',
+        message: 'WordPress username:',
+        default: config.WORDPRESS_USERNAME || '',
+        validate: (input) => input ? true : 'Username is required'
+      },
+      {
+        type: 'password',
+        name: 'WORDPRESS_APP_PASSWORD',
+        message: 'WordPress Application Password:',
+        mask: '*',
+        validate: (input) => input ? true : 'Application password is required'
+      },
+      {
+        type: 'list',
+        name: 'WORDPRESS_DEFAULT_STATUS',
+        message: 'Default post status:',
+        choices: ['draft', 'publish', 'pending'],
+        default: config.WORDPRESS_DEFAULT_STATUS || 'draft'
+      }
+    ]);
+
+    // Test connection
+    const spinner = createSpinner('Testing WordPress connection...');
+    spinner.start();
+
+    const client = new WordPressClient({
+      siteUrl: answers.WORDPRESS_URL,
+      username: answers.WORDPRESS_USERNAME,
+      appPassword: answers.WORDPRESS_APP_PASSWORD
+    });
+
+    const result = await client.validateConnection();
+
+    if (result.valid) {
+      spinner.succeed(result.message);
+
+      // Save configuration
+      await this.configManager.saveEnvConfig(answers);
+      logger.success('WordPress configuration saved!');
+    } else {
+      spinner.fail(result.message);
+
+      const { saveAnyway } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'saveAnyway',
+          message: 'Save configuration anyway?',
+          default: false
+        }
+      ]);
+
+      if (saveAnyway) {
+        await this.configManager.saveEnvConfig(answers);
+        logger.warn('Configuration saved (connection not verified).');
+      }
+    }
+  }
+
+  /**
+   * Configure OpenStack settings
+   */
+  async configureOpenStack() {
+    logger.section('OpenStack Configuration');
+    logger.info('Configure your OpenStack cloud for VM management.');
+    logger.blank();
+
+    const config = await this.configManager.loadAll();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'OS_AUTH_URL',
+        message: 'OpenStack Auth URL:',
+        default: config.OS_AUTH_URL || '',
+        validate: (input) => input ? true : 'Auth URL is required'
+      },
+      {
+        type: 'input',
+        name: 'OS_USERNAME',
+        message: 'OpenStack username:',
+        default: config.OS_USERNAME || '',
+        validate: (input) => input ? true : 'Username is required'
+      },
+      {
+        type: 'password',
+        name: 'OS_PASSWORD',
+        message: 'OpenStack password:',
+        mask: '*',
+        validate: (input) => input ? true : 'Password is required'
+      },
+      {
+        type: 'input',
+        name: 'OS_PROJECT_NAME',
+        message: 'Project name:',
+        default: config.OS_PROJECT_NAME || '',
+        validate: (input) => input ? true : 'Project name is required'
+      },
+      {
+        type: 'input',
+        name: 'OS_USER_DOMAIN_NAME',
+        message: 'User domain name:',
+        default: config.OS_USER_DOMAIN_NAME || 'Default'
+      },
+      {
+        type: 'input',
+        name: 'OS_PROJECT_DOMAIN_NAME',
+        message: 'Project domain name:',
+        default: config.OS_PROJECT_DOMAIN_NAME || 'Default'
+      },
+      {
+        type: 'input',
+        name: 'OS_REGION_NAME',
+        message: 'Region name (optional):',
+        default: config.OS_REGION_NAME || ''
+      }
+    ]);
+
+    // Save configuration
+    await this.configManager.saveEnvConfig(answers);
+    logger.success('OpenStack configuration saved!');
+    logger.info('Note: Run the health check to verify your connection.');
+  }
+
+  /**
+   * Configure content generation settings
+   */
+  async configureContent() {
+    logger.section('Content Settings');
+    logger.info('Configure default settings for content generation.');
+    logger.blank();
+
+    const config = await this.configManager.loadAll();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'number',
+        name: 'DEFAULT_WORD_COUNT',
+        message: 'Default word count:',
+        default: parseInt(config.DEFAULT_WORD_COUNT, 10) || 1500,
+        validate: (input) => {
+          if (input < 100 || input > 10000) {
+            return 'Word count must be between 100 and 10000';
+          }
+          return true;
+        }
+      },
+      {
+        type: 'list',
+        name: 'DEFAULT_TONE',
+        message: 'Default writing tone:',
+        choices: ['professional', 'conversational', 'technical', 'casual', 'authoritative'],
+        default: config.DEFAULT_TONE || 'professional'
+      },
+      {
+        type: 'input',
+        name: 'CONTENT_OUTPUT_DIR',
+        message: 'Default output directory:',
+        default: config.CONTENT_OUTPUT_DIR || './content'
+      }
+    ]);
+
+    // Save configuration
+    await this.configManager.saveEnvConfig(answers);
+    logger.success('Content settings saved!');
+  }
+
+  /**
+   * Configure general settings
+   */
+  async configureGeneral() {
+    logger.section('General Settings');
+    logger.blank();
+
+    const config = await this.configManager.loadAll();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'CLI_TYPE',
+        message: 'AI CLI type:',
+        choices: [
+          { name: 'Claude Code (Recommended)', value: 'claude' },
+          { name: 'Gemini CLI', value: 'gemini' },
+          { name: 'Codex CLI / OpenCode', value: 'codex' }
+        ],
+        default: config.CLI_TYPE || 'claude'
+      },
+      {
+        type: 'list',
+        name: 'LOG_LEVEL',
+        message: 'Log level:',
+        choices: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
+        default: config.LOG_LEVEL || 'INFO'
+      }
+    ]);
+
+    // Save configuration
+    await this.configManager.saveEnvConfig(answers);
+    logger.success('General settings saved!');
+  }
+
+  /**
+   * View current configuration
+   */
+  async viewConfiguration() {
+    logger.section('Current Configuration');
+
+    const config = await this.configManager.loadAll();
+    const keys = Object.keys(config).sort();
+
+    if (keys.length === 0) {
+      logger.info('No configuration found.');
+      return;
+    }
+
+    // Group by prefix
+    const groups = {};
+    for (const key of keys) {
+      const prefix = key.split('_')[0];
+      if (!groups[prefix]) groups[prefix] = [];
+
+      // Mask sensitive values
+      let value = config[key];
+      if (key.includes('PASSWORD') || key.includes('SECRET') || key.includes('TOKEN')) {
+        value = '********';
+      }
+
+      groups[prefix].push({ key, value });
+    }
+
+    for (const [prefix, items] of Object.entries(groups)) {
+      console.log(`\n${chalk.bold(prefix)}:`);
+      for (const item of items) {
+        console.log(`  ${chalk.cyan(item.key)}: ${item.value}`);
+      }
+    }
+
+    logger.blank();
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const section = args[0];
+
+  const wizard = new ConfigurationWizard();
+
+  try {
+    await wizard.run(section);
+  } catch (error) {
+    if (error.isTtyError) {
+      logger.error('This script requires an interactive terminal.');
+    } else {
+      logger.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();