create-byan-agent 1.1.3 → 1.2.1

package/lib/utils/node-detector.js

@@ -0,0 +1,58 @@
+/**
+ * Node.js Detector Utility
+ * 
+ * Detects Node.js version.
+ * 
+ * @module utils/node-detector
+ */
+
+/**
+ * Detect Node.js version
+ * 
+ * @returns {string} - Version string (e.g., '18.19.0')
+ */
+function detect() {
+  return process.version.slice(1); // Remove 'v' prefix
+}
+
+/**
+ * Compare two semver versions
+ * 
+ * Strips version suffixes (-beta, -rc1, etc.) before comparison.
+ * 
+ * @param {string} version1 - First version
+ * @param {string} version2 - Second version
+ * @returns {number} - -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(version1, version2) {
+  // Strip suffixes: '18.0.0-beta' → '18.0.0'
+  const cleanV1 = version1.replace(/-.*$/, '');
+  const cleanV2 = version2.replace(/-.*$/, '');
+  
+  const v1Parts = cleanV1.split('.').map(Number);
+  const v2Parts = cleanV2.split('.').map(Number);
+  
+  for (let i = 0; i < 3; i++) {
+    if (v1Parts[i] > v2Parts[i]) return 1;
+    if (v1Parts[i] < v2Parts[i]) return -1;
+  }
+  
+  return 0;
+}
+
+/**
+ * Check if Node version meets minimum requirement
+ * 
+ * @param {string} currentVersion - Current Node version
+ * @param {string} requiredVersion - Required Node version
+ * @returns {boolean}
+ */
+function meetsRequirement(currentVersion, requiredVersion) {
+  return compareVersions(currentVersion, requiredVersion) >= 0;
+}
+
+module.exports = {
+  detect,
+  compareVersions,
+  meetsRequirement
+};

package/lib/utils/os-detector.js

@@ -0,0 +1,74 @@
+/**
+ * OS Detector Utility
+ * 
+ * Detects operating system and version.
+ * 
+ * @module utils/os-detector
+ */
+
+const os = require('os');
+
+/**
+ * Detect operating system
+ * 
+ * @returns {{name: string, version: string, platform: string}}
+ */
+function detect() {
+  const platform = os.platform();
+  const release = os.release();
+  
+  let name;
+  switch (platform) {
+    case 'win32':
+      name = 'windows';
+      break;
+    case 'darwin':
+      name = 'macos';
+      break;
+    case 'linux':
+      name = 'linux';
+      break;
+    default:
+      name = 'unknown';
+  }
+  
+  return {
+    name,
+    version: release,
+    platform
+  };
+}
+
+/**
+ * Check if running on Windows
+ * 
+ * @returns {boolean}
+ */
+function isWindows() {
+  return os.platform() === 'win32';
+}
+
+/**
+ * Check if running on macOS
+ * 
+ * @returns {boolean}
+ */
+function isMacOS() {
+  return os.platform() === 'darwin';
+}
+
+/**
+ * Check if running on Linux
+ * 
+ * @returns {boolean}
+ */
+function isLinux() {
+  return os.platform() === 'linux';
+}
+
+module.exports = {
+  detect,
+  isWindows,
+  isMacOS,
+  isLinux
+};

package/lib/utils/yaml-utils.js

@@ -0,0 +1,87 @@
+/**
+ * YAML Utilities
+ * 
+ * Wrapper around js-yaml for YAML parsing/dumping.
+ * 
+ * @module utils/yaml-utils
+ */
+
+const yaml = require('js-yaml');
+const fileUtils = require('./file-utils');
+
+/**
+ * Parse YAML string
+ * 
+ * @param {string} yamlString - YAML string
+ * @returns {Object}
+ */
+function parse(yamlString) {
+  return yaml.load(yamlString);
+}
+
+/**
+ * Dump object to YAML string
+ * 
+ * @param {Object} obj - Object to dump
+ * @returns {string}
+ */
+function dump(obj) {
+  return yaml.dump(obj, {
+    indent: 2,
+    lineWidth: -1
+  });
+}
+
+/**
+ * Read YAML file
+ * 
+ * @param {string} filePath - YAML file path
+ * @returns {Promise<Object>}
+ */
+async function readYAML(filePath) {
+  const content = await fileUtils.readFile(filePath);
+  return parse(content);
+}
+
+/**
+ * Write YAML file
+ * 
+ * @param {string} filePath - YAML file path
+ * @param {Object} data - Data to write
+ * @returns {Promise<void>}
+ */
+async function writeYAML(filePath, data) {
+  const yamlString = dump(data);
+  await fileUtils.writeFile(filePath, yamlString);
+}
+
+/**
+ * Extract YAML frontmatter from markdown
+ * 
+ * @param {string} markdownContent - Markdown content
+ * @returns {{frontmatter: Object | null, content: string}}
+ */
+function extractFrontmatter(markdownContent) {
+  const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/;
+  const match = markdownContent.match(frontmatterRegex);
+  
+  if (!match) {
+    return {
+      frontmatter: null,
+      content: markdownContent
+    };
+  }
+  
+  return {
+    frontmatter: parse(match[1]),
+    content: match[2]
+  };
+}
+
+module.exports = {
+  parse,
+  dump,
+  readYAML,
+  writeYAML,
+  extractFrontmatter
+};

