mdan-cli 2.5.0 → 2.5.2

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/file-ops.js

@@ -0,0 +1,204 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+/**
+ * File operations utility class
+ */
+class FileOps {
+  /**
+   * Copy a directory recursively
+   * @param {string} source - Source directory
+   * @param {string} dest - Destination directory
+   * @param {Object} options - Copy options
+   */
+  async copyDirectory(source, dest, options = {}) {
+    const defaultOptions = {
+      overwrite: true,
+      errorOnExist: false,
+      filter: (src) => !this.shouldIgnore(src),
+    };
+
+    const copyOptions = { ...defaultOptions, ...options };
+    await fs.copy(source, dest, copyOptions);
+  }
+
+  /**
+   * Sync directory (selective copy preserving modifications)
+   * @param {string} source - Source directory
+   * @param {string} dest - Destination directory
+   */
+  async syncDirectory(source, dest) {
+    const sourceFiles = await this.getFileList(source);
+
+    for (const file of sourceFiles) {
+      const sourceFile = path.join(source, file);
+      const destFile = path.join(dest, file);
+
+      // Check if destination file exists
+      if (await fs.pathExists(destFile)) {
+        // Compare checksums to see if file has been modified
+        const sourceHash = await this.getFileHash(sourceFile);
+        const destHash = await this.getFileHash(destFile);
+
+        if (sourceHash === destHash) {
+          // Files are identical, safe to update
+          await fs.copy(sourceFile, destFile, { overwrite: true });
+        } else {
+          // File has been modified, check timestamps
+          const sourceStats = await fs.stat(sourceFile);
+          const destStats = await fs.stat(destFile);
+
+          if (sourceStats.mtime > destStats.mtime) {
+            // Source is newer, update
+            await fs.copy(sourceFile, destFile, { overwrite: true });
+          }
+          // Otherwise, preserve user modifications
+        }
+      } else {
+        // New file, copy it
+        await fs.ensureDir(path.dirname(destFile));
+        await fs.copy(sourceFile, destFile);
+      }
+    }
+
+    // Remove files that no longer exist in source
+    const destFiles = await this.getFileList(dest);
+    for (const file of destFiles) {
+      const sourceFile = path.join(source, file);
+      const destFile = path.join(dest, file);
+
+      if (!(await fs.pathExists(sourceFile))) {
+        await fs.remove(destFile);
+      }
+    }
+  }
+
+  /**
+   * Get list of all files in a directory
+   * @param {string} dir - Directory path
+   * @returns {Array} List of relative file paths
+   */
+  async getFileList(dir) {
+    const files = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return files;
+    }
+
+    const walk = async (currentDir, baseDir) => {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        if (entry.isDirectory() && !this.shouldIgnore(fullPath)) {
+          await walk(fullPath, baseDir);
+        } else if (entry.isFile() && !this.shouldIgnore(fullPath)) {
+          files.push(path.relative(baseDir, fullPath));
+        }
+      }
+    };
+
+    await walk(dir, dir);
+    return files;
+  }
+
+  /**
+   * Get file hash for comparison
+   * @param {string} filePath - File path
+   * @returns {string} File hash
+   */
+  async getFileHash(filePath) {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (data) => hash.update(data));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Check if a path should be ignored
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if should be ignored
+   */
+  shouldIgnore(filePath) {
+    const ignoredPatterns = ['.git', '.DS_Store', 'node_modules', '*.swp', '*.tmp', '.idea', '.vscode', '__pycache__', '*.pyc'];
+
+    const basename = path.basename(filePath);
+
+    for (const pattern of ignoredPatterns) {
+      if (pattern.includes('*')) {
+        // Simple glob pattern matching
+        const regex = new RegExp(pattern.replace('*', '.*'));
+        if (regex.test(basename)) {
+          return true;
+        }
+      } else if (basename === pattern) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dir - Directory path
+   */
+  async ensureDir(dir) {
+    await fs.ensureDir(dir);
+  }
+
+  /**
+   * Remove directory or file
+   * @param {string} targetPath - Path to remove
+   */
+  async remove(targetPath) {
+    if (await fs.pathExists(targetPath)) {
+      await fs.remove(targetPath);
+    }
+  }
+
+  /**
+   * Read file content
+   * @param {string} filePath - File path
+   * @returns {string} File content
+   */
+  async readFile(filePath) {
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  /**
+   * Write file content
+   * @param {string} filePath - File path
+   * @param {string} content - File content
+   */
+  async writeFile(filePath, content) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  /**
+   * Check if path exists
+   * @param {string} targetPath - Path to check
+   * @returns {boolean} True if exists
+   */
+  async exists(targetPath) {
+    return await fs.pathExists(targetPath);
+  }
+
+  /**
+   * Get file or directory stats
+   * @param {string} targetPath - Path to check
+   * @returns {Object} File stats
+   */
+  async stat(targetPath) {
+    return await fs.stat(targetPath);
+  }
+}
+
+module.exports = { FileOps };

package/tools/cli/lib/platform-codes.js

@@ -0,0 +1,116 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+const { getProjectRoot } = require('./project-root');
+
+/**
+ * Platform Codes Manager
+ * Loads and provides access to the centralized platform codes configuration
+ */
+class PlatformCodes {
+  constructor() {
+    this.configPath = path.join(getProjectRoot(), 'tools', 'platform-codes.yaml');
+    this.loadConfig();
+  }
+
+  /**
+   * Load the platform codes configuration
+   */
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const content = fs.readFileSync(this.configPath, 'utf8');
+        this.config = yaml.parse(content);
+      } else {
+        console.warn(`Platform codes config not found at ${this.configPath}`);
+        this.config = { platforms: {} };
+      }
+    } catch (error) {
+      console.error(`Error loading platform codes: ${error.message}`);
+      this.config = { platforms: {} };
+    }
+  }
+
+  /**
+   * Get all platform codes
+   * @returns {Object} All platform configurations
+   */
+  getAllPlatforms() {
+    return this.config.platforms || {};
+  }
+
+  /**
+   * Get a specific platform configuration
+   * @param {string} code - Platform code
+   * @returns {Object|null} Platform configuration or null if not found
+   */
+  getPlatform(code) {
+    return this.config.platforms[code] || null;
+  }
+
+  /**
+   * Check if a platform code is valid
+   * @param {string} code - Platform code to validate
+   * @returns {boolean} True if valid
+   */
+  isValidPlatform(code) {
+    return code in this.config.platforms;
+  }
+
+  /**
+   * Get all preferred platforms
+   * @returns {Array} Array of preferred platform codes
+   */
+  getPreferredPlatforms() {
+    return Object.entries(this.config.platforms)
+      .filter(([, config]) => config.preferred)
+      .map(([code]) => code);
+  }
+
+  /**
+   * Get platforms by category
+   * @param {string} category - Category to filter by
+   * @returns {Array} Array of platform codes in the category
+   */
+  getPlatformsByCategory(category) {
+    return Object.entries(this.config.platforms)
+      .filter(([, config]) => config.category === category)
+      .map(([code]) => code);
+  }
+
+  /**
+   * Get platform display name
+   * @param {string} code - Platform code
+   * @returns {string} Display name or code if not found
+   */
+  getDisplayName(code) {
+    const platform = this.getPlatform(code);
+    return platform ? platform.name : code;
+  }
+
+  /**
+   * Validate platform code format
+   * @param {string} code - Platform code to validate
+   * @returns {boolean} True if format is valid
+   */
+  isValidFormat(code) {
+    const conventions = this.config.conventions || {};
+    const pattern = conventions.allowed_characters || 'a-z0-9-';
+    const maxLength = conventions.max_code_length || 20;
+
+    const regex = new RegExp(`^[${pattern}]+$`);
+    return regex.test(code) && code.length <= maxLength;
+  }
+
+  /**
+   * Get all platform codes as array
+   * @returns {Array} Array of platform codes
+   */
+  getCodes() {
+    return Object.keys(this.config.platforms);
+  }
+  config = null;
+}
+
+// Export singleton instance
+module.exports = new PlatformCodes();

