bmad-elsabro 1.0.0

package/tools/cli/lib/cli-utils.js

@@ -0,0 +1,227 @@
+const chalk = require('chalk');
+const boxen = require('boxen');
+const wrapAnsi = require('wrap-ansi');
+const figlet = require('figlet');
+const path = require('node:path');
+const os = require('node:os');
+
+const CLIUtils = {
+  /**
+   * Get version from package.json
+   */
+  getVersion() {
+    try {
+      const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+      return packageJson.version || 'Unknown';
+    } catch {
+      return 'Unknown';
+    }
+  },
+
+  /**
+   * Display BMAD logo
+   * @param {boolean} clearScreen - Whether to clear the screen first (default: true for initial display only)
+   */
+  displayLogo(clearScreen = true) {
+    if (clearScreen) {
+      console.clear();
+    }
+
+    const version = this.getVersion();
+
+    // ASCII art logo
+    const logo = `
+    ██████╗ ███╗   ███╗ █████╗ ██████╗ ™
+    ██╔══██╗████╗ ████║██╔══██╗██╔══██╗
+    ██████╔╝██╔████╔██║███████║██║  ██║
+    ██╔══██╗██║╚██╔╝██║██╔══██║██║  ██║
+    ██████╔╝██║ ╚═╝ ██║██║  ██║██████╔╝
+    ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝╚═════╝`;
+
+    console.log(chalk.cyan(logo));
+    console.log(chalk.dim(`    Build More, Architect Dreams`) + chalk.cyan.bold(` v${version}`) + '\n');
+  },
+
+  /**
+   * Display section header
+   * @param {string} title - Section title
+   * @param {string} subtitle - Optional subtitle
+   */
+  displaySection(title, subtitle = null) {
+    console.log('\n' + chalk.cyan('═'.repeat(80)));
+    console.log(chalk.cyan.bold(` ${title}`));
+    if (subtitle) {
+      console.log(chalk.dim(` ${subtitle}`));
+    }
+    console.log(chalk.cyan('═'.repeat(80)) + '\n');
+  },
+
+  /**
+   * Display info box
+   * @param {string|Array} content - Content to display
+   * @param {Object} options - Box options
+   */
+  displayBox(content, options = {}) {
+    const defaultOptions = {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'cyan',
+      ...options,
+    };
+
+    // Handle array content
+    let text = content;
+    if (Array.isArray(content)) {
+      text = content.join('\n\n');
+    }
+
+    // Wrap text to prevent overflow
+    const wrapped = wrapAnsi(text, 76, { hard: true, wordWrap: true });
+
+    console.log(boxen(wrapped, defaultOptions));
+  },
+
+  /**
+   * Display module configuration header
+   * @param {string} moduleName - Module name (fallback if no custom header)
+   * @param {string} header - Custom header from module.yaml
+   * @param {string} subheader - Custom subheader from module.yaml
+   */
+  displayModuleConfigHeader(moduleName, header = null, subheader = null) {
+    // Simple blue banner with custom header/subheader if provided
+    console.log('\n' + chalk.cyan('─'.repeat(80)));
+    console.log(chalk.cyan(header || `Configuring ${moduleName.toUpperCase()} Module`));
+    if (subheader) {
+      console.log(chalk.dim(`${subheader}`));
+    }
+    console.log(chalk.cyan('─'.repeat(80)) + '\n');
+  },
+
+  /**
+   * Display module with no custom configuration
+   * @param {string} moduleName - Module name (fallback if no custom header)
+   * @param {string} header - Custom header from module.yaml
+   * @param {string} subheader - Custom subheader from module.yaml
+   */
+  displayModuleNoConfig(moduleName, header = null, subheader = null) {
+    // Show full banner with header/subheader, just like modules with config
+    console.log('\n' + chalk.cyan('─'.repeat(80)));
+    console.log(chalk.cyan(header || `${moduleName.toUpperCase()} Module - No Custom Configuration`));
+    if (subheader) {
+      console.log(chalk.dim(`${subheader}`));
+    }
+    console.log(chalk.cyan('─'.repeat(80)) + '\n');
+  },
+
+  /**
+   * Display step indicator
+   * @param {number} current - Current step
+   * @param {number} total - Total steps
+   * @param {string} description - Step description
+   */
+  displayStep(current, total, description) {
+    const progress = `[${current}/${total}]`;
+    console.log('\n' + chalk.cyan(progress) + ' ' + chalk.bold(description));
+    console.log(chalk.dim('─'.repeat(80 - progress.length - 1)) + '\n');
+  },
+
+  /**
+   * Display completion message
+   * @param {string} message - Completion message
+   */
+  displayComplete(message) {
+    console.log(
+      '\n' +
+        boxen(chalk.green('✨ ' + message), {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'green',
+        }),
+    );
+  },
+
+  /**
+   * Display error message
+   * @param {string} message - Error message
+   */
+  displayError(message) {
+    console.log(
+      '\n' +
+        boxen(chalk.red('✗ ' + message), {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'red',
+        }),
+    );
+  },
+
+  /**
+   * Format list for display
+   * @param {Array} items - Items to display
+   * @param {string} prefix - Item prefix
+   */
+  formatList(items, prefix = '•') {
+    return items.map((item) => `  ${prefix} ${item}`).join('\n');
+  },
+
+  /**
+   * Clear previous lines
+   * @param {number} lines - Number of lines to clear
+   */
+  clearLines(lines) {
+    for (let i = 0; i < lines; i++) {
+      process.stdout.moveCursor(0, -1);
+      process.stdout.clearLine(1);
+    }
+  },
+
+  /**
+   * Display table
+   * @param {Array} data - Table data
+   * @param {Object} options - Table options
+   */
+  displayTable(data, options = {}) {
+    const Table = require('cli-table3');
+    const table = new Table({
+      style: {
+        head: ['cyan'],
+        border: ['dim'],
+      },
+      ...options,
+    });
+
+    for (const row of data) table.push(row);
+    console.log(table.toString());
+  },
+
+  /**
+   * Display module completion message
+   * @param {string} moduleName - Name of the completed module
+   * @param {boolean} clearScreen - Whether to clear the screen first (deprecated, always false now)
+   */
+  displayModuleComplete(moduleName, clearScreen = false) {
+    // No longer clear screen or show boxes - just a simple completion message
+    // This is deprecated but kept for backwards compatibility
+  },
+
+  /**
+   * Expand path with ~ expansion
+   * @param {string} inputPath - Path to expand
+   * @returns {string} Expanded path
+   */
+  expandPath(inputPath) {
+    if (!inputPath) return inputPath;
+
+    // Expand ~ to home directory
+    if (inputPath.startsWith('~')) {
+      return path.join(os.homedir(), inputPath.slice(1));
+    }
+
+    return inputPath;
+  },
+};
+
+module.exports = { CLIUtils };

