create-byan-agent 2.19.1 → 2.19.2

package/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.19.2] - 2026-06-02
+
+### Fixed - `update-byan-agent update` is non-destructive, non-interactive, and local
+
+Field testing of the 2.19.1 updater surfaced four real bugs in
+`update-byan-agent/bin/update-byan-agent.js` (the published template `_byan` was
+verified healthy and is untouched):
+
+- **No more redundant network install.** The updater runs via
+  `npx -p create-byan-agent@latest`, so the `@latest` package (and its template)
+  is already on disk next to the running bin. It now resolves the template from
+  the running package root (`path.resolve(__dirname, '..', '..')`, with a
+  `node_modules/create-byan-agent` fallback) instead of re-running
+  `npm install --no-save create-byan-agent@latest` into the user project (which
+  pulled ~215 packages, took minutes, had no timeout, and emitted no output).
+  The `.github/agents`, Claude-native, and fs-migration refreshes now resolve
+  from that same local root, so the F22 Gen3 stub refresh is no longer silently
+  skipped when the user project has no local `node_modules`.
+- **Non-destructive rebuild.** The replacement template is validated as a
+  non-empty directory and fully staged beside the live tree before anything is
+  deleted; the swap is then two atomic renames. A failed or empty source aborts
+  the update with the existing `_byan` left intact (previously `_byan` was
+  `rm -rf`'d up front, so a failing install left the project relying on backup
+  rollback).
+- **Non-interactive support.** `update` accepts `-y/--yes` and
+  `--non-interactive`, and auto-confirms when `--force`, `--yes`,
+  `--non-interactive`, or a non-TTY stdout is detected. In CI / headless / piped
+  runs the updater no longer hangs on the `Y/n` prompt.
+- **Honest diagnostics.** A template that cannot be used now reports whether the
+  package could not be resolved at all vs. the template directory being present
+  but empty, and prints the probed paths — instead of the misleading
+  "_byan directory not found in npm package" that blamed a healthy package.
+
+Covered by `update-byan-agent/__tests__/apply-update.test.js` (11 tests:
+local resolution, full Gen2->Gen3 replace, stub refresh, swap atomicity, and the
+destructive-safety guard). The updater bin now reports its real package version
+instead of a stale hard-coded literal.
+
+---
+
 ## [2.19.1] - 2026-06-02
 
 ### Fixed - Agent stubs repointed to the by-type (Gen3) layout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.19.1",
+  "version": "2.19.2",
   "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": {

package/update-byan-agent/bin/update-byan-agent.js

@@ -6,16 +6,22 @@ const ora = require('ora');
 const inquirer = require('inquirer');
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
 
 const Analyzer = require('../lib/analyzer');
 const Backup = require('../lib/backup');
 const CustomizationDetector = require('../lib/customization-detector');
+const { applyUpdate, resolvePackageRoot } = require('../lib/apply-update');
+
+// Read the version from this package, not a hand-maintained literal that drifts.
+let UPDATER_VERSION = '0.0.0';
+try {
+  UPDATER_VERSION = require('../package.json').version;
+} catch { /* keep fallback */ }
 
 program
   .name('update-byan-agent')
   .description('Gestion des mises a jour BYAN avec detection de conflits')
-  .version('2.6.1');
+  .version(UPDATER_VERSION);
 
 program
   .command('check')
@@ -58,37 +64,45 @@ program
   .description('Mettre a jour installation BYAN')
   .option('--dry-run', 'Analyser sans appliquer les changements')
   .option('--force', 'Forcer la mise a jour meme si deja a jour')
+  .option('-y, --yes', 'Mode non-interactif : confirmer automatiquement')
+  .option('--non-interactive', 'Alias de --yes (utile en CI / headless)')
   .action(async (options) => {
     const installPath = process.cwd();
-    
+
     try {
       // Step 1: Check version
       const spinner = ora('Verification version...').start();
       const analyzer = new Analyzer(installPath);
       const versionInfo = await analyzer.checkVersion();
       spinner.succeed(`Version actuelle: ${versionInfo.current}, npm: ${versionInfo.latest}`);
-      
+
       if (versionInfo.upToDate && !options.force) {
         console.log(chalk.green('\nBYAN est deja a jour!'));
         return;
       }
-      
+
       if (options.dryRun) {
         console.log(chalk.cyan('\nMode dry-run: Aucune modification appliquee'));
         return;
       }
-      
-      // Step 2: Confirm update
-      const { confirmUpdate } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirmUpdate',
-        message: `Mettre a jour BYAN ${versionInfo.current} -> ${versionInfo.latest}?`,
-        default: true
-      }]);
-      
-      if (!confirmUpdate) {
-        console.log(chalk.yellow('Mise a jour annulee'));
-        return;
+
+      // Step 2: Confirm update. Skip the prompt when explicitly non-interactive
+      // (--yes / --non-interactive / --force) or when stdout is not a TTY (CI,
+      // pipe, headless) — otherwise the updater hangs on the Y/n in automation.
+      const autoConfirm =
+        options.yes || options.nonInteractive || options.force ||
+        !process.stdout.isTTY || !process.stdin.isTTY;
+      if (!autoConfirm) {
+        const { confirmUpdate } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirmUpdate',
+          message: `Mettre a jour BYAN ${versionInfo.current} -> ${versionInfo.latest}?`,
+          default: true
+        }]);
+        if (!confirmUpdate) {
+          console.log(chalk.yellow('Mise a jour annulee'));
+          return;
+        }
       }
       
       // Step 3: Detect customizations