package/tools/cli/lib/project-root.js

@@ -0,0 +1,77 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+
+/**
+ * Find the BMAD project root directory by looking for package.json
+ * or specific BMAD markers
+ */
+function findProjectRoot(startPath = __dirname) {
+  let currentPath = path.resolve(startPath);
+
+  // Keep going up until we find package.json with bmad-method
+  while (currentPath !== path.dirname(currentPath)) {
+    const packagePath = path.join(currentPath, 'package.json');
+
+    if (fs.existsSync(packagePath)) {
+      try {
+        const pkg = fs.readJsonSync(packagePath);
+        // Check if this is the BMAD project
+        if (pkg.name === 'bmad-method' || fs.existsSync(path.join(currentPath, 'src', 'core'))) {
+          return currentPath;
+        }
+      } catch {
+        // Continue searching
+      }
+    }
+
+    // Also check for src/core as a marker
+    if (fs.existsSync(path.join(currentPath, 'src', 'core', 'agents'))) {
+      return currentPath;
+    }
+
+    currentPath = path.dirname(currentPath);
+  }
+
+  // If we can't find it, use process.cwd() as fallback
+  return process.cwd();
+}
+
+// Cache the project root after first calculation
+let cachedRoot = null;
+
+function getProjectRoot() {
+  if (!cachedRoot) {
+    cachedRoot = findProjectRoot();
+  }
+  return cachedRoot;
+}
+
+/**
+ * Get path to source directory
+ */
+function getSourcePath(...segments) {
+  return path.join(getProjectRoot(), 'src', ...segments);
+}
+
+/**
+ * Get path to a module's directory
+ * bmm is a built-in module directly under src/
+ * core is also directly under src/
+ * All other modules are stored remote
+ */
+function getModulePath(moduleName, ...segments) {
+  if (moduleName === 'core') {
+    return getSourcePath('core', ...segments);
+  }
+  if (moduleName === 'bmm') {
+    return getSourcePath('bmm', ...segments);
+  }
+  return getSourcePath('modules', moduleName, ...segments);
+}
+
+module.exports = {
+  getProjectRoot,
+  getSourcePath,
+  getModulePath,
+  findProjectRoot,
+};