create-byan-agent 2.7.8 → 2.8.0

package/lib/utils/version-compare.js

@@ -0,0 +1,69 @@
+/**
+ * Version Comparison Utility
+ *
+ * Compares semver versions and fetches latest from npm registry.
+ *
+ * @module utils/version-compare
+ */
+
+const https = require('https');
+
+/**
+ * Compare two semver version strings.
+ *
+ * @param {string} a - First version (e.g., '2.7.9')
+ * @param {string} b - Second version (e.g., '2.8.0')
+ * @returns {number} -1 if a < b, 0 if equal, 1 if a > b
+ */
+function compareVersions(a, b) {
+  const partsA = a.replace(/^v/, '').split('.').map(Number);
+  const partsB = b.replace(/^v/, '').split('.').map(Number);
+  const len = Math.max(partsA.length, partsB.length);
+
+  for (let i = 0; i < len; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Fetch the latest published version of a package from npm registry.
+ *
+ * @param {string} packageName - npm package name
+ * @returns {Promise<string>} Latest version string
+ */
+function getLatestVersion(packageName) {
+  const url = `https://registry.npmjs.org/${packageName}/latest`;
+
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'Accept': 'application/json' } }, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`npm registry returned ${res.statusCode} for ${packageName}`));
+        res.resume();
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve(parsed.version);
+        } catch (err) {
+          reject(new Error(`Failed to parse npm registry response: ${err.message}`));
+        }
+      });
+    }).on('error', (err) => {
+      reject(new Error(`Failed to reach npm registry: ${err.message}`));
+    });
+  });
+}
+
+module.exports = {
+  compareVersions,
+  getLatestVersion
+};

package/lib/yanstaller/backuper.js

@@ -1,15 +1,15 @@
 /**
  * BACKUPER Module
- * 
- * Backs up and restores _bmad/ directory.
- * 
- * Phase 6: 24h development
- * 
+ *
+ * Backs up and restores _byan/ directory with timestamp-based snapshots.
+ *
  * @module yanstaller/backuper
  */
 
+const fs = require('fs-extra');
 const path = require('path');
-const fileUtils = require('../utils/file-utils');
+
+const BACKUP_PREFIX = '_byan.backup-';
 
 /**
  * @typedef {Object} BackupResult
@@ -20,75 +20,130 @@ const fileUtils = require('../utils/file-utils');
  */
 
 /**
- * Backup _bmad/ directory
- * 
- * @param {string} bmadPath - Path to _bmad/ directory
+ * Recursively count files and total size in a directory.
+ *
+ * @param {string} dir - Directory to measure
+ * @returns {Promise<{count: number, size: number}>}
+ */
+async function measureDir(dir) {
+  let count = 0;
+  let size = 0;
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const sub = await measureDir(fullPath);
+      count += sub.count;
+      size += sub.size;
+    } else if (entry.isFile()) {
+      const stat = await fs.stat(fullPath);
+      count++;
+      size += stat.size;
+    }
+  }
+
+  return { count, size };
+}
+
+/**
+ * Backup _byan/ directory to a timestamped snapshot.
+ *
+ * @param {string} byanPath - Absolute path to _byan/ directory
  * @returns {Promise<BackupResult>}
  */