package/tools/cli/lib/config.js

@@ -0,0 +1,213 @@
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const path = require('node:path');
+const packageJson = require('../../../package.json');
+
+/**
+ * Configuration utility class
+ */
+class Config {
+  /**
+   * Load a YAML configuration file
+   * @param {string} configPath - Path to config file
+   * @returns {Object} Parsed configuration
+   */
+  async loadYaml(configPath) {
+    if (!(await fs.pathExists(configPath))) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+
+    const content = await fs.readFile(configPath, 'utf8');
+    return yaml.parse(content);
+  }
+
+  /**
+   * Save configuration to YAML file
+   * @param {string} configPath - Path to config file
+   * @param {Object} config - Configuration object
+   */
+  async saveYaml(configPath, config) {
+    const yamlContent = yaml.dump(config, {
+      indent: 2,
+      lineWidth: 120,
+      noRefs: true,
+    });
+
+    await fs.ensureDir(path.dirname(configPath));
+    // Ensure POSIX-compliant final newline
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Process configuration file (replace placeholders)
+   * @param {string} configPath - Path to config file
+   * @param {Object} replacements - Replacement values
+   */
+  async processConfig(configPath, replacements = {}) {
+    let content = await fs.readFile(configPath, 'utf8');
+
+    // Standard replacements
+    const standardReplacements = {
+      '{project-root}': replacements.root || '',
+      '{module}': replacements.module || '',
+      '{version}': replacements.version || packageJson.version,
+      '{date}': new Date().toISOString().split('T')[0],
+    };
+
+    // Apply all replacements
+    const allReplacements = { ...standardReplacements, ...replacements };
+
+    for (const [placeholder, value] of Object.entries(allReplacements)) {
+      if (typeof placeholder === 'string' && typeof value === 'string') {
+        const regex = new RegExp(placeholder.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`), 'g');
+        content = content.replace(regex, value);
+      }
+    }
+
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Merge configurations
+   * @param {Object} base - Base configuration
+   * @param {Object} override - Override configuration
+   * @returns {Object} Merged configuration
+   */
+  mergeConfigs(base, override) {
+    return this.deepMerge(base, override);
+  }
+
+  /**
+   * Deep merge two objects
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object
+   * @returns {Object} Merged object
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+
+    if (this.isObject(target) && this.isObject(source)) {
+      for (const key of Object.keys(source)) {
+        if (this.isObject(source[key])) {
+          if (key in target) {
+            output[key] = this.deepMerge(target[key], source[key]);
+          } else {
+            output[key] = source[key];
+          }
+        } else {
+          output[key] = source[key];
+        }
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Check if value is an object
+   * @param {*} item - Item to check
+   * @returns {boolean} True if object
+   */
+  isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+  }
+
+  /**
+   * Validate configuration against schema
+   * @param {Object} config - Configuration to validate
+   * @param {Object} schema - Validation schema
+   * @returns {Object} Validation result
+   */
+  validateConfig(config, schema) {
+    const errors = [];
+    const warnings = [];
+
+    // Check required fields
+    if (schema.required) {
+      for (const field of schema.required) {
+        if (!(field in config)) {
+          errors.push(`Missing required field: ${field}`);
+        }
+      }
+    }
+
+    // Check field types
+    if (schema.properties) {
+      for (const [field, spec] of Object.entries(schema.properties)) {
+        if (field in config) {
+          const value = config[field];
+          const expectedType = spec.type;
+
+          if (expectedType === 'array' && !Array.isArray(value)) {
+            errors.push(`Field '${field}' should be an array`);
+          } else if (expectedType === 'object' && !this.isObject(value)) {
+            errors.push(`Field '${field}' should be an object`);
+          } else if (expectedType === 'string' && typeof value !== 'string') {
+            errors.push(`Field '${field}' should be a string`);
+          } else if (expectedType === 'number' && typeof value !== 'number') {
+            errors.push(`Field '${field}' should be a number`);
+          } else if (expectedType === 'boolean' && typeof value !== 'boolean') {
+            errors.push(`Field '${field}' should be a boolean`);
+          }
+
+          // Check enum values
+          if (spec.enum && !spec.enum.includes(value)) {
+            errors.push(`Field '${field}' must be one of: ${spec.enum.join(', ')}`);
+          }
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+    };
+  }
+
+  /**
+   * Get configuration value with fallback
+   * @param {Object} config - Configuration object
+   * @param {string} path - Dot-notation path to value
+   * @param {*} defaultValue - Default value if not found
+   * @returns {*} Configuration value
+   */
+  getValue(config, path, defaultValue = null) {
+    const keys = path.split('.');
+    let current = config;
+
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        return defaultValue;
+      }
+    }
+
+    return current;
+  }
+
+  /**
+   * Set configuration value
+   * @param {Object} config - Configuration object
+   * @param {string} path - Dot-notation path to value
+   * @param {*} value - Value to set
+   */
+  setValue(config, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    let current = config;
+
+    for (const key of keys) {
+      if (!(key in current) || typeof current[key] !== 'object') {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+
+    current[lastKey] = value;
+  }
+}
+
+module.exports = { Config };

package/tools/cli/lib/config.ts

@@ -0,0 +1,227 @@
+import * as fs from 'fs-extra';
+import * as yaml from 'yaml';
+import * as path from 'node:path';
+import type {
+  ConfigReplacements,
+  ValidationSchema,
+  ValidationResult,
+  ConfigObject,
+  PropertySpec,
+} from './types/config.types';
+
+const packageJson = require('../../../package.json');
+
+/**
+ * Configuration utility class
+ */
+export class Config {
+  /**
+   * Load a YAML configuration file
+   * @param configPath - Path to config file
+   * @returns Parsed configuration
+   */
+  async loadYaml(configPath: string): Promise<ConfigObject> {
+    if (!(await fs.pathExists(configPath))) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+
+    const content = await fs.readFile(configPath, 'utf8');
+    return yaml.parse(content) as ConfigObject;
+  }
+
+  /**
+   * Save configuration to YAML file
+   * @param configPath - Path to config file
+   * @param config - Configuration object
+   */
+  async saveYaml(configPath: string, config: ConfigObject): Promise<void> {
+    const yamlContent = yaml.dump(config, {
+      indent: 2,
+      lineWidth: 120,
+      noRefs: true,
+    });
+
+    await fs.ensureDir(path.dirname(configPath));
+    // Ensure POSIX-compliant final newline
+    const content = yamlContent.endsWith('\n') ? yamlContent : yamlContent + '\n';
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Process configuration file (replace placeholders)
+   * @param configPath - Path to config file
+   * @param replacements - Replacement values
+   */
+  async processConfig(configPath: string, replacements: ConfigReplacements = {}): Promise<void> {
+    let content = await fs.readFile(configPath, 'utf8');
+
+    // Standard replacements
+    const standardReplacements: ConfigReplacements = {
+      '{project-root}': replacements.root || '',
+      '{module}': replacements.module || '',
+      '{version}': replacements.version || packageJson.version,
+      '{date}': new Date().toISOString().split('T')[0],
+    };
+
+    // Apply all replacements
+    const allReplacements = { ...standardReplacements, ...replacements };
+
+    for (const [placeholder, value] of Object.entries(allReplacements)) {
+      if (typeof placeholder === 'string' && typeof value === 'string') {
+        const regex = new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`), 'g');
+        content = content.replace(regex, value);
+      }
+    }
+
+    await fs.writeFile(configPath, content, 'utf8');
+  }
+
+  /**
+   * Merge configurations
+   * @param base - Base configuration
+   * @param override - Override configuration
+   * @returns Merged configuration
+   */
+  mergeConfigs(base: ConfigObject, override: ConfigObject): ConfigObject {
+    return this.deepMerge(base, override);
+  }
+
+  /**
+   * Deep merge two objects
+   * @param target - Target object
+   * @param source - Source object
+   * @returns Merged object
+   */
+  deepMerge(target: ConfigObject, source: ConfigObject): ConfigObject {
+    const output = { ...target };
+
+    if (this.isObject(target) && this.isObject(source)) {
+      for (const key of Object.keys(source)) {
+        if (this.isObject(source[key])) {
+          if (key in target) {
+            output[key] = this.deepMerge(
+              target[key] as ConfigObject,
+              source[key] as ConfigObject
+            );
+          } else {
+            output[key] = source[key];
+          }
+        } else {
+          output[key] = source[key];
+        }
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Check if value is an object
+   * @param item - Item to check
+   * @returns True if object
+   */
+  isObject(item: unknown): item is ConfigObject {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+  }
+
+  /**
+   * Validate configuration against schema
+   * @param config - Configuration to validate
+   * @param schema - Validation schema
+   * @returns Validation result
+   */
+  validateConfig(config: ConfigObject, schema: ValidationSchema): ValidationResult {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Check required fields
+    if (schema.required) {
+      for (const field of schema.required) {
+        if (!(field in config)) {
+          errors.push(`Missing required field: ${field}`);
+        }
+      }
+    }
+
+    // Check field types
+    if (schema.properties) {
+      for (const [field, spec] of Object.entries(schema.properties)) {
+        if (field in config) {
+          const value = config[field];
+          const expectedType = spec.type;
+
+          if (expectedType === 'array' && !Array.isArray(value)) {
+            errors.push(`Field '${field}' should be an array`);
+          } else if (expectedType === 'object' && !this.isObject(value)) {
+            errors.push(`Field '${field}' should be an object`);
+          } else if (expectedType === 'string' && typeof value !== 'string') {
+            errors.push(`Field '${field}' should be a string`);
+          } else if (expectedType === 'number' && typeof value !== 'number') {
+            errors.push(`Field '${field}' should be a number`);
+          } else if (expectedType === 'boolean' && typeof value !== 'boolean') {
+            errors.push(`Field '${field}' should be a boolean`);
+          }
+
+          // Check enum values
+          if (spec.enum && !spec.enum.includes(value)) {
+            errors.push(`Field '${field}' must be one of: ${spec.enum.join(', ')}`);
+          }
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+    };
+  }
+
+  /**
+   * Get configuration value with fallback
+   * @param config - Configuration object
+   * @param path - Dot-notation path to value
+   * @param defaultValue - Default value if not found
+   * @returns Configuration value
+   */
+  getValue<T = unknown>(config: ConfigObject, path: string, defaultValue: T | null = null): T | null {
+    const keys = path.split('.');
+    let current: unknown = config;
+
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = (current as Record<string, unknown>)[key];
+      } else {
+        return defaultValue;
+      }
+    }
+
+    return current as T;
+  }
+
+  /**
+   * Set configuration value
+   * @param config - Configuration object
+   * @param path - Dot-notation path to value
+   * @param value - Value to set
+   */
+  setValue(config: ConfigObject, path: string, value: unknown): void {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    if (!lastKey) return;
+
+    let current: Record<string, unknown> = config;
+
+    for (const key of keys) {
+      if (!(key in current) || typeof current[key] !== 'object') {
+        current[key] = {};
+      }
+      current = current[key] as Record<string, unknown>;
+    }
+
+    current[lastKey] = value;
+  }
+}
+
+// Export for backward compatibility
+module.exports = { Config };