package/lib/yanstaller/backuper.js

@@ -0,0 +1,308 @@
+/**
+ * BACKUPER Module
+ * 
+ * Backs up and restores _bmad/ directory.
+ * 
+ * Phase 6: 24h development
+ * 
+ * @module yanstaller/backuper
+ */
+
+const path = require('path');
+const fs = require('fs-extra');
+const fileUtils = require('../utils/file-utils');
+const logger = require('../utils/logger');
+
+/**
+ * @typedef {Object} BackupResult
+ * @property {boolean} success
+ * @property {string} backupPath - Path to backup directory
+ * @property {number} filesBackedUp
+ * @property {number} size - Backup size in bytes
+ * @property {number} duration - Backup duration in ms
+ */
+
+/**
+ * @typedef {Object} BackupInfo
+ * @property {string} path - Backup directory path
+ * @property {number} timestamp - Creation timestamp
+ * @property {Date} created - Creation date
+ * @property {number} size - Size in bytes
+ * @property {number} files - Number of files
+ */
+
+/**
+ * Backup _bmad/ directory
+ * 
+ * @param {string} bmadPath - Path to _bmad/ directory
+ * @param {Object} options - Backup options
+ * @returns {Promise<BackupResult>}
+ */
+async function backup(bmadPath, options = {}) {
+  const startTime = Date.now();
+  const timestamp = Date.now();
+  const backupPath = `${bmadPath}.backup-${timestamp}`;
+  
+  try {
+    logger.info(`Creating backup: ${backupPath}`);
+    
+    // Check if source exists
+    if (!await fileUtils.exists(bmadPath)) {
+      throw new BackupError(`Source path does not exist: ${bmadPath}`);
+    }
+    
+    // Copy entire _bmad/ to backup path
+    await fileUtils.copy(bmadPath, backupPath);
+    
+    // Count files and calculate size
+    const { files, size } = await getDirectoryStats(backupPath);
+    
+    // Create metadata file
+    const metadata = {
+      timestamp,
+      created: new Date(timestamp).toISOString(),
+      source: bmadPath,
+      files,
+      size,
+      version: '1.2.0'
+    };
+    
+    await fileUtils.writeFile(
+      path.join(backupPath, '.backup-metadata.json'),
+      JSON.stringify(metadata, null, 2)
+    );
+    
+    const duration = Date.now() - startTime;
+    
+    logger.info(`✓ Backup created: ${files} files, ${formatSize(size)}, ${duration}ms`);
+    
+    return {
+      success: true,
+      backupPath,
+      filesBackedUp: files,
+      size,
+      duration
+    };
+  } catch (error) {
+    throw new BackupError(`Failed to backup ${bmadPath}`, { cause: error });
+  }
+}
+
+/**
+ * Restore from backup
+ * 
+ * @param {string} backupPath - Path to backup directory
+ * @param {string} targetPath - Target restoration path
+ * @param {Object} options - Restore options
+ * @returns {Promise<void>}
+ */
+async function restore(backupPath, targetPath, options = {}) {
+  try {
+    logger.info(`Restoring from backup: ${backupPath}`);
+    
+    // Verify backup exists
+    if (!await fileUtils.exists(backupPath)) {
+      throw new BackupError(`Backup not found: ${backupPath}`);
+    }
+    
+    // Verify backup metadata
+    const metadataPath = path.join(backupPath, '.backup-metadata.json');
+    if (await fileUtils.exists(metadataPath)) {
+      const metadata = await fileUtils.readJSON(metadataPath);
+      logger.info(`Backup created: ${metadata.created}, ${metadata.files} files`);
+    }
+    
+    // Create backup of current state before restoring (if exists)
+    if (await fileUtils.exists(targetPath) && !options.skipCurrentBackup) {
+      logger.info('Creating backup of current state before restore...');
+      await backup(targetPath);
+    }
+    
+    // Remove current installation
+    if (await fileUtils.exists(targetPath)) {
+      await fileUtils.remove(targetPath);
+    }
+    
+    // Copy backup to target
+    await fileUtils.copy(backupPath, targetPath);
+    
+    // Remove metadata file from restored directory
+    const restoredMetadata = path.join(targetPath, '.backup-metadata.json');
+    if (await fileUtils.exists(restoredMetadata)) {
+      await fileUtils.remove(restoredMetadata);
+    }
+    
+    logger.info('✓ Restore completed successfully');
+  } catch (error) {
+    throw new BackupError(`Failed to restore from ${backupPath}`, { cause: error });
+  }
+}
+
+/**
+ * List available backups
+ * 
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<BackupInfo[]>} - Array of backup info objects
+ */
+async function listBackups(projectRoot) {
+  try {
+    const backups = [];
+    const bmadPath = path.join(projectRoot, '_bmad');
+    const parentDir = path.dirname(bmadPath);
+    
+    // Find all _bmad.backup-* directories
+    const items = await fileUtils.readDir(parentDir);
+    
+    for (const item of items) {
+      if (item.startsWith('_bmad.backup-')) {
+        const backupPath = path.join(parentDir, item);
+        const timestamp = parseInt(item.replace('_bmad.backup-', ''));
+        
+        // Read metadata if available
+        const metadataPath = path.join(backupPath, '.backup-metadata.json');
+        let metadata = { files: 0, size: 0 };
+        
+        if (await fileUtils.exists(metadataPath)) {
+          metadata = await fileUtils.readJSON(metadataPath);
+        } else {
+          // Calculate if no metadata
+          const stats = await getDirectoryStats(backupPath);
+          metadata.files = stats.files;
+          metadata.size = stats.size;
+        }
+        
+        backups.push({
+          path: backupPath,
+          timestamp,
+          created: new Date(timestamp),
+          size: metadata.size,
+          files: metadata.files
+        });
+      }
+    }
+    
+    // Sort by timestamp (newest first)
+    backups.sort((a, b) => b.timestamp - a.timestamp);
+    
+    return backups;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return []; // No backups found
+    }
+    throw error;
+  }
+}
+
+/**
+ * Clean old backups (keep last N)
+ * 
+ * @param {string} projectRoot - Project root directory
+ * @param {number} keep - Number of backups to keep
+ * @returns {Promise<number>} - Number of backups deleted
+ */
+async function cleanOldBackups(projectRoot, keep = 3) {
+  try {
+    const backups = await listBackups(projectRoot);
+    
+    if (backups.length <= keep) {
+      return 0; // Nothing to delete
+    }
+    
+    // Delete oldest backups
+    const toDelete = backups.slice(keep);
+    let deleted = 0;
+    
+    for (const backup of toDelete) {
+      try {
+        await fileUtils.remove(backup.path);
+        logger.info(`✓ Deleted old backup: ${path.basename(backup.path)}`);
+        deleted++;
+      } catch (error) {
+        logger.warn(`Failed to delete backup ${backup.path}: ${error.message}`);
+      }
+    }
+    
+    return deleted;
+  } catch (error) {
+    throw new BackupError(`Failed to clean old backups: ${error.message}`);
+  }
+}
+
+/**
+ * Get backup size
+ * 
+ * @param {string} backupPath - Path to backup directory
+ * @returns {Promise<number>} - Size in bytes
+ */
+async function getBackupSize(backupPath) {
+  const stats = await getDirectoryStats(backupPath);
+  return stats.size;
+}
+
+/**
+ * Get directory statistics (files count and total size)
+ * 
+ * @param {string} dirPath - Directory path
+ * @returns {Promise<{files: number, size: number}>}
+ */
+async function getDirectoryStats(dirPath) {
+  let files = 0;
+  let size = 0;
+  
+  async function traverse(currentPath) {
+    const items = await fileUtils.readDir(currentPath);
+    
+    for (const item of items) {
+      const itemPath = path.join(currentPath, item);
+      const stats = await fs.stat(itemPath);
+      
+      if (stats.isDirectory()) {
+        await traverse(itemPath);
+      } else {
+        files++;
+        size += stats.size;
+      }
+    }
+  }
+  
+  await traverse(dirPath);
+  
+  return { files, size };
+}
+
+/**
+ * Format size in human-readable format
+ * 
+ * @param {number} bytes - Size in bytes
+ * @returns {string}
+ */
+function formatSize(bytes) {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+  
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  
+  return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+class BackupError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = 'BackupError';
+  }
+}
+
+module.exports = {
+  backup,
+  restore,
+  listBackups,
+  cleanOldBackups,
+  getBackupSize,
+  getDirectoryStats,
+  formatSize,
+  BackupError
+};

