create-byan-agent 2.9.7 → 2.9.8

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.9.8] - 2026-04-21
+
+### Fixed - `update-byan-agent` CLI broken on fresh npm install
+
+- **`update-byan-agent/` added to `package.json` `files` array** — previously only `update-byan-agent/bin/` shipped (because it was listed in `bin`), but `update-byan-agent/lib/` (analyzer, backup, customization-detector) was missing. Running `update-byan-agent` crashed with `Cannot find module '../lib/analyzer'`.
+- **Observed on**: npm install 2.9.7, `cd ~/byan_web && update-byan-agent` → `MODULE_NOT_FOUND`.
+
+---
+
 ## [2.9.7] - 2026-04-21
 
 ### Fixed - MCP server empty-directory install bug

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.9.7",
+  "version": "2.9.8",
   "description": "BYAN v2.8 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher + native Claude Code integration (hooks, skills, MCP server). Multi-platform (Copilot CLI, Claude Code, Codex). Merise Agile + TDD + 64 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {
@@ -48,6 +48,7 @@
   "files": [
     "src/",
     "install/",
+    "update-byan-agent/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"

package/update-byan-agent/lib/analyzer.js

@@ -0,0 +1,136 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const yaml = require('js-yaml');
+
+/**
+ * Analyzer - Version checking and comparison module
+ * Validates current BYAN installation version vs npm registry
+ */
+class Analyzer {
+  constructor(installPath) {
+    this.installPath = installPath;
+    this.configPath = path.join(installPath, '_byan', 'bmb', 'config.yaml');
+  }
+
+  /**
+   * Check current version from _byan/bmb/config.yaml
+   * @returns {Promise<string|null>} Current version or null if not found
+   */
+  async checkCurrentVersion() {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        return null;
+      }
+
+      const configContent = fs.readFileSync(this.configPath, 'utf8');
+      const config = yaml.load(configContent);
+      
+      return config.byan_version || null;
+    } catch (error) {
+      throw new Error(`Erreur lecture config.yaml: ${error.message}`);
+    }
+  }
+
+  /**
+   * Fetch latest version from npm registry
+   * @returns {Promise<string>} Latest version available on npm
+   */
+  async fetchLatestVersion() {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: 'registry.npmjs.org',
+        path: '/create-byan-agent/latest',
+        method: 'GET',
+        headers: {
+          'Accept': 'application/json'
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.version);
+          } catch (error) {
+            reject(new Error(`Erreur parsing npm response: ${error.message}`));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`Erreur connexion npm registry: ${error.message}`));
+      });
+
+      req.end();
+    });
+  }
+
+  /**
+   * Compare two semver versions
+   * @param {string} current - Current version (e.g., "2.6.0")
+   * @param {string} latest - Latest version (e.g., "2.6.1")
+   * @returns {number} -1 if current < latest, 0 if equal, 1 if current > latest
+   */
+  compare(current, latest) {
+    const parseCurrent = this._parseSemver(current);
+    const parseLatest = this._parseSemver(latest);
+
+    if (parseCurrent.major !== parseLatest.major) {
+      return parseCurrent.major < parseLatest.major ? -1 : 1;
+    }
+    if (parseCurrent.minor !== parseLatest.minor) {
+      return parseCurrent.minor < parseLatest.minor ? -1 : 1;
+    }
+    if (parseCurrent.patch !== parseLatest.patch) {
+      return parseCurrent.patch < parseLatest.patch ? -1 : 1;
+    }
+    
+    return 0;
+  }
+
+  /**
+   * Parse semver string to object
+   * @param {string} version - Version string (e.g., "2.6.1")
+   * @returns {{major: number, minor: number, patch: number}}
+   */
+  _parseSemver(version) {
+    const parts = version.split('.').map(Number);
+    return {
+      major: parts[0] || 0,
+      minor: parts[1] || 0,
+      patch: parts[2] || 0
+    };
+  }
+
+  /**
+   * Check if update is available
+   * @returns {Promise<{current: string, latest: string, needsUpdate: boolean}>}
+   */
+  async checkVersion() {
+    const current = await this.checkCurrentVersion();
+    const latest = await this.fetchLatestVersion();
+
+    if (!current) {
+      throw new Error('Version actuelle introuvable dans config.yaml');
+    }
+
+    const comparison = this.compare(current, latest);
+    
+    return {
+      current,
+      latest,
+      needsUpdate: comparison < 0,
+      upToDate: comparison === 0,
+      ahead: comparison > 0
+    };
+  }
+}
+
+module.exports = Analyzer;

