wolverine-ai 2.6.2 → 2.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "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/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/platform/auto-update.js

@@ -90,80 +90,6 @@ function isNewer(latest, current) {
   return false;
 }
 
-/**
- * Protect ALL user files before update and restore after.
- * The entire server/ directory is sacred — auto-update must never touch it.
- * Also protects .env files and any user config.
- */
-function backupUserFiles(cwd) {
-  const backups = {};
-
-  // Protect config files
-  const protectedFiles = [".env.local", ".env"];
-
-  // Protect ALL .wolverine/ state (backups, brain, events, usage, repairs)
-  const wolvDir = path.join(cwd, ".wolverine");
-  if (fs.existsSync(wolvDir)) {
-    const walkState = (dir, base) => {
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
-          const relPath = path.join(base, entry.name).replace(/\\/g, "/");
-          if (entry.isDirectory()) { walkState(fullPath, relPath); }
-          else {
-            try {
-              const stat = fs.statSync(fullPath);
-              if (stat.size <= 10 * 1024 * 1024) { // skip files > 10MB
-                backups[relPath] = fs.readFileSync(fullPath, "utf-8");
-              }
-            } catch {}
-          }
-        }
-      } catch {}
-    };
-    walkState(wolvDir, ".wolverine");
-  }
-  for (const file of protectedFiles) {
-    const fullPath = path.join(cwd, file);
-    if (fs.existsSync(fullPath)) {
-      backups[file] = fs.readFileSync(fullPath, "utf-8");
-    }
-  }
-
-  // Protect entire server/ directory (recursive)
-  const serverDir = path.join(cwd, "server");
-  if (fs.existsSync(serverDir)) {
-    const walk = (dir, base) => {
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name === "node_modules") continue;
-          const fullPath = path.join(dir, entry.name);
-          const relPath = path.join(base, entry.name).replace(/\\/g, "/");
-          if (entry.isDirectory()) { walk(fullPath, relPath); }
-          else {
-            try { backups[relPath] = fs.readFileSync(fullPath, "utf-8"); } catch {}
-          }
-        }
-      } catch {}
-    };
-    walk(serverDir, "server");
-  }
-
-  return backups;
-}
-
-function restoreUserFiles(cwd, backups) {
-  for (const [file, content] of Object.entries(backups)) {
-    const fullPath = path.join(cwd, file);
-    try {
-      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-      fs.writeFileSync(fullPath, content, "utf-8");
-    } catch {}
-  }
-}
-
 /**
  * Detect if this is a git repo or an npm install.
  */
@@ -214,51 +140,6 @@ function checkForUpdate(cwd) {
   }
 }
 