-async function backup(bmadPath) {
+async function backup(byanPath) {
+  if (!await fs.pathExists(byanPath)) {
+    throw new BackupError(`Source directory does not exist: ${byanPath}`);
+  }
+
   const timestamp = Date.now();
-  const backupPath = `${bmadPath}.backup-${timestamp}`;
-  
+  const backupPath = path.join(path.dirname(byanPath), `${BACKUP_PREFIX}${timestamp}`);
+
   try {
-    // TODO: Copy entire _bmad/ to backup path
-    // await fileUtils.copy(bmadPath, backupPath);
-    
+    await fs.copy(byanPath, backupPath);
+    const { count, size } = await measureDir(backupPath);
+
     return {
       success: true,
       backupPath,
-      filesBackedUp: 0,
-      size: 0
+      filesBackedUp: count,
+      size
     };
   } catch (error) {
-    throw new BackupError(`Failed to backup ${bmadPath}`, { cause: error });
+    throw new BackupError(`Failed to backup ${byanPath}`, { cause: error });
   }
 }
 
 /**
- * Restore from backup
- * 
- * @param {string} backupPath - Path to backup directory
- * @param {string} targetPath - Target restoration path
+ * Restore from a backup, replacing the current _byan/ directory.
+ *
+ * @param {string} backupPath - Absolute path to the backup directory
+ * @param {string} targetPath - Absolute path to restore into (e.g., _byan/)
  * @returns {Promise<void>}
  */
 async function restore(backupPath, targetPath) {
-  // TODO: Remove current _bmad/, copy backup to target
-  // await fileUtils.remove(targetPath);
-  // await fileUtils.copy(backupPath, targetPath);
+  if (!await fs.pathExists(backupPath)) {
+    throw new BackupError(`Backup not found: ${backupPath}`);
+  }
+
+  await fs.remove(targetPath);
+  await fs.copy(backupPath, targetPath);
 }
 
 /**
- * List available backups
- * 
+ * List available backup directories sorted by timestamp (newest first).
+ *
  * @param {string} projectRoot - Project root directory
- * @returns {Promise<string[]>} - Array of backup paths
+ * @returns {Promise<string[]>} Absolute paths to backup directories
  */
 async function listBackups(projectRoot) {
-  // TODO: Find all _bmad.backup-* directories
-  return [];
+  if (!await fs.pathExists(projectRoot)) return [];
+
+  const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+  const backups = entries
+    .filter(e => e.isDirectory() && e.name.startsWith(BACKUP_PREFIX))
+    .map(e => ({
+      name: e.name,
+      timestamp: parseInt(e.name.slice(BACKUP_PREFIX.length), 10),
+      path: path.join(projectRoot, e.name)
+    }))
+    .filter(b => !isNaN(b.timestamp))
+    .sort((a, b) => b.timestamp - a.timestamp);
+
+  return backups.map(b => b.path);
 }
 
 /**
- * Clean old backups (keep last N)
- * 
+ * Prune old backups, keeping only the N most recent.
+ *
  * @param {string} projectRoot - Project root directory
- * @param {number} keep - Number of backups to keep
- * @returns {Promise<number>} - Number of backups deleted
+ * @param {number} [maxBackups=3] - Number of backups to keep
+ * @returns {Promise<number>} Number of backups deleted
  */
-async function cleanOldBackups(projectRoot, keep = 3) {
-  // TODO: Sort by timestamp, delete oldest
-  return 0;
+async function pruneBackups(projectRoot, maxBackups = 3) {
+  const all = await listBackups(projectRoot);
+
+  if (all.length <= maxBackups) return 0;
+
+  const toDelete = all.slice(maxBackups);
+  for (const backupPath of toDelete) {
+    await fs.remove(backupPath);
+  }
+
+  return toDelete.length;
 }
 
 /**
- * Get backup size
- * 
- * @param {string} backupPath - Path to backup directory
- * @returns {Promise<number>} - Size in bytes
+ * Get total size of a backup directory in bytes.
+ *
+ * @param {string} backupPath - Absolute path to backup directory
+ * @returns {Promise<number>} Size in bytes
  */
 async function getBackupSize(backupPath) {
-  // TODO: Recursively calculate directory size
-  return 0;
+  if (!await fs.pathExists(backupPath)) return 0;
+  const { size } = await measureDir(backupPath);
+  return size;
 }
 
 class BackupError extends Error {
@@ -102,7 +157,8 @@ module.exports = {
   backup,
   restore,
   listBackups,
-  cleanOldBackups,
+  pruneBackups,
   getBackupSize,
-  BackupError
+  BackupError,
+  BACKUP_PREFIX
 };

package/lib/yanstaller/index.js

@@ -6,6 +6,7 @@
  * @module yanstaller
  */
 
+const path = require('path');
 const detector = require('./detector');
 const recommender = require('./recommender');
 const installer = require('./installer');
@@ -13,6 +14,7 @@ const validator = require('./validator');
 const troubleshooter = require('./troubleshooter');
 const interviewer = require('./interviewer');
 const backuper = require('./backuper');
+const updater = require('./updater');
 const wizard = require('./wizard');
 const platformSelector = require('./platform-selector');
 const logger = require('../utils/logger');
@@ -122,18 +124,53 @@ async function uninstall() {
 /**
  * Update existing BYAN installation
  * 
- * @param {string} version - Target version
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} [options={}] - Update options
+ * @param {boolean} [options.force] - Force update even if same version
+ * @param {boolean} [options.preview] - Show diff without applying
+ * @returns {Promise<import('./updater').UpdateResult>}
+ */
+async function update(projectRoot, options = {}) {
+  return updater.update(projectRoot, options);
+}
+
+/**
+ * Rollback to the most recent backup.
+ *
+ * @param {string} projectRoot - Project root directory
  * @returns {Promise<void>}
  */
-async function update(version) {
-  // TODO: Backup → Update agents → Merge configs
+async function rollback(projectRoot) {
+  const backups = await backuper.listBackups(projectRoot);
+  if (backups.length === 0) {
+    throw new Error('No backups found to restore from.');
+  }
+
+  const latestBackup = backups[0];
+  const targetPath = path.join(projectRoot, '_byan');
+  logger.info(`Restoring from ${path.basename(latestBackup)}...`);
+  await backuper.restore(latestBackup, targetPath);
+}
+
+/**
+ * List all available BYAN backups.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string[]>} Absolute paths, newest first
+ */
+async function listBackups(projectRoot) {
+  return backuper.listBackups(projectRoot);
 }
 
 module.exports = {
   install,
   uninstall,
   update,
+  rollback,
+  listBackups,
   // Expose for testing
   detector,
-  platformSelector
+  platformSelector,
+  updater,
+  backuper
 };

package/lib/yanstaller/updater.js

@@ -0,0 +1,271 @@
+/**
+ * UPDATER Module
+ *
+ * Orchestrates the BYAN update lifecycle:
+ * version check -> diff -> backup -> apply -> manifest -> validate.
+ *
+ * @module yanstaller/updater
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { compareVersions, getLatestVersion } = require('../utils/version-compare');
+const { diffFiles } = require('../utils/file-differ');
+const { readManifest, writeManifest, generateManifest, detectUserModifications } = require('../utils/manifest');
+const backuper = require('./backuper');
+const logger = require('../utils/logger');
+
+/**
+ * Resolve the template directory containing the canonical _byan/ files.
+ * Same logic as getTemplateDir() in create-byan-agent-v2.js.
+ *
+ * @returns {string|null} Absolute path to templates/ or null
+ */
+function getTemplateDir() {
+  const npmPackagePath = path.join(__dirname, '..', '..', 'templates');
+  if (fs.existsSync(npmPackagePath)) return npmPackagePath;
+
+  const devPath = path.join(__dirname, '..', '..', '..');
+  if (fs.existsSync(devPath)) return devPath;
+
+  return null;
+}
+
+/**
+ * @typedef {Object} UpdateCheck
+ * @property {boolean} updateAvailable
+ * @property {string} installed - Currently installed version
+ * @property {string} latest - Latest version on npm
+ * @property {string[]} changes - List of files that would change
+ */
+
+/**
+ * Check whether an update is available.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<UpdateCheck>}
+ */
+async function checkForUpdate(projectRoot) {
+  const installedVersion = await getInstalledVersion(projectRoot);
+  const latest = await getLatestVersion('create-byan-agent');
+  const cmp = compareVersions(installedVersion, latest);
+
+  let changes = [];
+  if (cmp < 0) {
+    const templateDir = getTemplateDir();
+    if (templateDir) {
+      const templateByan = path.join(templateDir, '_byan');
+      const installedByan = path.join(projectRoot, '_byan');
+      if (await fs.pathExists(templateByan) && await fs.pathExists(installedByan)) {
+        const diff = await diffFiles(installedByan, templateByan);
+        changes = [...diff.toUpdate, ...diff.toAdd];
+      }
+    }
+  }
+
+  return {
+    updateAvailable: cmp < 0,
+    installed: installedVersion,
+    latest,
+    changes
+  };
+}
+
+/**
+ * Preview what an update would do without applying changes.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<{diff: import('../utils/file-differ').DiffResult, userModified: string[], installed: string, latest: string}>}
+ */
+async function preview(projectRoot) {
+  const installedVersion = await getInstalledVersion(projectRoot);
+  const latest = await getLatestVersion('create-byan-agent');
+
+  const templateDir = getTemplateDir();
+  if (!templateDir) {
+    throw new Error('Template directory not found. Is the package installed correctly?');
+  }
+
+  const templateByan = path.join(templateDir, '_byan');
+  const installedByan = path.join(projectRoot, '_byan');
+
+  if (!await fs.pathExists(installedByan)) {
+    throw new Error('No _byan/ directory found. Run install first.');
+  }
+
+  const diff = await diffFiles(installedByan, templateByan);
+  const userModified = await detectUserModifications(projectRoot);
+
+  return { diff, userModified, installed: installedVersion, latest };
+}
+
+/**
+ * @typedef {Object} UpdateOptions
+ * @property {boolean} [force=false] - Force update even if same version
+ * @property {boolean} [preview=false] - Only show diff, don't apply
+ */
+
+/**
+ * @typedef {Object} UpdateResult
+ * @property {boolean} success
+ * @property {string} previousVersion
+ * @property {string} newVersion
+ * @property {string} backupPath
+ * @property {number} filesUpdated
+ * @property {number} filesAdded
+ * @property {number} filesSkipped - User-modified files left untouched
+ */
+
+/**
+ * Execute the full update flow.
+ *
+ * @param {string} projectRoot - Project root directory
+ * @param {UpdateOptions} [options={}]
+ * @returns {Promise<UpdateResult>}
+ */
+async function update(projectRoot, options = {}) {
+  const installedVersion = await getInstalledVersion(projectRoot);
+  const latest = await getLatestVersion('create-byan-agent');
+  const cmp = compareVersions(installedVersion, latest);
+
+  if (cmp >= 0 && !options.force) {
+    logger.info(`Already up to date (${installedVersion})`);
+    return {
+      success: true,
+      previousVersion: installedVersion,
+      newVersion: installedVersion,
+      backupPath: null,
+      filesUpdated: 0,
+      filesAdded: 0,
+      filesSkipped: 0
+    };
+  }
+
+  const templateDir = getTemplateDir();
+  if (!templateDir) {
+    throw new Error('Template directory not found. Is the package installed correctly?');
+  }
+
+  const templateByan = path.join(templateDir, '_byan');
+  const installedByan = path.join(projectRoot, '_byan');
+
+  if (!await fs.pathExists(templateByan)) {
+    throw new Error('Template _byan/ directory not found.');
+  }
+  if (!await fs.pathExists(installedByan)) {
+    throw new Error('No _byan/ directory found. Run install first.');
+  }
+
+  const diff = await diffFiles(installedByan, templateByan);
+  const userModified = new Set(await detectUserModifications(projectRoot));
+
+  if (options.preview) {
+    return formatPreviewResult(diff, userModified, installedVersion, latest);
+  }
+
+  // Backup before applying changes
+  const backupResult = await backuper.backup(installedByan);
+  logger.debug(`Backup created: ${backupResult.backupPath} (${backupResult.filesBackedUp} files)`);
+
+  let filesUpdated = 0;
+  let filesAdded = 0;
+  let filesSkipped = 0;
+
+  try {
+    // Apply updated files (skip user-modified unless forced)
+    for (const file of diff.toUpdate) {
+      if (userModified.has(file) && !options.force) {
+        filesSkipped++;
+        logger.debug(`Skipped (user-modified): ${file}`);
+        continue;
+      }
+      const src = path.join(templateByan, file);
+      const dest = path.join(installedByan, file);
+      await fs.ensureDir(path.dirname(dest));
+      await fs.copy(src, dest);
+      filesUpdated++;
+    }
+
+    // Add new files
+    for (const file of diff.toAdd) {
+      const src = path.join(templateByan, file);
+      const dest = path.join(installedByan, file);
+      await fs.ensureDir(path.dirname(dest));
+      await fs.copy(src, dest);
+      filesAdded++;
+    }
+
+    // Regenerate manifest with new state
+    const newManifest = await generateManifest(installedByan, latest);
+    await writeManifest(projectRoot, newManifest);
+
+    // Prune old backups
+    await backuper.pruneBackups(projectRoot);
+
+  } catch (error) {
+    // Rollback on failure
+    logger.error(`Update failed, restoring backup: ${error.message}`);
+    await backuper.restore(backupResult.backupPath, installedByan);
+    throw error;
+  }
+
+  return {
+    success: true,
+    previousVersion: installedVersion,
+    newVersion: latest,
+    backupPath: backupResult.backupPath,
+    filesUpdated,
+    filesAdded,
+    filesSkipped
+  };
+}
+
+/**
+ * Read the installed BYAN version from the manifest or package.json fallback.
+ *
+ * @param {string} projectRoot - Project root
+ * @returns {Promise<string>}
+ */
+async function getInstalledVersion(projectRoot) {
+  const manifest = await readManifest(projectRoot);
+  if (manifest && manifest.version) return manifest.version;
+
+  // Fallback: read from the package that shipped this code
+  const pkgPath = path.join(__dirname, '..', '..', 'package.json');
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJSON(pkgPath);
+    return pkg.version;
+  }
+
+  return '0.0.0';
+}
+
+/**
+ * Format a preview-only result for display.
+ *
+ * @param {import('../utils/file-differ').DiffResult} diff
+ * @param {Set<string>} userModified
+ * @param {string} installedVersion
+ * @param {string} latest
+ * @returns {UpdateResult}
+ */
+function formatPreviewResult(diff, userModified, installedVersion, latest) {
+  const skippable = diff.toUpdate.filter(f => userModified.has(f));
+  return {
+    success: true,
+    previousVersion: installedVersion,
+    newVersion: latest,
+    backupPath: null,
+    filesUpdated: diff.toUpdate.length - skippable.length,
+    filesAdded: diff.toAdd.length,
+    filesSkipped: skippable.length
+  };
+}
+
+module.exports = {
+  checkForUpdate,
+  preview,
+  update,
+  getInstalledVersion,
+  getTemplateDir
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.7.8",
+  "version": "2.8.0",
   "description": "BYAN v2.2.2 - Intelligent AI agent installer with multi-platform native support (GitHub Copilot CLI, Claude Code, Codex/OpenCode)",
   "bin": {
     "create-byan-agent": "bin/create-byan-agent-v2.js"
@@ -44,7 +44,8 @@
     "fs-extra": "^11.2.0",
     "inquirer": "^8.2.5",
     "js-yaml": "^4.1.0",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "ws": "^8.20.0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -55,6 +56,8 @@
     "src/",
     "templates/",
     "setup-turbo-whisper.js",
+    "setup-parakeet.js",
+    "docker-compose.parakeet.yml",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"