@@ -130,66 +144,47 @@ program
       }
       preserveSpinner.succeed('Personnalisations sauvegardees');
       
-      // Step 6: Download and install latest version
-      const updateSpinner = ora('Telechargement derniere version...').start();
+      // Step 6: Rebuild from the running package template (no network install).
+      // The updater is launched via `npx -p create-byan-agent@latest`, so the
+      // @latest package (and its template) is already on disk next to this bin.
+      // We resolve it locally instead of re-installing it into the user project
+      // (BUG3), validate the template BEFORE deleting anything, and swap via
+      // rename so a failure never leaves _byan missing (BUG2).
+      const updateSpinner = ora('Reconstruction depuis le template du package...').start();
+      let pkgRoot;
       try {
-        // Remove current _byan directory
-        const byanDir = path.join(installPath, '_byan');
-        if (fs.existsSync(byanDir)) {
-          fs.rmSync(byanDir, { recursive: true, force: true });
-        }
-        
-        // Run npm install to get latest create-byan-agent
-        execSync('npm install --no-save create-byan-agent@latest', {
-          cwd: installPath,
-          stdio: 'pipe'
-        });
-        
-        // Copy _byan from node_modules to project root. The published tarball
-        // ships _byan source under install/templates/_byan/, not at the root.
-        // Fall back to root-level _byan/ for legacy tarballs that may still
-        // have shipped it there.
-        const pkgRoot = path.join(installPath, 'node_modules', 'create-byan-agent');
-        const candidates = [
-          path.join(pkgRoot, 'install', 'templates', '_byan'),
-          path.join(pkgRoot, '_byan'),
-        ];
-        const nodeModulesByan = candidates.find((p) => fs.existsSync(p));
-        if (nodeModulesByan) {
-          copyRecursive(nodeModulesByan, byanDir);
-        } else {
-          throw new Error(
-            `_byan directory not found in npm package (looked in: ${candidates.map((p) => path.relative(pkgRoot, p)).join(', ')})`
-          );
-        }
+        const resolved = resolvePackageRoot({ installPath, binDir: __dirname });
+        pkgRoot = resolved.pkgRoot;
 
-        // Also refresh .github/agents/ from templates (Copilot stubs)
-        const ghAgentsSrc = path.join(pkgRoot, 'install', 'templates', '.github', 'agents');
-        const ghAgentsDst = path.join(installPath, '.github', 'agents');
-        if (fs.existsSync(ghAgentsSrc)) {
-          if (fs.existsSync(ghAgentsDst)) {
-            fs.rmSync(ghAgentsDst, { recursive: true, force: true });
-          }
-          fs.mkdirSync(path.dirname(ghAgentsDst), { recursive: true });
-          copyRecursive(ghAgentsSrc, ghAgentsDst);
-        }
+        const report = applyUpdate({ installPath, pkgRoot });
+        updateSpinner.succeed(
+          `Template applique (${report.byanEntries} entrees _byan` +
+          (report.githubAgentsEntries != null
+            ? `, ${report.githubAgentsEntries} stubs .github/agents` : '') +
+          `) depuis ${resolved.source}`
+        );
 
         // Refresh Claude Code native (.claude/hooks, .claude/skills,
-        // .claude/agents, .claude/settings.json, .mcp.json, _byan/mcp/)
+        // .claude/agents, .claude/settings.json, .mcp.json, _byan/mcp/) from the
+        // SAME local package root.
+        const nativeSpinner = ora('Refresh Claude Code native...').start();
         try {
           const setupModule = path.join(pkgRoot, 'install', 'lib', 'claude-native-setup.js');
           if (fs.existsSync(setupModule)) {
             // eslint-disable-next-line import/no-dynamic-require, global-require
             const { setupClaudeNative } = require(setupModule);
-            await setupClaudeNative(installPath, { installDeps: true, quiet: false });
+            await setupClaudeNative(installPath, { installDeps: true, quiet: true });
+            nativeSpinner.succeed('Claude Code native rafraichi');
+          } else {
+            nativeSpinner.info('Module claude-native-setup absent, refresh ignore');
           }
         } catch (e) {
-          console.warn(chalk.yellow(`  ⚠ Claude native refresh skipped: ${e.message}`));
+          nativeSpinner.warn(`Claude native refresh ignore: ${e.message}`);
         }
 
         // FS migration (F11) — dormant by default. Acts only when explicitly
         // enabled (env BYAN_FS_MIGRATE=1 or _byan/_config/migrate-fs.enabled)
-        // AND the legacy module layout is present. Backs up _byan/ first.
+        // AND the legacy module layout is present. Same local package root.
         try {
           const hookModule = path.join(pkgRoot, 'install', 'lib', 'fs-migration-hook.js');
           if (fs.existsSync(hookModule)) {
@@ -197,22 +192,22 @@ program
             const { runFsMigration } = require(hookModule);
             const r = runFsMigration({ projectRoot: installPath });
             if (r.ran) {
-              console.log(chalk.green(`  ✓ FS migration applied (backup: ${r.backup})`));
+              console.log(chalk.green(`  FS migration applied (backup: ${r.backup})`));
             }
           }
         } catch (e) {
-          console.warn(chalk.yellow(`  ⚠ FS migration skipped: ${e.message}`));
+          console.warn(chalk.yellow(`  FS migration skipped: ${e.message}`));
         }
-
-        updateSpinner.succeed('Derniere version installee');
       } catch (error) {
-        updateSpinner.fail('Erreur installation');
-        
-        // Rollback
+        updateSpinner.fail('Erreur reconstruction');
+
+        // Rollback. With the atomic-swap rebuild, _byan is only ever replaced
+        // after a validated stage, so most failures happen before destruction;
+        // the backup restore is the belt-and-suspenders net.
         const rollbackSpinner = ora('Restauration backup...').start();
         await backup.restore(backupPath);
         rollbackSpinner.succeed('Backup restaure');
-        
+
         throw error;
       }
       