package/update-byan-agent/lib/backup.js

@@ -0,0 +1,204 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Backup - Safe backup and restore operations for BYAN updates
+ * Creates timestamped backups and manages rollback functionality
+ */
+class Backup {
+  constructor(installPath) {
+    this.installPath = installPath;
+    this.byanDir = path.join(installPath, '_byan');
+    this.backupBaseDir = path.join(installPath, '_byan.backup');
+  }
+
+  /**
+   * Create backup of _byan directory with timestamp
+   * @returns {Promise<string>} Path to created backup
+   */
+  async create() {
+    try {
+      if (!fs.existsSync(this.byanDir)) {
+        throw new Error('Directory _byan/ introuvable');
+      }
+
+      // Create backup directory with timestamp
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0] + 
+                       '_' + new Date().toTimeString().split(' ')[0].replace(/:/g, '-');
+      const backupPath = path.join(this.backupBaseDir, `backup-${timestamp}`);
+
+      // Create backup base directory if not exists
+      if (!fs.existsSync(this.backupBaseDir)) {
+        fs.mkdirSync(this.backupBaseDir, { recursive: true });
+      }
+
+      // Copy _byan to backup location
+      this._copyRecursive(this.byanDir, backupPath);
+
+      // Save backup metadata
+      const metadataPath = path.join(backupPath, '.backup-metadata.json');
+      const metadata = {
+        timestamp: new Date().toISOString(),
+        originalPath: this.byanDir,
+        backupPath: backupPath
+      };
+      fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+
+      return backupPath;
+    } catch (error) {
+      throw new Error(`Erreur creation backup: ${error.message}`);
+    }
+  }
+
+  /**
+   * Restore from backup directory
+   * @param {string} backupPath - Path to backup directory (optional, uses latest if not provided)
+   * @returns {Promise<boolean>} Success status
+   */
+  async restore(backupPath = null) {
+    try {
+      // If no backup path provided, find latest
+      if (!backupPath) {
+        backupPath = await this.getLatestBackup();
+      }
+
+      if (!fs.existsSync(backupPath)) {
+        throw new Error(`Backup introuvable: ${backupPath}`);
+      }
+
+      // Remove current _byan directory
+      if (fs.existsSync(this.byanDir)) {
+        this._removeRecursive(this.byanDir);
+      }
+
+      // Restore from backup
+      this._copyRecursive(backupPath, this.byanDir);
+
+      // Remove backup metadata file from restored directory
+      const metadataPath = path.join(this.byanDir, '.backup-metadata.json');
+      if (fs.existsSync(metadataPath)) {
+        fs.unlinkSync(metadataPath);
+      }
+
+      return true;
+    } catch (error) {
+      throw new Error(`Erreur restoration backup: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get latest backup path
+   * @returns {Promise<string|null>} Latest backup path or null
+   */
+  async getLatestBackup() {
+    if (!fs.existsSync(this.backupBaseDir)) {
+      return null;
+    }
+
+    const backups = fs.readdirSync(this.backupBaseDir)
+      .filter(name => name.startsWith('backup-'))
+      .map(name => path.join(this.backupBaseDir, name))
+      .filter(p => fs.statSync(p).isDirectory())
+      .sort((a, b) => {
+        const statA = fs.statSync(a);
+        const statB = fs.statSync(b);
+        return statB.mtime.getTime() - statA.mtime.getTime();
+      });
+
+    return backups.length > 0 ? backups[0] : null;
+  }
+
+  /**
+   * List all available backups
+   * @returns {Promise<Array>} List of backup info objects
+   */
+  async listBackups() {
+    if (!fs.existsSync(this.backupBaseDir)) {
+      return [];
+    }
+
+    const backups = fs.readdirSync(this.backupBaseDir)
+      .filter(name => name.startsWith('backup-'))
+      .map(name => {
+        const backupPath = path.join(this.backupBaseDir, name);
+        const metadataPath = path.join(backupPath, '.backup-metadata.json');
+        
+        let metadata = {};
+        if (fs.existsSync(metadataPath)) {
+          metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+        }
+
+        const stats = fs.statSync(backupPath);
+        
+        return {
+          name,
+          path: backupPath,
+          timestamp: metadata.timestamp || stats.mtime.toISOString(),
+          size: this._getDirectorySize(backupPath)
+        };
+      })
+      .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+    return backups;
+  }
+
+  /**
+   * Copy directory recursively
+   * @param {string} src - Source directory
+   * @param {string} dest - Destination directory
+   */
+  _copyRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this._copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Remove directory recursively
+   * @param {string} dirPath - Directory to remove
+   */
+  _removeRecursive(dirPath) {
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  }
+
+  /**
+   * Get directory size in bytes
+   * @param {string} dirPath - Directory path
+   * @returns {number} Size in bytes
+   */
+  _getDirectorySize(dirPath) {
+    let size = 0;
+
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      
+      if (entry.isDirectory()) {
+        size += this._getDirectorySize(entryPath);
+      } else {
+        size += fs.statSync(entryPath).size;
+      }
+    }
+
+    return size;
+  }
+}
+
+module.exports = Backup;

package/update-byan-agent/lib/conflict-resolver.js

@@ -0,0 +1,7 @@
+// Conflict-resolver Module - MVP placeholder
+class conflict-resolver {
+  constructor(installPath) {
+    this.installPath = installPath;
+  }
+}
+module.exports = conflict-resolver;

package/update-byan-agent/lib/customization-detector.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * CustomizationDetector - Detects user customizations in BYAN files
+ * Helps preserve user changes during updates
+ */
+class CustomizationDetector {
+  constructor(installPath) {
+    this.installPath = installPath;
+    this.byanDir = path.join(installPath, '_byan');
+  }
+
+  /**
+   * Detect customized files that should be preserved
+   * @returns {Promise<Array>} List of customized file paths
+   */
+  async detectCustomizations() {
+    const customizations = [];
+
+    // Preserve config.yaml
+    const configPath = path.join(this.byanDir, 'bmb', 'config.yaml');
+    if (fs.existsSync(configPath)) {
+      customizations.push({
+        path: configPath,
+        type: 'config',
+        preserve: true
+      });
+    }
+
+    // Preserve _memory directory
+    const memoryDir = path.join(this.byanDir, '_memory');
+    if (fs.existsSync(memoryDir)) {
+      customizations.push({
+        path: memoryDir,
+        type: 'memory',
+        preserve: true
+      });
+    }
+
+    // Preserve _byan-output directory
+    const outputDir = path.join(this.installPath, '_byan-output');
+    if (fs.existsSync(outputDir)) {
+      customizations.push({
+        path: outputDir,
+        type: 'output',
+        preserve: true
+      });
+    }
+
+    return customizations;
+  }
+
+  /**
+   * Check if a file has been modified by user
+   * @param {string} filePath - File to check
+   * @returns {Promise<boolean>} True if modified
+   */
+  async isModified(filePath) {
+    // Simple check based on modification time
+    // In a more advanced version, could compare with original checksums
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+
+    const stats = fs.statSync(filePath);
+    const now = Date.now();
+    const hoursSinceModification = (now - stats.mtime.getTime()) / (1000 * 60 * 60);
+
+    // If modified in last 24h, consider it customized
+    return hoursSinceModification < 24;
+  }
+}
+
+module.exports = CustomizationDetector;

package/update-byan-agent/lib/validator.js

@@ -0,0 +1,7 @@
+// Validator Module - MVP placeholder
+class validator {
+  constructor(installPath) {
+    this.installPath = installPath;
+  }
+}
+module.exports = validator;

package/update-byan-agent/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "update-byan-agent",
+  "version": "1.0.0",
+  "description": "CLI tool for managing BYAN updates with intelligent conflict detection and customization preservation",
+  "bin": {
+    "update-byan-agent": "bin/update-byan-agent.js"
+  },
+  "scripts": {
+    "start": "node bin/update-byan-agent.js",
+    "test": "jest",
+    "lint": "eslint bin/ lib/",
+    "prepublish": "npm test"
+  },
+  "keywords": [
+    "byan",
+    "update",
+    "version-management",
+    "conflict-resolution",
+    "backup",
+    "merge",
+    "ai-agent",
+    "bmad",
+    "merise",
+    "tdd"
+  ],
+  "author": "Yan",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "diff": "^5.1.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.5",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
+}