bmad-elsabro 1.0.0

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

@@ -0,0 +1,215 @@
+import * as fs from 'fs-extra';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import type { Stats } from 'fs-extra';
+
+/**
+ * Copy options interface
+ */
+export interface CopyOptions {
+  overwrite?: boolean;
+  errorOnExist?: boolean;
+  filter?: (src: string) => boolean;
+}
+
+/**
+ * File operations utility class
+ */
+export class FileOps {
+  /**
+   * Copy a directory recursively
+   * @param source - Source directory
+   * @param dest - Destination directory
+   * @param options - Copy options
+   */
+  async copyDirectory(source: string, dest: string, options: CopyOptions = {}): Promise<void> {
+    const defaultOptions: CopyOptions = {
+      overwrite: true,
+      errorOnExist: false,
+      filter: (src: string) => !this.shouldIgnore(src),
+    };
+
+    const copyOptions = { ...defaultOptions, ...options };
+    await fs.copy(source, dest, copyOptions);
+  }
+
+  /**
+   * Sync directory (selective copy preserving modifications)
+   * @param source - Source directory
+   * @param dest - Destination directory
+   */
+  async syncDirectory(source: string, dest: string): Promise<void> {
+    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 dir - Directory path
+   * @returns List of relative file paths
+   */
+  async getFileList(dir: string): Promise<string[]> {
+    const files: string[] = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return files;
+    }
+
+    const walk = async (currentDir: string, baseDir: string): Promise<void> => {
+      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 filePath - File path
+   * @returns File hash
+   */
+  async getFileHash(filePath: string): Promise<string> {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (data: Buffer) => hash.update(data));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Check if a path should be ignored
+   * @param filePath - Path to check
+   * @returns True if should be ignored
+   */
+  shouldIgnore(filePath: string): boolean {
+    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 dir - Directory path
+   */
+  async ensureDir(dir: string): Promise<void> {
+    await fs.ensureDir(dir);
+  }
+
+  /**
+   * Remove directory or file
+   * @param targetPath - Path to remove
+   */
+  async remove(targetPath: string): Promise<void> {
+    if (await fs.pathExists(targetPath)) {
+      await fs.remove(targetPath);
+    }
+  }
+
+  /**
+   * Read file content
+   * @param filePath - File path
+   * @returns File content
+   */
+  async readFile(filePath: string): Promise<string> {
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  /**
+   * Write file content
+   * @param filePath - File path
+   * @param content - File content
+   */
+  async writeFile(filePath: string, content: string): Promise<void> {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  /**
+   * Check if path exists
+   * @param targetPath - Path to check
+   * @returns True if exists
+   */
+  async exists(targetPath: string): Promise<boolean> {
+    return await fs.pathExists(targetPath);
+  }
+
+  /**
+   * Get file or directory stats
+   * @param targetPath - Path to check
+   * @returns File stats
+   */
+  async stat(targetPath: string): Promise<Stats> {
+    return await fs.stat(targetPath);
+  }
+}
+
+// Export for backward compatibility
+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,
+};