wolverine-ai 2.6.3 → 2.7.0

package/README.md

@@ -552,6 +552,15 @@ All backups stored in **`~/.wolverine-safe-backups/`** — outside the project d
 - **Retention**: unstable/verified pruned after 7 days, stable keeps 1/day after 7 days
 - Protected files never overwritten during rollback: `settings.json`, `db.js`, `.env.local`
 
+```bash
+# CLI commands
+wolverine --backup "before auth changes"  # create snapshot
+wolverine --list-backups                  # show all with status/age
+wolverine --rollback mngt8mwb-v0sm        # restore specific backup
+wolverine --rollback-latest               # restore most recent
+wolverine --undo-rollback                 # undo last rollback
+```
+
 **Rollback & Recovery:**
 
 | Action | What it does |

package/bin/wolverine.js

@@ -72,7 +72,45 @@ if (args.includes("--restore")) {
   process.exit(0);
 }
 
-// --backups: list safe backups
+// --backup: create server snapshot
+if (args.includes("--backup")) {
+  const reason = args[args.indexOf("--backup") + 1] || "manual";
+  const { backup } = require("../src/skills/backup");
+  backup(process.cwd(), reason);
+  process.exit(0);
+}
+
+// --list-backups: list all server snapshots
+if (args.includes("--list-backups")) {
+  const { listBackups } = require("../src/skills/backup");
+  listBackups(process.cwd());
+  process.exit(0);
+}
+
+// --rollback: rollback to specific backup
+if (args.includes("--rollback") && !args.includes("--rollback-latest") && !args.includes("--undo-rollback")) {
+  const id = args[args.indexOf("--rollback") + 1];
+  if (!id) { console.log("Usage: wolverine --rollback <backup-id>"); process.exit(1); }
+  const { rollback } = require("../src/skills/backup");
+  const result = rollback(process.cwd(), id);
+  process.exit(result.success ? 0 : 1);
+}
+
+// --rollback-latest: rollback to most recent backup
+if (args.includes("--rollback-latest")) {
+  const { rollbackLatest } = require("../src/skills/backup");
+  const result = rollbackLatest(process.cwd());
+  process.exit(result.success ? 0 : 1);
+}
+
+// --undo-rollback: undo last rollback
+if (args.includes("--undo-rollback")) {
+  const { undoRollback } = require("../src/skills/backup");
+  const result = undoRollback(process.cwd());
+  process.exit(result.success ? 0 : 1);
+}
+
+// --backups: list safe backups (update snapshots)
 if (args.includes("--backups")) {
   const { listSafeBackups } = require("../src/skills/update");
   const backups = listSafeBackups();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.6.3",
+  "version": "2.7.0",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {

package/src/agent/research-agent.js

@@ -55,7 +55,7 @@ class ResearchAgent {
 
     const namespace = success ? "fixes" : "errors";
     const prefix = success ? "FIXED" : "FAILED";
-    const text = `${prefix}: ${safeError} in ${filePath}. ${success ? "Solution" : "Attempted"}: ${safeExplanation}`;
+    const text = `${prefix}: ${safeError} in ${filePath}. ${success ? "Solution" : "Attempted (DO NOT REPEAT)"}: ${safeExplanation}`;
 
     await this.brain.remember(namespace, text, { type: success ? "fix-success" : "fix-failure", file: filePath });
     console.log(chalk.gray(`  🧠 ${success ? "✅" : "❌"} Recorded ${prefix.toLowerCase()} for ${safeError.slice(0, 50)}`));

package/src/brain/brain.js

@@ -237,6 +237,10 @@ const SEED_DOCS = [
     text: "Dependency manager skill (src/skills/deps.js): structured npm dependency analysis + repair. diagnose(errorMessage, cwd) returns {diagnosed, category, summary, fixes} — categories: missing_install, missing_package, version_conflict, outdated_api, corrupted_modules. healthReport(cwd) returns full health check: npm audit (vulnerabilities), outdated packages, peer dep conflicts, unused packages, lock file status, health score 0-100. getMigration(packageName) returns known upgrade paths: express→fastify (5.6x faster), moment→dayjs (2KB vs 70KB), request→node-fetch (deprecated), body-parser→built-in, callbacks→async/await. Agent tools: audit_deps (full health check), check_migration (upgrade paths). Heal pipeline uses diagnose() in tryOperationalFix before AI — zero tokens for dependency issues.",
     metadata: { topic: "skill-deps" },
   },
+  {
+    text: "Backup skill (src/skills/backup.js): agent-friendly backup/rollback. Functions: backup(cwd, reason) creates snapshot, rollback(cwd, id) restores specific backup, rollbackLatest(cwd) restores most recent, undoRollback(cwd) undoes last rollback, listBackups(cwd) shows all with status/age/reason. Agent can use via bash_exec: node -e \"require('./src/skills/backup').backup('.', 'before change')\". CLI: wolverine --backup 'reason', wolverine --list-backups, wolverine --rollback <id>, wolverine --rollback-latest, wolverine --undo-rollback. All stored in ~/.wolverine-safe-backups/snapshots/. Create backup BEFORE any risky server change.",
+    metadata: { topic: "backup-skill" },
+  },
   {
     text: "CRITICAL: Never run raw 'npm install wolverine-ai' or 'git pull' to update — these OVERWRITE server/, .wolverine/ (brain, backups, events), and .env.local. Always use the safe update skill: wolverine --update (CLI), safeUpdate(cwd) (programmatic), or let auto-update handle it. ALL backups (heal snapshots + update snapshots) stored in ~/.wolverine-safe-backups/ (OUTSIDE project, survives git clean, rm -rf, project deletion). Structure: ~/.wolverine-safe-backups/snapshots/ (heal backups), ~/.wolverine-safe-backups/updates/ (pre-update snapshots), ~/.wolverine-safe-backups/manifest.json (backup registry). Old .wolverine/backups/ auto-migrated on first run. Restore with: wolverine --restore <name>. List: wolverine --backups.",
     metadata: { topic: "safe-update-warning" },

package/src/core/wolverine.js

@@ -413,6 +413,29 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
     });
   }
 
+  // Record outcome to brain — both successes AND failures with full context
+  if (brain && brain._initialized) {
+    try {
+      if (goalResult.success) {
+        await brain.remember("fixes",
+          `FIXED (${goalResult.mode}, iter ${goalResult.iteration}): ${parsed.errorMessage} in ${parsed.filePath}:${parsed.line}. ` +
+          `Solution: ${goalResult.explanation?.slice(0, 200)}. Files: ${(goalResult.agentStats?.filesModified || []).join(", ")}`,
+          { type: "fix-success", file: parsed.filePath, error: parsed.errorMessage, mode: goalResult.mode }
+        );
+      } else {
+        // Record failure with all attempts so brain knows what NOT to do
+        const attemptSummary = (goalResult.attempts || []).map(a =>
+          `Iter ${a.iteration} (${a.mode}): ${a.explanation?.slice(0, 80)}`
+        ).join("; ");
+        await brain.remember("errors",
+          `UNRESOLVED: ${parsed.errorMessage} in ${parsed.filePath}:${parsed.line}. ` +
+          `Tried ${goalResult.iteration} iterations: ${attemptSummary}. All failed.`,
+          { type: "fix-failure", file: parsed.filePath, error: parsed.errorMessage, attempts: goalResult.iteration }
+        );
+      }
+    } catch {}
+  }
+
   if (goalResult.success) {
     if (logger) logger.info(EVENT_TYPES.HEAL_SUCCESS, goalResult.explanation, { iteration: goalResult.iteration, mode: goalResult.mode });
     return { healed: true, ...goalResult };

package/src/index.js

@@ -37,6 +37,7 @@ const { sqlGuard, SafeDB, scanForInjection, idempotencyGuard, idempotencyAfterHo
 const { diagnose: diagnoseDeps, healthReport: depsHealthReport, getMigration } = require("./skills/deps");
 const { checkForUpdate, upgrade: upgradeWolverine, getCurrentVersion } = require("./platform/auto-update");
 const { safeUpdate, createSafeBackup, listSafeBackups, restoreFromSafeBackup } = require("./skills/update");
+const { backup, rollback, rollbackLatest, undoRollback, listBackups } = require("./skills/backup");
 
 module.exports = {
   // Core
@@ -108,4 +109,9 @@ module.exports = {
   createSafeBackup,
   listSafeBackups,
   restoreFromSafeBackup,
+  backup,
+  rollback,
+  rollbackLatest,
+  undoRollback,
+  listBackups,
 };

package/src/skills/backup.js

@@ -0,0 +1,163 @@
+/**
+ * Backup Skill — agent-friendly backup/rollback interface.
+ *
+ * Wraps BackupManager with simple callable functions and CLI commands.
+ * The agent can create snapshots, list backups, rollback, and undo —
+ * all through bash_exec or direct function calls.
+ *
+ * CLI commands (via wolverine):
+ *   wolverine --backup "reason"         Create a snapshot
+ *   wolverine --rollback <id>           Rollback to a specific backup
+ *   wolverine --rollback-latest         Rollback to most recent backup
+ *   wolverine --undo-rollback           Undo the last rollback
+ *   wolverine --list-backups            List all backups with status
+ *
+ * Programmatic:
+ *   const { backup, rollback, listBackups } = require("wolverine-ai");
+ *
+ * Agent tool usage (via bash_exec):
+ *   bash_exec: node -e "require('./src/skills/backup').backup('.', 'before risky change')"
+ *   bash_exec: node -e "require('./src/skills/backup').rollbackLatest('.')"
+ */
+
+const path = require("path");
+const chalk = require("chalk");
+
+/**
+ * Create a backup snapshot of server/.
+ * @param {string} cwd — project root
+ * @param {string} reason — why this backup was created
+ * @returns {{ id, fileCount, reason }}
+ */
+function backup(cwd, reason = "manual") {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  const id = bm.createBackup(reason);
+  const entry = bm.manifest.backups.find(b => b.id === id);
+  console.log(chalk.green(`  💾 Backup created: ${id} (${entry?.fileCount || 0} files) — ${reason}`));
+  return { id, fileCount: entry?.fileCount || 0, reason };
+}
+
+/**
+ * Rollback to a specific backup.
+ * @param {string} cwd — project root
+ * @param {string} backupId — backup to restore
+ * @returns {{ success, preRollbackId }}
+ */
+function rollback(cwd, backupId) {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  const result = bm.rollbackTo(backupId);
+  if (result.success) {
+    console.log(chalk.green(`  ↩️  Rolled back to ${backupId} (pre-rollback: ${result.preRollbackId})`));
+  } else {
+    console.log(chalk.red(`  ❌ Rollback failed: backup ${backupId} not found`));
+  }
+  return result;
+}
+
+/**
+ * Rollback to the most recent backup.
+ */
+function rollbackLatest(cwd) {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  const result = bm.rollbackLatest();
+  if (result.success) {
+    console.log(chalk.green(`  ↩️  Rolled back to latest backup (pre-rollback: ${result.preRollbackId})`));
+  } else {
+    console.log(chalk.red("  ❌ No backups available to rollback"));
+  }
+  return result;
+}
+
+/**
+ * Undo the last rollback.
+ */
+function undoRollback(cwd) {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  const result = bm.undoRollback();
+  if (result.success) {
+    console.log(chalk.green("  ↩️  Undo rollback — restored pre-rollback state"));
+  } else {
+    console.log(chalk.red("  ❌ No rollback to undo"));
+  }
+  return result;
+}
+
+/**
+ * List all backups with status, age, reason, file count.
+ * @returns {Array<{ id, status, reason, fileCount, age, timestamp }>}
+ */
+function listBackups(cwd) {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  const backups = bm.getAll();
+  const stats = bm.getStats();
+
+  console.log(chalk.bold(`\n  Backups: ${stats.total} total (${stats.stable} stable, ${stats.verified} verified, ${stats.unstable} unstable)\n`));
+
+  for (const b of backups.slice(-15).reverse()) {
+    const age = Math.round((Date.now() - b.timestamp) / 60000);
+    const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+    const icon = b.status === "stable" ? "🟢" : b.status === "verified" ? "🔵" : "⚪";
+    console.log(`  ${icon} ${b.id}  ${b.status.padEnd(9)} ${b.fileCount} files  ${ageStr}  ${b.reason || ""}`);
+  }
+  console.log("");
+
+  return backups.map(b => ({
+    id: b.id,
+    status: b.status,
+    reason: b.reason,
+    fileCount: b.fileCount,
+    age: Math.round((Date.now() - b.timestamp) / 60000),
+    timestamp: b.timestamp,
+  }));
+}
+
+/**
+ * Get rollback log.
+ */
+function getRollbackLog(cwd) {
+  const { BackupManager } = require("../backup/backup-manager");
+  const bm = new BackupManager(cwd);
+  return bm.getRollbackLog();
+}
+
+// ── Skill Metadata ──
+
+const SKILL_NAME = "backup";
+const SKILL_DESCRIPTION = "Backup and rollback for server/ directory. Create snapshots before risky changes, rollback to any previous state, undo rollbacks. All backups stored safely in ~/.wolverine-safe-backups/. Agent can use via bash_exec or direct tool calls.";
+const SKILL_KEYWORDS = ["backup", "rollback", "restore", "undo", "snapshot", "revert", "save", "recovery"];
+const SKILL_USAGE = `// Create backup before making changes
+const { backup } = require("wolverine-ai");
+backup(process.cwd(), "before adding auth routes");
+
+// List all backups
+const { listBackups } = require("wolverine-ai");
+listBackups(process.cwd());
+
+// Rollback to specific backup
+const { rollback } = require("wolverine-ai");
+rollback(process.cwd(), "mngt8mwb-v0sm");
+
+// Rollback to latest
+const { rollbackLatest } = require("wolverine-ai");
+rollbackLatest(process.cwd());
+
+// Undo last rollback
+const { undoRollback } = require("wolverine-ai");
+undoRollback(process.cwd());
+
+// CLI:
+// wolverine --backup "before auth changes"
+// wolverine --list-backups
+// wolverine --rollback mngt8mwb-v0sm
+// wolverine --rollback-latest
+// wolverine --undo-rollback`;
+
+module.exports = {
+  SKILL_NAME, SKILL_DESCRIPTION, SKILL_KEYWORDS, SKILL_USAGE,
+  backup, rollback, rollbackLatest, undoRollback, listBackups, getRollbackLog,
+};