package/lib/yanstaller/detector.js

@@ -0,0 +1,141 @@
+/**
+ * DETECTOR Module
+ * 
+ * Detects OS, Node.js version, Git, and installed platforms.
+ * 
+ * Phase 1: 40h development
+ * 
+ * @module yanstaller/detector
+ */
+
+const osDetector = require('../utils/os-detector');
+const nodeDetector = require('../utils/node-detector');
+const gitDetector = require('../utils/git-detector');
+const platforms = require('../platforms');
+
+/**
+ * @typedef {Object} DetectionResult
+ * @property {string} os - 'windows' | 'linux' | 'macos'
+ * @property {string} osVersion - e.g., '11' for Windows 11
+ * @property {string} nodeVersion - e.g., '18.19.0'
+ * @property {boolean} hasGit
+ * @property {string} [gitVersion] - e.g., '2.43.0'
+ * @property {PlatformInfo[]} platforms - Detected platforms
+ */
+
+/**
+ * @typedef {Object} PlatformInfo
+ * @property {string} name - 'copilot-cli' | 'vscode' | 'claude' | 'codex'
+ * @property {boolean} detected
+ * @property {string} [path] - Installation path if detected
+ * @property {string} [version] - Version if detected
+ */
+
+const logger = require('../utils/logger');
+
+/**
+ * Detect full environment
+ * 
+ * Runs parallel detection for speed.
+ * Non-blocking: platform detection failures are caught and logged.
+ * 
+ * @returns {Promise<DetectionResult>}
+ */
+async function detect() {
+  // Parallel detection for speed (Mantra #7 KISS)
+  const [osInfo, nodeVersion, gitInfo] = await Promise.all([
+    osDetector.detect(),
+    Promise.resolve(nodeDetector.detect()), // Sync wrapped in Promise
+    gitDetector.detect()
+  ]);
+  
+  // Platform detection with timeout protection
+  const platformNames = ['copilot-cli', 'vscode', 'claude', 'codex'];
+  const platformsInfo = await Promise.all(
+    platformNames.map(name => detectPlatform(name))
+  );
+  
+  // Check if ALL platforms failed
+  const allFailed = platformsInfo.every(p => !p.detected);
+  if (allFailed) {
+    const errors = platformsInfo
+      .filter(p => p.error)
+      .map(p => `${p.name}: ${p.error}`)
+      .join(', ');
+    if (errors) {
+      logger.warn(`0/4 platforms detected. Errors: [${errors}]`);
+    }
+  }
+  
+  return {
+    os: osInfo.name,
+    osVersion: osInfo.version,
+    nodeVersion,
+    hasGit: gitInfo.installed,
+    gitVersion: gitInfo.version,
+    platforms: platformsInfo
+  };
+}
+
+/**
+ * Check if Node.js version meets minimum requirement
+ * 
+ * Handles version suffixes (-beta, -rc1) by stripping them.
+ * 
+ * @param {string} currentVersion - e.g., '18.19.0'
+ * @param {string} requiredVersion - e.g., '18.0.0'
+ * @returns {boolean}
+ */
+function isNodeVersionValid(currentVersion, requiredVersion) {
+  return nodeDetector.meetsRequirement(currentVersion, requiredVersion);
+}
+
+/**
+ * Detect specific platform
+ * 
+ * Non-blocking: errors are caught and returned in result.
+ * 
+ * @param {string} platformName - 'copilot-cli' | 'vscode' | 'claude' | 'codex'
+ * @returns {Promise<PlatformInfo>}
+ */
+async function detectPlatform(platformName) {
+  const platform = platforms[platformName];
+  if (!platform) {
+    throw new Error(`Unknown platform: ${platformName}`);
+  }
+  
+  try {
+    const detected = await platform.detect();
+    
+    // Handle timeout response format (object with detected + error)
+    if (typeof detected === 'object' && 'error' in detected) {
+      logger.warn(`Platform ${platformName} detection failed: ${detected.error}`);
+      return {
+        name: platformName,
+        detected: false,
+        error: detected.error
+      };
+    }
+    
+    return {
+      name: platformName,
+      detected: !!detected,
+      path: detected ? platform.getPath() : undefined
+    };
+  } catch (error) {
+    // Non-blocking: platform detection failure shouldn't crash detection
+    // Error UX: Log warning and include in report for user visibility
+    logger.warn(`Platform ${platformName} detection failed: ${error.message}`);
+    return {
+      name: platformName,
+      detected: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  detect,
+  isNodeVersionValid,
+  detectPlatform
+};