-/**
- * Merge new brain seed docs into existing brain.
- * Reads the updated brain.js SEED_DOCS, compares topics with what's
- * already stored in .wolverine/brain/, and appends only new ones.
- * Existing memories (errors, fixes, learnings) are never touched.
- *
- * @returns {number} count of new seed docs added
- */
-function _mergeBrainSeeds(cwd) {
-  try {
-    // Load the brain store directly
-    const storePath = path.join(cwd, ".wolverine", "brain", "store.json");
-    if (!fs.existsSync(storePath)) return 0;
-
-    const store = JSON.parse(fs.readFileSync(storePath, "utf-8"));
-    const existingTexts = new Set();
-    for (const ns of Object.values(store.namespaces || {})) {
-      for (const entry of (ns || [])) {
-        if (entry.text) existingTexts.add(entry.text.slice(0, 80));
-      }
-    }
-
-    // Load fresh seed docs from the updated brain.js
-    // Clear require cache to get the new version
-    const brainPath = path.join(cwd, "src", "brain", "brain.js");
-    delete require.cache[require.resolve(brainPath)];
-    const brainModule = require(brainPath);
-
-    // Access seed docs — they're in the module's closure, but brain.init() re-seeds them.
-    // Instead, we'll read the file and extract them
-    const brainSource = fs.readFileSync(brainPath, "utf-8");
-    const seedMatch = brainSource.match(/const SEED_DOCS = \[([\s\S]*?)\n\];/);
-    if (!seedMatch) return 0;
-
-    // Count how many seed doc topics are new
-    // We can't easily parse the JS array, but we can trigger brain.init() on next restart
-    // which will re-seed. The brain's init() already only adds seeds if namespace is empty.
-    // So we just need to signal that seeds should be refreshed.
-    const seedRefreshPath = path.join(cwd, ".wolverine", "brain", ".seed-refresh");
-    fs.writeFileSync(seedRefreshPath, new Date().toISOString(), "utf-8");
-
-    return 1; // signal that refresh is pending
-  } catch { return 0; }
-}
-
 /**
  * Start auto-update schedule. Checks every hour (configurable).
  * If autoUpdate is enabled and a new version is found, upgrades and signals restart.

package/src/skills/update.js

@@ -1,66 +1,62 @@
 /**
  * Update Skill — safe self-updating for the wolverine framework.
  *
- * WARNING: raw `npm install` or `git pull` can overwrite:
- * - server/ (user's live code, routes, config, database)
- * - .wolverine/ (brain memories, backups, events, repair history, usage)
- * - .env.local (API keys, secrets)
+ * WARNING: raw `npm install` or `git pull` can overwrite server/ and .wolverine/.
+ * This skill updates ONLY framework files and never touches the server.
  *
- * This skill does it safely:
- * 1. Creates a pre-update snapshot in ~/.wolverine-safe-backups/ (outside project, never erased)
- * 2. Backs up all user files to memory
- * 3. Selectively updates ONLY framework files (src/, bin/, package.json)
- * 4. Restores all user files
- * 5. Merges new brain seed docs (append, not replace)
- * 6. Verifies the update didn't break anything
+ * What it does:
+ * 1. Creates emergency backup of server/ + brain (small, no node_modules)
+ * 2. Selectively updates ONLY framework files (src/, bin/, package.json)
+ * 3. server/ is NEVER touched — no backup/restore dance needed
+ * 4. Signals brain to merge new seed docs on next boot
  *
- * Callable as:
- *   wolverine --update              (CLI)
- *   npx wolverine-update            (npm)
- *   require("wolverine-ai").safeUpdate(cwd)  (programmatic)
+ * Emergency backup is for rollback ONLY if something goes wrong.
+ * Located in ~/.wolverine-safe-backups/ (outside project, survives everything).
  */
 
 const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const chalk = require("chalk");
+const os = require("os");
 
 const PACKAGE_NAME = "wolverine-ai";
-const SAFE_BACKUP_DIR = path.join(require("os").homedir(), ".wolverine-safe-backups");
-const SAFE_SNAPSHOTS_DIR = path.join(SAFE_BACKUP_DIR, "snapshots");
+const SAFE_BACKUP_DIR = path.join(os.homedir(), ".wolverine-safe-backups");
+
+// Files/dirs to SKIP when backing up server/ (these are huge and not user code)
+const SKIP_DIRS = new Set(["node_modules", ".git", ".wolverine", "dist", ".next", ".cache"]);
 
 /**
- * Create a safe backup snapshot outside the project directory.
- * These survive git clean, rm -rf node_modules, even rm -rf .wolverine.
+ * Create an emergency backup — server/ code + brain only.
+ * Small and fast. No node_modules, no backup-of-backups.
  */
 function createSafeBackup(cwd) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const backupDir = path.join(SAFE_BACKUP_DIR, "updates", timestamp);
   fs.mkdirSync(backupDir, { recursive: true });
 
-  const dirsToBackup = [
-    { src: ".wolverine", label: "brain/backups/events/usage" },
-    { src: "server", label: "server code" },
-  ];
-  const filesToBackup = [".env.local", ".env"];
-
   let fileCount = 0;
 