@@ -253,9 +248,9 @@ program
         const { runMigration } = require('../lib/migrate-mcp-config');
         const result = await runMigration(process.cwd(), { verbose: false });
         if (result.migrated) {
-          console.log(chalk.green(`  ✓ .mcp.json migrated (${result.changes.length} change${result.changes.length > 1 ? 's' : ''})`));
+          console.log(chalk.green(`  .mcp.json migrated (${result.changes.length} change${result.changes.length > 1 ? 's' : ''})`));
         } else if (result.reason === 'no-token-available') {
-          console.log(chalk.yellow(`  ⚠ ${result.hint}`));
+          console.log(chalk.yellow(`  ${result.hint}`));
         }
         // silent on already-ok / no-mcp-json / no-byan-server
       } catch (err) {

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

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * Core of `update-byan-agent update`: rebuild the installed _byan tree and the
+ * Copilot stubs from the create-byan-agent template, without a network install
+ * and without ever leaving _byan deleted on failure.
+ *
+ * Design constraints (field-reported bugs this module fixes):
+ *  - BUG3 : the updater already runs from the @latest package (npx -p ...), so
+ *    the template lives next to the running bin. Resolve it locally instead of
+ *    re-running `npm install create-byan-agent@latest` into the user project.
+ *  - BUG2 : validate the replacement source on disk BEFORE touching the live
+ *    _byan, then swap via rename (stage -> rename), so a failure never leaves
+ *    the project without a _byan.
+ *  - BUG1 : a usable-template failure reports whether the package could not be
+ *    resolved at all vs. the template dir being present but empty, with the
+ *    probed paths, instead of a flat "not found in npm package".
+ *
+ * Pure module: no commander, no inquirer, no spinners, no network. The bin
+ * wires UI/version/backup/customization-preservation around it.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/** True when p is a directory that contains at least one entry. */
+function isNonEmptyDir(p) {
+  try {
+    if (!fs.statSync(p).isDirectory()) return false;
+    return fs.readdirSync(p).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** Recursively copy a directory tree (files + dirs), creating dest as needed. */
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+    // symlinks / specials are intentionally skipped (template ships none)
+  }
+}
+
+function rmrf(p) {
+  fs.rmSync(p, { recursive: true, force: true });
+}
+
+/**
+ * Resolve the create-byan-agent package root that holds install/templates.
+ * Preference order:
+ *  1. the running package itself (the bin lives at <pkg>/update-byan-agent/bin)
+ *  2. node_modules/create-byan-agent under the install path (legacy fallback)
+ *
+ * @param {object} opts
+ * @param {string} opts.installPath  project root being updated
+ * @param {string} opts.binDir       __dirname of the running bin
+ * @returns {{ pkgRoot: string, source: 'running-package'|'node_modules' }}
+ * @throws {Error} BUG1 diagnostic when no package root carries a template dir
+ */
+function resolvePackageRoot({ installPath, binDir }) {
+  const runningPkg = path.resolve(binDir, '..', '..');
+  const nodeModulesPkg = path.join(installPath, 'node_modules', 'create-byan-agent');
+  const candidates = [
+    { pkgRoot: runningPkg, source: 'running-package' },
+    { pkgRoot: nodeModulesPkg, source: 'node_modules' },
+  ];
+
+  const probed = [];
+  for (const c of candidates) {
+    const tplDir = path.join(c.pkgRoot, 'install', 'templates');
+    const byanTpl = path.join(tplDir, '_byan');
+    probed.push(byanTpl);
+    if (isNonEmptyDir(byanTpl)) return c;
+    // Distinguish "present but empty" (real package defect) from "absent".
+    if (fs.existsSync(byanTpl)) {
+      throw new Error(
+        `create-byan-agent template is present but EMPTY at ${byanTpl}. ` +
+        `The package is malformed for this version; do not delete _byan. ` +
+        `Reinstall the package or republish.`
+      );
+    }
+  }
+
+  throw new Error(
+    `Could not resolve the create-byan-agent package template. Probed:\n` +
+    probed.map((p) => `  - ${p}`).join('\n') +
+    `\nThis means the running package layout is unexpected (not a template ` +
+    `absence in a healthy package). Re-run via ` +
+    `'npx -p create-byan-agent@latest update-byan-agent update'.`
+  );
+}
+
+/**
+ * Replace a destination dir with a freshly staged copy of `src`, never leaving
+ * the destination missing for more than two atomic renames. The replacement
+ * source is fully staged (and validated non-empty) before the live dir is moved
+ * aside, so an interrupted/failed stage cannot destroy the existing content.
+ *
+ * @param {string} src   validated, non-empty source dir
+ * @param {string} dest  live dir to replace
+ * @param {string} label for error messages
+ * @returns {number} number of top-level entries staged
+ */
+function stageAndSwap(src, dest, label) {
+  if (!isNonEmptyDir(src)) {
+    throw new Error(`Refusing to replace ${label}: source ${src} is missing or empty.`);
+  }
+
+  const staging = `${dest}.staging`;
+  const prev = `${dest}.prev`;
+  // Clean any residue from a prior interrupted run. The replacement is always
+  // rebuilt from the validated `src`, so a stale `${dest}.prev` is debris, not
+  // data to recover (the bin's separate _byan.backup is the crash net).
+  rmrf(staging);
+  rmrf(prev);
+
+  // 1. Stage the new content beside the destination. If this throws, the live
+  //    dest is still untouched.
+  copyRecursive(src, staging);
+  if (!isNonEmptyDir(staging)) {
+    rmrf(staging);
+    throw new Error(`Staging ${label} produced no files (source ${src}).`);
+  }
+
+  // 2. Swap. Move the live dir aside (atomic), move staging into place
+  //    (atomic), then drop the old one. On a swap failure, restore and leave no
+  //    .staging debris behind.
+  const destExists = fs.existsSync(dest);
+  try {
+    if (destExists) fs.renameSync(dest, prev);
+    fs.renameSync(staging, dest);
+  } catch (err) {
+    if (destExists && !fs.existsSync(dest) && fs.existsSync(prev)) {
+      try { fs.renameSync(prev, dest); } catch { /* leave prev for manual recovery */ }
+    }
+    rmrf(staging);
+    throw err;
+  }
+
+  // The swap is committed. A failure to drop the old copy must NOT fail the
+  // update (e.g. transient EBUSY on a locked file); a stale .prev is cleaned by
+  // the next run's top-of-function rmrf.
+  try { rmrf(prev); } catch { /* best-effort */ }
+
+  return fs.readdirSync(dest).length;
+}
+
+/**
+ * Apply the file-system part of an update: rebuild _byan and refresh the
+ * Copilot stubs from the resolved package template.
+ *
+ * Caller is responsible for preserving/restoring user customizations around
+ * this call (config.yaml, memory, _byan-output, etc.).
+ *
+ * @param {object} opts
+ * @param {string} opts.installPath project root being updated
+ * @param {string} opts.pkgRoot     resolved create-byan-agent package root
+ * @returns {{ byanEntries: number, githubAgentsEntries: number|null, templateRoot: string }}
+ */
+function applyUpdate({ installPath, pkgRoot }) {
+  const templateRoot = path.join(pkgRoot, 'install', 'templates');
+  const byanSrc = path.join(templateRoot, '_byan');
+
+  // Validate BEFORE any destruction (BUG2). resolvePackageRoot already vetted
+  // this, but applyUpdate may be called directly, so re-check.
+  if (!isNonEmptyDir(byanSrc)) {
+    throw new Error(
+      `Template _byan is missing or empty at ${byanSrc}. ` +
+      `Aborting update without deleting the existing _byan.`
+    );
+  }
+
+  const byanDir = path.join(installPath, '_byan');
+  const byanEntries = stageAndSwap(byanSrc, byanDir, '_byan');
+
+  // Refresh Copilot stubs (.github/agents) from the template, same discipline.
+  // Optional: only when the template ships them.
+  let githubAgentsEntries = null;
+  const ghSrc = path.join(templateRoot, '.github', 'agents');
+  if (isNonEmptyDir(ghSrc)) {
+    const ghDst = path.join(installPath, '.github', 'agents');
+    fs.mkdirSync(path.dirname(ghDst), { recursive: true });
+    githubAgentsEntries = stageAndSwap(ghSrc, ghDst, '.github/agents');
+  }
+
+  return { byanEntries, githubAgentsEntries, templateRoot };
+}
+
+module.exports = {
+  applyUpdate,
+  resolvePackageRoot,
+  stageAndSwap,
+  isNonEmptyDir,
+  copyRecursive,
+};

package/update-byan-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "update-byan-agent",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CLI tool for managing BYAN updates with intelligent conflict detection and customization preservation",
   "bin": {
     "update-byan-agent": "bin/update-byan-agent.js"