baldart 3.6.2

package/src/commands/update.js

@@ -0,0 +1,419 @@
+const GitUtils = require('../utils/git');
+const SymlinkUtils = require('../utils/symlinks');
+const UI = require('../utils/ui');
+const State = require('../utils/state');
+const Hooks = require('../utils/hooks');
+
+// Path prefixes BALDART itself writes during install/update. Anything outside
+// these patterns is treated as user-owned and never auto-staged.
+const BALDART_MANAGED_PATTERNS = [
+  /^\.framework(\/|$)/,
+  /^AGENTS\.md$/,
+  /^agents(\.backup)?(\/|$)/,
+  /^\.claude\/(agents|commands|skills|hooks|routines|settings\.json)(\/|$)/,
+  /^\.baldart(\/|$)/,
+  /^baldart\.config\.yml$/,
+  /^docs\/references\/(ui-guidelines\.template\.md|brand-guidelines\.md)$/,
+  /^templates(\/|$)/,
+  /^\.github\/workflows\/baldart-/,
+  /^scripts\/routines(\/|$)/
+];
+
+function isBaldartManagedPath(p) {
+  return BALDART_MANAGED_PATTERNS.some((rx) => rx.test(p));
+}
+
+async function postUpdateAutoCommit(git, newVersion, options) {
+  if (options && options.commit === false) {
+    UI.info('Auto-commit skipped (--no-commit).');
+    return;
+  }
+  let status;
+  try {
+    status = await git.git.status();
+  } catch (err) {
+    UI.warning(`Could not read git status for auto-commit: ${err.message}`);
+    return;
+  }
+  // Collect every dirty path simple-git reports, classify against the allowlist.
+  const allDirty = [
+    ...status.not_added,
+    ...status.modified,
+    ...status.created,
+    ...status.deleted,
+    ...status.renamed.map((r) => r.to),
+    ...status.staged
+  ];
+  const seen = new Set();
+  const managed = [];
+  const userOwned = [];
+  for (const p of allDirty) {
+    if (!p || seen.has(p)) continue;
+    seen.add(p);
+    (isBaldartManagedPath(p) ? managed : userOwned).push(p);
+  }
+  if (managed.length === 0) {
+    return;
+  }
+  UI.newline();
+  UI.section('Auto-commit BALDART-managed changes');
+  UI.info(`${managed.length} BALDART-managed file(s) changed during this update:`);
+  const preview = managed.slice(0, 10);
+  UI.list(preview, 'cyan');
+  if (managed.length > preview.length) {
+    UI.info(`…and ${managed.length - preview.length} more.`);
+  }
+  if (userOwned.length > 0) {
+    UI.warning(`${userOwned.length} other dirty path(s) will be left untouched (not BALDART-managed).`);
+  }
+  const ok = await UI.confirm(`Commit them as \`chore(baldart): post-update reconcile to v${newVersion}\`?`, true);
+  if (!ok) {
+    UI.info('Auto-commit declined. Your worktree keeps the changes for manual review.');
+    return;
+  }
+  try {
+    await git.git.add(managed);
+    const subject = `chore(baldart): post-update reconcile to v${newVersion}`;
+    const body = [
+      'Automated by `npx baldart update`.',
+      '',
+      'Reconciles BALDART-managed files after framework upgrade:',
+      ...managed.map((p) => `  - ${p}`),
+      '',
+      'Revert this commit to undo the local reconcile without rolling back the framework subtree.'
+    ].join('\n');
+    await git.git.commit(`${subject}\n\n${body}`);
+    UI.success(`Committed ${managed.length} file(s).`);
+  } catch (err) {
+    UI.warning(`Auto-commit failed: ${err.message}`);
+    UI.info('Your changes are still in the worktree — commit manually when ready.');
+  }
+}
+
+async function update(options = {}) {
+  const git = new GitUtils();
+  const symlinks = new SymlinkUtils();
+  const repo = 'antbald/BALDART'; // Default repo
+
+  try {
+    // Step 1: Verify installation
+    UI.header('STEP 1/5: Verify Installation');
+
+    const exists = await git.frameworkExists();
+    if (!exists) {
+      UI.error('Framework not installed!');
+      UI.newline();
+      UI.box('ERROR', [
+        'Framework directory .framework/ not found.',
+        '',
+        'Solution:',
+        '  Install first: npx baldart add'
+      ]);
+      process.exit(1);
+    }
+
+    const currentVersion = await git.getFrameworkVersion();
+    UI.success(`Current version: ${currentVersion}`);
+
+    // Step 2: Check for updates
+    UI.header('STEP 2/5: Check for Updates');
+
+    const spinner = UI.spinner('Connecting to repository...').start();
+
+    try {
+      await git.fetch(repo);
+      spinner.succeed('Connected to repository');
+    } catch (error) {
+      spinner.fail();
+      UI.error('Cannot connect to repository!');
+      UI.newline();
+      UI.box('ERROR', [
+        'Possible causes:',
+        '  • No internet connection',
+        '  • Repository not accessible',
+        '',
+        'Solution:',
+        '  • Check internet connection',
+        '  • Try again later'
+      ]);
+      process.exit(1);
+    }
+
+    // Compare versions (simplified - in real scenario would fetch VERSION from remote)
+    UI.info('Checking for updates...');
+
+    const hasChanges = await git.hasChangesToPush();
+    if (!hasChanges) {
+      UI.success('Already up to date!');
+      process.exit(0);
+    }
+
+    UI.warning('Updates available!');
+
+    // Step 3: Show changes preview
+    UI.header('STEP 3/5: Preview Changes');
+
+    const diff = await git.diffWithRemote();
+    if (diff) {
+      UI.info('Changes detected. Review recommended.');
+      const showDiff = await UI.confirm('Show detailed diff?', false);
+
+      if (showDiff) {
+        console.log(diff);
+      }
+    }
+
+    const proceedUpdate = await UI.confirm('Proceed with update?', true);
+    if (!proceedUpdate) {
+      UI.info('Update cancelled');
+      process.exit(0);
+    }
+
+    // Pre-flight: git subtree pull --squash refuses a dirty worktree with
+    // "fatal: working tree has modifications. Cannot add." Offer to stash
+    // and re-apply after the update, so the user doesn't have to abort mid-flow.
+    let stashRef = null;
+    const isClean = await git.hasCleanWorkingTree();
+    if (!isClean) {
+      UI.newline();
+      UI.warning('Working tree has uncommitted changes. `git subtree pull` requires a clean tree.');
+      const dirty = await git.git.status();
+      const dirtyPaths = [
+        ...dirty.not_added, ...dirty.modified, ...dirty.created,
+        ...dirty.deleted, ...dirty.renamed.map((r) => r.to), ...dirty.staged
+      ];
+      const unique = [...new Set(dirtyPaths)];
+      UI.info(`${unique.length} dirty path(s):`);
+      UI.list(unique.slice(0, 8), 'yellow');
+      if (unique.length > 8) UI.info(`…and ${unique.length - 8} more.`);
+
+      const action = await UI.select('How would you like to proceed?', [
+        { name: 'Auto-stash now and re-apply after the update (recommended)', value: 'stash' },
+        { name: 'Abort — I want to commit or stash manually first', value: 'abort' }
+      ]);
+      if (action === 'abort') {
+        UI.info('Aborted. Commit or `git stash -u`, then re-run `npx baldart update`.');
+        process.exit(0);
+      }
+      stashRef = `baldart-pre-update-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+      try {
+        await git.git.stash(['push', '-u', '-m', stashRef]);
+        UI.success(`Stashed working tree as "${stashRef}".`);
+      } catch (err) {
+        UI.error(`Could not stash: ${err.message}`);
+        process.exit(1);
+      }
+    }
+
+    // Step 4: Create backup
+    UI.header('STEP 4/5: Create Backup');
+
+    const backupSpinner = UI.spinner('Creating backup tag...').start();
+    const backupTag = await git.createBackupTag();
+    backupSpinner.succeed(`Backup created: ${backupTag}`);
+
+    UI.newline();
+    UI.box('ROLLBACK INFO', [
+      'If something goes wrong, rollback with:',
+      `  git checkout ${backupTag}`,
+      '  git checkout -b recovery-branch'
+    ]);
+
+    // Step 5: Update framework
+    UI.header('STEP 5/5: Update Framework');
+
+    const updateSpinner = UI.spinner('Updating framework...').start();
+    let newVersion;
+
+    try {
+      await git.updateSubtree(repo);
+      updateSpinner.succeed('Framework updated');
+
+      newVersion = await git.getFrameworkVersion();
+      UI.success(`New version: ${newVersion}`);
+      try { State.recordUpdate({ from: currentVersion, to: newVersion }); } catch (_) { /* non-fatal */ }
+
+      // Re-apply the pre-update stash (if any). Conflicts mean we leave the
+      // stash intact and tell the user how to resolve — never silently drop.
+      if (stashRef) {
+        try {
+          await git.git.stash(['pop']);
+          UI.success(`Re-applied pre-update stash "${stashRef}".`);
+        } catch (err) {
+          UI.newline();
+          UI.warning(`Could not auto-re-apply stash "${stashRef}" — conflicts with the framework update.`);
+          UI.box('STASH CONFLICT', [
+            'Your pre-update changes are preserved in the stash.',
+            '',
+            'Inspect:   git stash list',
+            'Apply:     git stash pop      (resolve conflicts manually)',
+            'Discard:   git stash drop     (only if you no longer need them)'
+          ]);
+        }
+      }
+    } catch (error) {
+      updateSpinner.fail();
+      UI.error('Update failed!');
+
+      if (error.message.includes('conflict')) {
+        UI.newline();
+        UI.box('MERGE CONFLICT', [
+          'Git found conflicts during update.',
+          '',
+          'Resolution:',
+          '  1. Check conflicts: git status',
+          '  2. For each conflict file:',
+          '     • Keep yours: git checkout --ours <file>',
+          '     • Use new: git checkout --theirs <file>',
+          '     • Edit manually to resolve',
+          '  3. After resolving:',
+          '     git add <files>',
+          '     git commit -m "Resolved update conflicts"',
+          '  4. Retry: baldart update',
+          '',
+          'Or rollback:',
+          `  git checkout ${backupTag}`
+        ]);
+      }
+
+      // Subtree pull failed — restore the pre-update stash so the user's
+      // dirty changes don't appear lost. Conflicts here are unlikely (we
+      // never reached the modifying step), but we still report instead of
+      // silently dropping.
+      if (stashRef) {
+        try {
+          await git.git.stash(['pop']);
+          UI.info(`Restored pre-update stash "${stashRef}".`);
+        } catch (popErr) {
+          UI.warning(`Could not auto-restore stash "${stashRef}": ${popErr.message}`);
+          UI.info('Recover with: git stash list && git stash pop');
+        }
+      }
+
+      throw error;
+    }
+
+    // Verify symlinks
+    UI.newline();
+    UI.section('Verifying Symlinks');
+
+    const symlinkValid = symlinks.verifySymlinks();
+    if (!symlinkValid) {
+      UI.info('Some symlinks are missing or out of date. The framework will:');
+      UI.list([
+        'Refuse to overwrite any file/dir you customised (you\'ll be asked first).',
+        'Convert legacy .claude/skills/ bulk symlink (v2.0.x) into the new per-item layout.',
+        'Merge framework skills into .claude/skills/ without touching your personal skills.'
+      ]);
+      const recreate = await UI.confirm('Reconcile symlinks now?', true);
+      if (recreate) {
+        // Use 'prompt' mode so any customised file (non-symlink) gets a
+        // confirmation prompt before being moved to .backup.
+        await symlinks.createAllSymlinks({ mode: 'prompt' });
+      }
+    } else {
+      // Even when bulk symlinks are valid, re-run the per-item skill merge
+      // to pick up new framework skills shipped in this version.
+      symlinks.mergeSkills();
+    }
+
+    // Routines wizard (since v2.1.0) — surfaces routines added in the new framework version
+    try {
+      const routinesCmd = require('./routines');
+      await routinesCmd.postUpdateWizard();
+    } catch (err) {
+      UI.warning(`Routines wizard skipped: ${err.message}`);
+    }
+
+    // Framework-edit-gate hook (since v3.3.0) — backfill for consumers
+    // installed before v3.3.0 didn't have this hook. We register it on every
+    // update (idempotent — no-op if already present).
+    try {
+      const res = Hooks.register();
+      if (res.status === 'created' || res.status === 'updated') {
+        UI.success('Registered framework-edit-gate hook in .claude/settings.json (v3.3.0+ default).');
+      }
+    } catch (err) {
+      UI.warning(`Hook registration skipped: ${err.message}`);
+    }
+
+    // Project configuration check (since v3.0.0)
+    // Never overwrite baldart.config.yml on update. Offer to (re)run configure
+    // if the schema has gained required keys, or if no config exists at all.
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const configPath = path.join(process.cwd(), 'baldart.config.yml');
+      if (!fs.existsSync(configPath)) {
+        UI.newline();
+        UI.warning('No baldart.config.yml in this project — skills installed by this framework version require it.');
+        const runConfigure = await UI.confirm('Run `baldart configure` now?', true);
+        if (runConfigure) {
+          const configureCmd = require('./configure');
+          await configureCmd();
+        }
+      } else {
+        // Optional: detect schema drift by comparing template vs existing.
+        const yaml = require('js-yaml');
+        const templatePath = path.join('.framework', 'framework', 'templates', 'baldart.config.template.yml');
+        if (fs.existsSync(templatePath)) {
+          try {
+            const tpl = yaml.load(fs.readFileSync(templatePath, 'utf8')) || {};
+            const cur = yaml.load(fs.readFileSync(configPath, 'utf8')) || {};
+            const missingFeatures = Object.keys(tpl.features || {})
+              .filter((k) => !(k in (cur.features || {})));
+            const missingPaths = Object.keys(tpl.paths || {})
+              .filter((k) => !(k in (cur.paths || {})));
+            if (missingFeatures.length || missingPaths.length) {
+              UI.newline();
+              UI.warning(
+                `New config keys in this version: ${[...missingPaths, ...missingFeatures].join(', ')}. ` +
+                'Re-run `npx baldart configure` to populate them (existing values are preserved).'
+              );
+            }
+          } catch (_) {
+            // Non-fatal — schema drift detection is best-effort.
+          }
+        }
+      }
+    } catch (err) {
+      UI.warning(`Configuration check skipped: ${err.message}`);
+    }
+
+    // Post-update auto-commit (v3.5.0+) — keep the worktree clean and leave
+    // a single revertable commit for the reconcile step.
+    try {
+      await postUpdateAutoCommit(git, newVersion, options);
+    } catch (err) {
+      UI.warning(`Auto-commit step skipped: ${err.message}`);
+    }
+
+    // Success
+    UI.header('✓ UPDATE COMPLETE');
+
+    UI.box('WHAT CHANGED', [
+      `Version: ${currentVersion} → ${newVersion}`,
+      '',
+      'Review CHANGELOG:',
+      '  cat .framework/CHANGELOG.md',
+      '',
+      'Check template updates:',
+      '  diff .framework/.claude/hooks/*.template .claude/hooks/',
+      '',
+      'Review routines:',
+      '  npx baldart routines list',
+      '',
+      `Backup available: ${backupTag}`,
+      `Remove when confident: git tag -d ${backupTag}`
+    ]);
+
+    UI.newline();
+    UI.success('Framework updated successfully!');
+
+  } catch (error) {
+    UI.error(`Update failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = update;

package/src/commands/version.js

@@ -0,0 +1,88 @@
+const GitUtils = require('../utils/git');
+const UI = require('../utils/ui');
+const State = require('../utils/state');
+
+const REPO_DEFAULT = 'antbald/BALDART';
+const FRAMEWORK_DIR = '.framework';
+
+function fmtDate(iso) {
+  if (!iso) return '—';
+  try { return iso.slice(0, 10); } catch (_) { return iso; }
+}
+
+async function describeDrift(git) {
+  // Returns { ahead, behind, uncommittedFiles, hasFetchHead } or null on failure.
+  try {
+    let hasFetchHead = false;
+    try {
+      const out = await git.git.raw(['rev-list', '--left-right', '--count', 'HEAD...FETCH_HEAD']);
+      const [a, b] = out.trim().split('\t').map(Number);
+      hasFetchHead = !Number.isNaN(a) && !Number.isNaN(b);
+      var ahead = a, behind = b;
+    } catch (_) { /* no FETCH_HEAD — needs fetch first */ }
+
+    // Uncommitted local edits to .framework/
+    let uncommittedFiles = 0;
+    try {
+      const dirty = await git.git.raw(['diff', '--name-only', 'HEAD', '--', FRAMEWORK_DIR]);
+      uncommittedFiles = dirty.trim() ? dirty.trim().split('\n').length : 0;
+    } catch (_) { /* repo without HEAD yet */ }
+
+    return { ahead, behind, uncommittedFiles, hasFetchHead };
+  } catch (_) {
+    return null;
+  }
+}
+
+async function version(opts = {}) {
+  const git = new GitUtils();
+
+  try {
+    const exists = await git.frameworkExists();
+    if (!exists) {
+      UI.warning('Framework not installed');
+      UI.info('Install with: npx baldart add');
+      process.exit(0);
+    }
+
+    const frameworkVersion = await git.getFrameworkVersion();
+    const state = State.load();
+    const cliVersion = require('../../package.json').version;
+
+    // Optionally fetch upstream to compute drift (default: yes).
+    const offline = opts.offline === true;
+    if (!offline) {
+      try {
+        await git.fetch(state.framework_repo || REPO_DEFAULT);
+      } catch (_) { /* offline — drift report falls back */ }
+    }
+    const drift = await describeDrift(git);
+
+    UI.newline();
+    UI.box('BALDART VERSION', [
+      `Installed:   v${frameworkVersion}    ${state.install_date ? `(since ${fmtDate(state.install_date)})` : ''}`.trim(),
+      drift && drift.hasFetchHead
+        ? (drift.behind > 0
+            ? `Remote:      ${drift.behind} commit(s) ahead — pull with \`npx baldart update\``
+            : 'Remote:      up to date')
+        : 'Remote:      (offline / not fetched)',
+      drift
+        ? (drift.uncommittedFiles > 0
+            ? `Local:       v${frameworkVersion} + ${drift.uncommittedFiles} uncommitted file(s) in .framework/`
+            : `Local:       v${frameworkVersion} (clean)`)
+        : '',
+      '',
+      `Last update: ${fmtDate(state.last_update_date)}`,
+      `Last push:   v${state.last_pushed_version || '—'}    ${state.last_push_date ? `(${fmtDate(state.last_push_date)})` : ''}`.trim(),
+      '',
+      `CLI:         v${cliVersion}`,
+      `Repository:  https://github.com/${state.framework_repo || REPO_DEFAULT}`,
+    ].filter((l) => l !== ''));
+    UI.newline();
+  } catch (error) {
+    UI.error(`Failed to get version: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = version;