-  for (const { src } of dirsToBackup) {
-    const srcPath = path.join(cwd, src);
-    if (!fs.existsSync(srcPath)) continue;
-    const destPath = path.join(backupDir, src);
-    _copyDirRecursive(srcPath, destPath);
-    fileCount += _countFiles(destPath);
+  // Backup server/ (user code only — skip node_modules, .git, etc.)
+  const serverDir = path.join(cwd, "server");
+  if (fs.existsSync(serverDir)) {
+    fileCount += _copyDirSelective(serverDir, path.join(backupDir, "server"));
   }
 
-  for (const file of filesToBackup) {
-    const srcPath = path.join(cwd, file);
-    if (!fs.existsSync(srcPath)) continue;
-    fs.copyFileSync(srcPath, path.join(backupDir, file));
+  // Backup brain vectors (the learned knowledge)
+  const brainStore = path.join(cwd, ".wolverine", "brain", "vectors.json");
+  if (fs.existsSync(brainStore)) {
+    fs.mkdirSync(path.join(backupDir, ".wolverine", "brain"), { recursive: true });
+    fs.copyFileSync(brainStore, path.join(backupDir, ".wolverine", "brain", "vectors.json"));
     fileCount++;
   }
 
+  // Backup .env files
+  for (const f of [".env.local", ".env"]) {
+    const fp = path.join(cwd, f);
+    if (fs.existsSync(fp)) { fs.copyFileSync(fp, path.join(backupDir, f)); fileCount++; }
+  }
+
   // Write manifest
   fs.writeFileSync(path.join(backupDir, "manifest.json"), JSON.stringify({
     timestamp: Date.now(),
@@ -68,6 +64,7 @@ function createSafeBackup(cwd) {
     cwd,
     version: _getCurrentVersion(cwd),
     fileCount,
+    type: "pre-update",
   }, null, 2), "utf-8");
 
   return { dir: backupDir, fileCount, timestamp };
@@ -80,10 +77,10 @@ function listSafeBackups() {
   const updatesDir = path.join(SAFE_BACKUP_DIR, "updates");
   if (!fs.existsSync(updatesDir)) return [];
   return fs.readdirSync(updatesDir)
-    .filter(d => fs.statSync(path.join(updatesDir, d)).isDirectory())
+    .filter(d => { try { return fs.statSync(path.join(updatesDir, d)).isDirectory(); } catch { return false; } })
     .map(d => {
       try {
-        const manifest = JSON.parse(fs.readFileSync(path.join(SAFE_BACKUP_DIR, "updates", d, "manifest.json"), "utf-8"));
+        const manifest = JSON.parse(fs.readFileSync(path.join(updatesDir, d, "manifest.json"), "utf-8"));
         return { dir: d, ...manifest };
       } catch { return { dir: d }; }
     })
@@ -91,39 +88,41 @@ function listSafeBackups() {
 }
 
 /**
- * Restore from a safe backup.
+ * Restore from a safe backup (emergency only).
  */
 function restoreFromSafeBackup(cwd, backupName) {
   const backupDir = path.join(SAFE_BACKUP_DIR, "updates", backupName);
   if (!fs.existsSync(backupDir)) throw new Error(`Backup not found: ${backupName}`);
 
-  const dirsToRestore = [".wolverine", "server"];
-  const filesToRestore = [".env.local", ".env"];
-
   let restored = 0;
-  for (const dir of dirsToRestore) {
-    const srcPath = path.join(backupDir, dir);
-    if (!fs.existsSync(srcPath)) continue;
-    const destPath = path.join(cwd, dir);
-    _copyDirRecursive(srcPath, destPath);
-    restored += _countFiles(srcPath);
+
+  // Restore server/
+  const serverSrc = path.join(backupDir, "server");
+  if (fs.existsSync(serverSrc)) {
+    restored += _copyDirSelective(serverSrc, path.join(cwd, "server"));
   }
-  for (const file of filesToRestore) {
-    const srcPath = path.join(backupDir, file);
-    if (!fs.existsSync(srcPath)) continue;
-    fs.copyFileSync(srcPath, path.join(cwd, file));
+
+  // Restore brain
+  const brainSrc = path.join(backupDir, ".wolverine", "brain", "vectors.json");
+  if (fs.existsSync(brainSrc)) {
+    const dest = path.join(cwd, ".wolverine", "brain", "vectors.json");
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(brainSrc, dest);
     restored++;
   }
+
+  // Restore .env files
+  for (const f of [".env.local", ".env"]) {
+    const src = path.join(backupDir, f);
+    if (fs.existsSync(src)) { fs.copyFileSync(src, path.join(cwd, f)); restored++; }
+  }
+
   return { restored, backupDir };
 }
 
 /**
  * Safe update — the main entry point.
- * Call this instead of raw npm install or git pull.
- *
- * @param {string} cwd — project root
- * @param {object} options — { logger, dryRun }
- * @returns {{ success, from, to, backupDir, error? }}
+ * Updates framework files ONLY. server/ is never touched.
  */
 function safeUpdate(cwd, options = {}) {
   const { logger, dryRun } = options;
@@ -140,7 +139,6 @@ function safeUpdate(cwd, options = {}) {
     }).trim();
   } catch {}
 
-  // Also check git remote
   const isGit = _isGitRepo(cwd);
   if (isGit) {
     try {
@@ -167,20 +165,16 @@ function safeUpdate(cwd, options = {}) {
     return { success: true, from: currentVersion, to: latestVersion, dryRun: true };
   }
 
-  // 2. Create safe backup (outside project, survives everything)
-  console.log(chalk.gray("  🔒 Creating safe backup..."));
+  // 2. Emergency backup (server code + brain only — small and fast)
+  console.log(chalk.gray("  🔒 Creating emergency backup..."));
   const backup = createSafeBackup(cwd);
   console.log(chalk.gray(`  🔒 Backed up ${backup.fileCount} files to ${backup.dir}`));
-  if (logger) logger.info("update.backup", `Safe backup: ${backup.fileCount} files`, { dir: backup.dir });
-
-  // 3. Backup user files to memory (belt + suspenders)
-  const memoryBackup = _backupToMemory(cwd);
-  console.log(chalk.gray(`  🔒 Memory backup: ${Object.keys(memoryBackup).length} files`));
+  if (logger) logger.info("update.backup", `Emergency backup: ${backup.fileCount} files`, { dir: backup.dir });
 
   try {
-    // 4. Update framework ONLY
+    // 3. Update framework ONLY — server/ is never touched
     if (isGit) {
-      console.log(chalk.blue("  📦 Selective git update (server/ + .wolverine/ untouched)"));
+      console.log(chalk.blue("  📦 Selective git update (server/ untouched)"));
       const frameworkPaths = "src/ bin/ package.json package-lock.json examples/ tests/ CLAUDE.md README.md CHANGELOG.md .npmignore";
       execSync(`git checkout origin/master -- ${frameworkPaths}`, { cwd, stdio: "pipe", timeout: 30000 });
       execSync("npm install --production", { cwd, stdio: "pipe", timeout: 120000 });
@@ -190,29 +184,22 @@ function safeUpdate(cwd, options = {}) {
       execSync(cmd, { cwd, stdio: "pipe", timeout: 120000 });
     }
 
-    // 5. Restore user files from memory
-    _restoreFromMemory(cwd, memoryBackup);
-    console.log(chalk.gray(`  🔒 Restored ${Object.keys(memoryBackup).length} user files`));
-
-    // 6. Signal brain to merge new seeds on next boot
+    // 4. Signal brain to merge new seeds on next boot
     const seedRefreshDir = path.join(cwd, ".wolverine", "brain");
     fs.mkdirSync(seedRefreshDir, { recursive: true });
     fs.writeFileSync(path.join(seedRefreshDir, ".seed-refresh"), new Date().toISOString(), "utf-8");
     console.log(chalk.gray("  🧠 Brain seed merge scheduled for next boot"));
 
-    // 7. Verify
     const newVersion = _getCurrentVersion(cwd);
     console.log(chalk.green(`  ✅ Updated: ${currentVersion} → ${newVersion}`));
-    console.log(chalk.gray(`  🔒 Safe backup at: ${backup.dir}`));
+    console.log(chalk.gray(`  🔒 Emergency backup at: ${backup.dir}`));
     if (logger) logger.info("update.success", `Updated ${currentVersion} → ${newVersion}`, { from: currentVersion, to: newVersion });
 
     return { success: true, from: currentVersion, to: newVersion, backupDir: backup.dir };
   } catch (err) {
-    // Restore from memory on failure
-    _restoreFromMemory(cwd, memoryBackup);
     const errMsg = (err.message || "").slice(0, 100);
     console.log(chalk.red(`  ❌ Update failed: ${errMsg}`));
-    console.log(chalk.yellow(`  🔒 Restore from safe backup: wolverine --restore ${backup.timestamp}`));
+    console.log(chalk.yellow(`  🔒 Restore with: wolverine --restore ${backup.timestamp}`));
     if (logger) logger.warn("update.failed", `Update failed: ${errMsg}`, { from: currentVersion });
     return { success: false, from: currentVersion, to: latestVersion, error: errMsg, backupDir: backup.dir };
   }
@@ -235,82 +222,41 @@ function _isNewer(a, b) {
   return false;
 }
 
-function _copyDirRecursive(src, dest) {
+/**
+ * Copy directory recursively, skipping node_modules/.git/.wolverine/dist etc.
+ * Returns file count.
+ */
+function _copyDirSelective(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
+  let count = 0;
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    if (entry.name === "node_modules") continue;
+    if (SKIP_DIRS.has(entry.name)) continue;
     const s = path.join(src, entry.name), d = path.join(dest, entry.name);
-    if (entry.isDirectory()) _copyDirRecursive(s, d);
-    else { try { fs.copyFileSync(s, d); } catch {} }
-  }
-}
-
-function _countFiles(dir) {
-  let count = 0;
-  try {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) count += _countFiles(path.join(dir, entry.name));
-      else count++;
-    }
-  } catch {}
-  return count;
-}
-
-function _backupToMemory(cwd) {
-  const backups = {};
-  const protect = ["server", ".wolverine"];
-  const protectFiles = [".env.local", ".env"];
-
-  for (const dir of protect) {
-    const dirPath = path.join(cwd, dir);
-    if (!fs.existsSync(dirPath)) continue;
-    const walk = (d, base) => {
+    if (entry.isDirectory()) { count += _copyDirSelective(s, d); }
+    else {
       try {
-        for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-          if (entry.name === "node_modules") continue;
-          const full = path.join(d, entry.name), rel = path.join(base, entry.name).replace(/\\/g, "/");
-          if (entry.isDirectory()) walk(full, rel);
-          else { try { const s = fs.statSync(full); if (s.size <= 10*1024*1024) backups[rel] = fs.readFileSync(full); } catch {} }
-        }
+        const stat = fs.statSync(s);
+        if (stat.size <= 5 * 1024 * 1024) { fs.copyFileSync(s, d); count++; } // skip >5MB
       } catch {}
-    };
-    walk(dirPath, dir);
-  }
-  for (const f of protectFiles) {
-    const fp = path.join(cwd, f);
-    if (fs.existsSync(fp)) backups[f] = fs.readFileSync(fp);
-  }
-  return backups;
-}
-
-function _restoreFromMemory(cwd, backups) {
-  for (const [rel, content] of Object.entries(backups)) {
-    const fp = path.join(cwd, rel);
-    try { fs.mkdirSync(path.dirname(fp), { recursive: true }); fs.writeFileSync(fp, content); } catch {}
+    }
   }
+  return count;
 }
 
 // ── Skill Metadata ──
 
 const SKILL_NAME = "update";
-const SKILL_DESCRIPTION = "Safe self-updating for wolverine framework. Creates safe backup outside project (~/. wolverine-safe-backups/), selectively updates only framework files (src/, bin/, package.json), restores all user files (server/, .wolverine/, .env), merges new brain seeds. Never use raw npm install or git pull — they overwrite server code and brain memories.";
+const SKILL_DESCRIPTION = "Safe self-updating for wolverine framework. Creates emergency backup of server code + brain (no node_modules), selectively updates only framework files (src/, bin/, package.json), never touches server/. Never use raw npm install or git pull.";
 const SKILL_KEYWORDS = ["update", "upgrade", "version", "install", "pull", "self-update", "auto-update", "framework", "safe"];
 const SKILL_USAGE = `// Safe update (programmatic)
 const { safeUpdate } = require("wolverine-ai");
-const result = await safeUpdate(process.cwd());
-// { success: true, from: "2.5.3", to: "2.6.0", backupDir: "~/.wolverine-safe-backups/..." }
-
-// List safe backups
-const { listSafeBackups } = require("wolverine-ai");
-const backups = listSafeBackups();
-
-// Restore from safe backup
-const { restoreFromSafeBackup } = require("wolverine-ai");
-restoreFromSafeBackup(process.cwd(), "2026-04-02T21-15-00");
+const result = safeUpdate(process.cwd());
 
-// CLI: wolverine --update
-// CLI: wolverine --update --dry-run
-// CLI: wolverine --restore 2026-04-02T21-15-00`;
+// CLI
+// wolverine --update
+// wolverine --update --dry-run
+// wolverine --backups
+// wolverine --restore 2026-04-02T21-15-00`;
 
 module.exports = {
   SKILL_NAME, SKILL_DESCRIPTION, SKILL_KEYWORDS, SKILL_USAGE,