bi-superpowers 1.0.0

package/bin/commands/session-update.js

@@ -0,0 +1,204 @@
+/**
+ * Session auto-update hook (gstack-style)
+ * =======================================
+ *
+ * Target of the optional Claude Code `SessionStart` hook registered by
+ * `super autoupdate on`. On each session start it does a THROTTLED,
+ * non-blocking, silent self-update so the user never has to upgrade by hand.
+ *
+ * Two modes:
+ *   - default (hook mode): cheap. Reads a throttle stamp; if an hour hasn't
+ *     passed it exits 0 immediately. If due, it stamps "now", spawns a
+ *     DETACHED `--apply` child, and returns instantly so it never blocks or
+ *     times out session startup. Prints NOTHING to stdout (Claude Code
+ *     injects SessionStart stdout into context — we must stay silent).
+ *   - `--apply`: the background worker. Runs `npm install -g <pkg>@latest`
+ *     then `super install --all --yes` to refresh the agent skill/MCP
+ *     copies, records a "just upgraded" marker, and exits. Best-effort: any
+ *     failure is swallowed and the process still exits 0.
+ *
+ * State lives in ~/.bi-superpowers/autoupdate-state.json. The actual upgrade
+ * is npm-based, so it works even when the GitHub repo is private.
+ *
+ * @module commands/session-update
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const PACKAGE_NAME = (() => {
+  try {
+    return require('../../package.json').name;
+  } catch (_) {
+    return 'bi-superpowers';
+  }
+})();
+
+const DEFAULT_THROTTLE_SECONDS = 3600; // once per hour
+const STATE_DIR = '.bi-superpowers';
+const STATE_FILE = 'autoupdate-state.json';
+
+/**
+ * Absolute path to the auto-update state file under the given home dir.
+ */
+function stateFilePath(homeDir) {
+  return path.join(homeDir, STATE_DIR, STATE_FILE);
+}
+
+/**
+ * Read the auto-update state, or {} if missing/unreadable.
+ */
+function readState(file) {
+  try {
+    if (!fs.existsSync(file)) return {};
+    return JSON.parse(fs.readFileSync(file, 'utf8')) || {};
+  } catch (_) {
+    return {};
+  }
+}
+
+/**
+ * Persist state (best-effort). Creates the parent dir as needed.
+ */
+function writeState(file, state) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Decide whether an update check is due given the last-check timestamp.
+ * @param {object} state
+ * @param {number} nowMs - current time in ms
+ * @param {number} throttleSeconds
+ * @returns {boolean}
+ */
+function isDue(state, nowMs, throttleSeconds) {
+  // No prior check recorded → always due (don't gate the very first run on a
+  // tiny absolute clock value).
+  if (!state || typeof state.lastCheck !== 'number') return true;
+  return nowMs - state.lastCheck >= throttleSeconds * 1000;
+}
+
+/**
+ * Hook-mode logic: if due, stamp the check time and trigger the detached
+ * apply worker. Never throws.
+ *
+ * @param {object} deps
+ * @param {string} deps.file - state file path
+ * @param {number} deps.nowMs
+ * @param {number} deps.throttleSeconds
+ * @param {() => void} deps.spawnApply - launches the background upgrade
+ * @returns {{ ran: boolean }}
+ */
+function runHook({ file, nowMs, throttleSeconds, spawnApply }) {
+  const state = readState(file);
+  if (!isDue(state, nowMs, throttleSeconds)) {
+    return { ran: false };
+  }
+  // Stamp first so concurrent / next sessions don't double-trigger.
+  state.lastCheck = nowMs;
+  writeState(file, state);
+  try {
+    spawnApply();
+  } catch (_) {
+    /* best-effort: never block session start */
+  }
+  return { ran: true };
+}
+
+/**
+ * Spawn the detached background worker (`node session-update.js --apply`).
+ * Detached + unref so it outlives the hook and never blocks startup.
+ */
+function defaultSpawnApply() {
+  const child = spawn(process.execPath, [__filename, '--apply'], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+  child.unref();
+}
+
+/**
+ * Background worker: upgrade the global CLI, refresh agent skills/MCPs, and
+ * record the result. Best-effort; swallows all errors.
+ *
+ * @param {object} [deps]
+ * @param {string} [deps.file] - state file path
+ * @param {number} [deps.nowMs]
+ * @param {(cmd: string) => void} [deps.execFn] - command runner (injectable for tests)
+ * @param {string} [deps.cliPath] - path to cli.js (for the install refresh)
+ */
+function applyUpdate(deps = {}) {
+  const file = deps.file || stateFilePath(os.homedir());
+  const nowMs = typeof deps.nowMs === 'number' ? deps.nowMs : Date.now();
+  const cliPath = deps.cliPath || path.join(__dirname, '..', 'cli.js');
+  const execFn = deps.execFn || ((cmd) => execSync(cmd, { stdio: 'ignore', windowsHide: true }));
+
+  const state = readState(file);
+  try {
+    execFn(`npm install -g ${PACKAGE_NAME}@latest`);
+    // Refresh the per-agent skill + MCP copies from the freshly installed package.
+    execFn(`node "${cliPath}" install --all --yes`);
+    state.lastUpgrade = nowMs;
+    state.lastResult = 'ok';
+  } catch (err) {
+    state.lastResult = 'error';
+    state.lastError = err && err.message ? String(err.message).slice(0, 300) : 'unknown';
+  }
+  writeState(file, state);
+}
+
+/**
+ * Entry point. Silent on stdout in hook mode (no context pollution).
+ */
+function main(argv) {
+  const args = argv || process.argv.slice(2);
+  const home = os.homedir();
+  const file = stateFilePath(home);
+
+  if (args.includes('--apply')) {
+    applyUpdate({ file });
+    return;
+  }
+
+  const throttleIdx = args.indexOf('--throttle-seconds');
+  const throttleSeconds =
+    throttleIdx !== -1 && args[throttleIdx + 1]
+      ? Number(args[throttleIdx + 1]) || DEFAULT_THROTTLE_SECONDS
+      : DEFAULT_THROTTLE_SECONDS;
+
+  runHook({
+    file,
+    nowMs: Date.now(),
+    throttleSeconds,
+    spawnApply: defaultSpawnApply,
+  });
+  // Intentionally print nothing: SessionStart stdout is injected into context.
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (_) {
+    /* never fail a session start */
+  }
+  process.exit(0);
+}
+
+module.exports = main;
+module.exports.PACKAGE_NAME = PACKAGE_NAME;
+module.exports.DEFAULT_THROTTLE_SECONDS = DEFAULT_THROTTLE_SECONDS;
+module.exports.stateFilePath = stateFilePath;
+module.exports.readState = readState;
+module.exports.writeState = writeState;
+module.exports.isDue = isDue;
+module.exports.runHook = runHook;
+module.exports.applyUpdate = applyUpdate;

package/bin/commands/smoke-test.js

@@ -0,0 +1,20 @@
+/**
+ * Smoke Test Command
+ * ==================
+ *
+ * Convenience alias for the live base-template smoke test.
+ *
+ * Usage:
+ *   super smoke-test
+ *   super smoke-test --json
+ *   super smoke-test --root C:\path\to\bi-superpowers
+ */
+
+const validateCases = require('./validate-cases');
+
+function smokeTestCommand(args, config) {
+  const forwardedArgs = Array.isArray(args) ? args : [];
+  return validateCases([...forwardedArgs, '--case', 'base-template-smoke-test', '--live'], config);
+}
+
+module.exports = smokeTestCommand;