myaidev-method 0.2.22 → 0.2.24-1

package/src/lib/config-manager.js

@@ -0,0 +1,470 @@
+/**
+ * Configuration Manager
+ * Central configuration management for MyAIDev Method
+ * Handles loading, validating, and persisting configurations
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+
+// Configuration schemas for validation
+export const SCHEMAS = {
+  wordpress: {
+    required: ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'],
+    optional: ['WORDPRESS_DEFAULT_STATUS', 'WORDPRESS_DEFAULT_CATEGORIES'],
+    defaults: {
+      WORDPRESS_DEFAULT_STATUS: 'draft'
+    }
+  },
+  openstack: {
+    required: ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD', 'OS_PROJECT_NAME'],
+    optional: ['OS_REGION_NAME', 'OS_USER_DOMAIN_NAME', 'OS_PROJECT_DOMAIN_NAME'],
+    defaults: {
+      OS_USER_DOMAIN_NAME: 'Default',
+      OS_PROJECT_DOMAIN_NAME: 'Default'
+    }
+  },
+  content: {
+    required: [],
+    optional: ['DEFAULT_WORD_COUNT', 'DEFAULT_TONE', 'CONTENT_OUTPUT_DIR'],
+    defaults: {
+      DEFAULT_WORD_COUNT: '1500',
+      DEFAULT_TONE: 'professional',
+      CONTENT_OUTPUT_DIR: './content'
+    }
+  },
+  defaults: {
+    required: [],
+    optional: ['LOG_LEVEL', 'CLI_TYPE'],
+    defaults: {
+      LOG_LEVEL: 'INFO',
+      CLI_TYPE: 'claude'
+    }
+  }
+};
+
+/**
+ * Configuration Manager Class
+ */
+export class ConfigManager {
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
+    this.configCache = null;
+    this.lastLoad = null;
+  }
+
+  /**
+   * Get path to .env file
+   * @returns {string}
+   */
+  getEnvPath() {
+    return path.join(this.projectRoot, '.env');
+  }
+
+  /**
+   * Get path to .claude/config directory
+   * @returns {string}
+   */
+  getClaudeConfigDir() {
+    return path.join(this.projectRoot, '.claude', 'config');
+  }
+
+  /**
+   * Load all configurations from various sources
+   * @param {boolean} [force=false] - Force reload even if cached
+   * @returns {Promise<Object>} Merged configuration
+   */
+  async loadAll(force = false) {
+    // Return cached config if recent (within 5 seconds)
+    if (!force && this.configCache && this.lastLoad) {
+      const age = Date.now() - this.lastLoad;
+      if (age < 5000) {
+        return this.configCache;
+      }
+    }
+
+    const config = {};
+
+    // 1. Load from .env file
+    const envConfig = await this.loadEnvFile();
+    Object.assign(config, envConfig);
+
+    // 2. Load from .claude/config/*.json files
+    const claudeConfigs = await this.loadClaudeConfigs();
+    Object.assign(config, claudeConfigs);
+
+    // 3. Apply defaults for any missing values
+    this.applyDefaults(config);
+
+    // Cache the result
+    this.configCache = config;
+    this.lastLoad = Date.now();
+
+    return config;
+  }
+
+  /**
+   * Load configuration from .env file
+   * @returns {Promise<Object>}
+   */
+  async loadEnvFile() {
+    const envPath = this.getEnvPath();
+
+    try {
+      const exists = await fs.pathExists(envPath);
+      if (!exists) {
+        return {};
+      }
+
+      const content = await fs.readFile(envPath, 'utf-8');
+      return this.parseEnvContent(content);
+    } catch (error) {
+      console.warn(`Warning: Failed to load .env file: ${error.message}`);
+      return {};
+    }
+  }
+
+  /**
+   * Load configuration files from .claude/config/
+   * @returns {Promise<Object>}
+   */
+  async loadClaudeConfigs() {
+    const configDir = this.getClaudeConfigDir();
+    const merged = {};
+
+    try {
+      const exists = await fs.pathExists(configDir);
+      if (!exists) {
+        return merged;
+      }
+
+      const files = await fs.readdir(configDir);
+      const jsonFiles = files.filter(f => f.endsWith('.json'));
+
+      for (const file of jsonFiles) {
+        const filePath = path.join(configDir, file);
+        try {
+          const content = await fs.readFile(filePath, 'utf-8');
+          const data = JSON.parse(content);
+          Object.assign(merged, data);
+        } catch (err) {
+          console.warn(`Warning: Failed to load config file ${file}: ${err.message}`);
+        }
+      }
+
+      return merged;
+    } catch (error) {
+      console.warn(`Warning: Failed to load claude configs: ${error.message}`);
+      return merged;
+    }
+  }
+
+  /**
+   * Apply default values for missing configuration
+   * @param {Object} config - Configuration object to modify
+   */
+  applyDefaults(config) {
+    for (const schema of Object.values(SCHEMAS)) {
+      for (const [key, value] of Object.entries(schema.defaults || {})) {
+        if (config[key] === undefined) {
+          config[key] = value;
+        }
+      }
+    }
+  }
+
+  /**
+   * Get a specific configuration value
+   * @param {string} key - Configuration key
+   * @param {any} [defaultValue] - Default value if not found
+   * @returns {Promise<any>}
+   */
+  async getConfig(key, defaultValue = undefined) {
+    const config = await this.loadAll();
+    return config[key] !== undefined ? config[key] : defaultValue;
+  }
+
+  /**
+   * Save workflow-specific configuration
+   * @param {string} name - Workflow/config name (e.g., 'wordpress', 'openstack')
+   * @param {Object} config - Configuration values
+   * @returns {Promise<boolean>}
+   */
+  async saveWorkflowConfig(name, config) {
+    const configDir = this.getClaudeConfigDir();
+
+    try {
+      await fs.ensureDir(configDir);
+
+      const configPath = path.join(configDir, `${name}.json`);
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+      // Invalidate cache
+      this.configCache = null;
+
+      return true;
+    } catch (error) {
+      console.error(`Failed to save ${name} config: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Save configuration to .env file
+   * @param {Object} config - Configuration to save
+   * @param {boolean} [merge=true] - Merge with existing .env
+   * @returns {Promise<boolean>}
+   */
+  async saveEnvConfig(config, merge = true) {
+    const envPath = this.getEnvPath();
+
+    try {
+      let existing = {};
+      if (merge) {
+        existing = await this.loadEnvFile();
+      }
+
+      const merged = { ...existing, ...config };
+      const content = this.formatEnvContent(merged);
+
+      await fs.writeFile(envPath, content, 'utf-8');
+
+      // Invalidate cache
+      this.configCache = null;
+
+      return true;
+    } catch (error) {
+      console.error(`Failed to save .env config: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Validate configuration against a schema
+   * @param {Object} config - Configuration to validate
+   * @param {string} schemaName - Schema name ('wordpress', 'openstack', etc.)
+   * @returns {{valid: boolean, missing: string[], warnings: string[]}}
+   */
+  validateConfig(config, schemaName) {
+    const schema = SCHEMAS[schemaName];
+    if (!schema) {
+      return { valid: false, missing: [], warnings: [`Unknown schema: ${schemaName}`] };
+    }
+
+    const missing = [];
+    const warnings = [];
+
+    // Check required fields
+    for (const field of schema.required || []) {
+      if (!config[field] || config[field].trim() === '') {
+        missing.push(field);
+      }
+    }
+
+    // Check for empty optional fields
+    for (const field of schema.optional || []) {
+      if (config[field] === '') {
+        warnings.push(`${field} is empty, using default`);
+      }
+    }
+
+    return {
+      valid: missing.length === 0,
+      missing,
+      warnings
+    };
+  }
+
+  /**
+   * Merge multiple configurations
+   * @param {Object} base - Base configuration
+   * @param {...Object} overrides - Override configurations
+   * @returns {Object} Merged configuration
+   */
+  mergeConfigs(base, ...overrides) {
+    const result = { ...base };
+
+    for (const override of overrides) {
+      for (const [key, value] of Object.entries(override)) {
+        if (value !== undefined && value !== null && value !== '') {
+          result[key] = value;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if a specific configuration is complete
+   * @param {string} schemaName - Schema name to check
+   * @returns {Promise<{complete: boolean, missing: string[]}>}
+   */
+  async isConfigured(schemaName) {
+    const config = await this.loadAll();
+    const validation = this.validateConfig(config, schemaName);
+
+    return {
+      complete: validation.valid,
+      missing: validation.missing
+    };
+  }
+
+  /**
+   * Get configuration for a specific workflow
+   * @param {string} workflowName - Workflow name
+   * @returns {Promise<Object>}
+   */
+  async getWorkflowConfig(workflowName) {
+    const config = await this.loadAll();
+    const prefix = workflowName.toUpperCase() + '_';
+
+    const workflowConfig = {};
+    for (const [key, value] of Object.entries(config)) {
+      if (key.startsWith(prefix) || key.startsWith(workflowName.toUpperCase())) {
+        workflowConfig[key] = value;
+      }
+    }
+
+    return workflowConfig;
+  }
+
+  /**
+   * Parse .env content into object
+   * @param {string} content - .env file content
+   * @returns {Object}
+   */
+  parseEnvContent(content) {
+    const result = {};
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        const key = match[1].trim();
+        let value = match[2].trim();
+
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+
+        result[key] = value;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Format object as .env content
+   * @param {Object} config - Configuration object
+   * @returns {string}
+   */
+  formatEnvContent(config) {
+    const lines = [];
+
+    // Group by prefix for better organization
+    const groups = {};
+    const noPrefix = [];
+
+    for (const [key, value] of Object.entries(config)) {
+      if (value === undefined || value === null) continue;
+
+      const prefixMatch = key.match(/^([A-Z]+)_/);
+      if (prefixMatch) {
+        const prefix = prefixMatch[1];
+        if (!groups[prefix]) groups[prefix] = [];
+        groups[prefix].push([key, value]);
+      } else {
+        noPrefix.push([key, value]);
+      }
+    }
+
+    // Format groups
+    for (const [prefix, entries] of Object.entries(groups)) {
+      lines.push(`# ${prefix} Configuration`);
+      for (const [key, value] of entries) {
+        lines.push(this.formatEnvLine(key, value));
+      }
+      lines.push('');
+    }
+
+    // Format ungrouped
+    if (noPrefix.length > 0) {
+      lines.push('# General Configuration');
+      for (const [key, value] of noPrefix) {
+        lines.push(this.formatEnvLine(key, value));
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format a single .env line
+   * @param {string} key - Key
+   * @param {any} value - Value
+   * @returns {string}
+   */
+  formatEnvLine(key, value) {
+    const stringValue = String(value);
+    const needsQuotes = stringValue.includes(' ') ||
+                       stringValue.includes('#') ||
+                       stringValue.includes('=');
+
+    return needsQuotes ? `${key}="${stringValue}"` : `${key}=${stringValue}`;
+  }
+
+  /**
+   * Delete a configuration key
+   * @param {string} key - Key to delete
+   * @returns {Promise<boolean>}
+   */
+  async deleteConfig(key) {
+    const config = await this.loadEnvFile();
+
+    if (config[key] !== undefined) {
+      delete config[key];
+      await this.saveEnvConfig(config, false);
+      this.configCache = null;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * List all configuration keys
+   * @returns {Promise<string[]>}
+   */
+  async listConfigKeys() {
+    const config = await this.loadAll();
+    return Object.keys(config).sort();
+  }
+}
+
+// Singleton instance for convenience
+let defaultInstance = null;
+
+/**
+ * Get the default ConfigManager instance
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {ConfigManager}
+ */
+export function getConfigManager(projectRoot) {
+  if (!defaultInstance || (projectRoot && projectRoot !== defaultInstance.projectRoot)) {
+    defaultInstance = new ConfigManager(projectRoot);
+  }
+  return defaultInstance;
+}
+
+export default ConfigManager;