wolverine-ai 2.4.4 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "2.4.4",
+  "version": "2.5.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/server/config/settings.json

@@ -81,7 +81,7 @@
 
   "autoUpdate": {
     "enabled": true,
-    "intervalMs": 3600000
+    "intervalMs": 300000
   },
 
   "dashboard": {},

package/src/brain/brain.js

@@ -263,10 +263,17 @@ class Brain {
 
     console.log(chalk.gray(`  🧠 Brain: ${stats.totalEntries} memories loaded`));
 
-    // 1. Seed wolverine docs on first run
+    // 1. Seed wolverine docs on first run OR merge new seeds after framework update
+    const seedRefreshPath = path.join(this.projectRoot, ".wolverine", "brain", ".seed-refresh");
+    const needsSeedRefresh = fs.existsSync(seedRefreshPath);
+
     if (isFirstRun) {
       console.log(chalk.gray("  🧠 First run — seeding wolverine documentation..."));
       await this._seedDocs();
+    } else if (needsSeedRefresh) {
+      console.log(chalk.gray("  🧠 Framework updated — merging new seed docs..."));
+      await this._mergeSeedDocs();
+      try { fs.unlinkSync(seedRefreshPath); } catch {}
     }
 
     // 2. Scan project for live function map
@@ -394,6 +401,47 @@ class Brain {
     console.log(chalk.gray(`  🧠 Seeded ${SEED_DOCS.length} documentation entries`));
   }
 
+  /**
+   * Merge new seed docs into existing brain — append only, never delete.
+   * Compares by topic metadata to find new/updated docs.
+   * Existing memories (errors, fixes, learnings) are untouched.
+   */
+  async _mergeSeedDocs() {
+    const existing = this.store.getNamespace("docs") || [];
+    const existingTopics = new Set(existing.map(e => e.metadata?.topic).filter(Boolean));
+
+    // Find seed docs whose topic isn't already in the brain
+    const newDocs = SEED_DOCS.filter(d => !existingTopics.has(d.metadata?.topic));
+    // Find seed docs whose topic exists but text has changed (updated knowledge)
+    const updatedDocs = SEED_DOCS.filter(d => {
+      if (!existingTopics.has(d.metadata?.topic)) return false;
+      const match = existing.find(e => e.metadata?.topic === d.metadata?.topic);
+      return match && match.text !== d.text;
+    });
+
+    const toEmbed = [...newDocs, ...updatedDocs];
+    if (toEmbed.length === 0) {
+      console.log(chalk.gray("  🧠 Brain seeds already up to date"));
+      return;
+    }
+
+    // Remove old versions of updated docs
+    for (const doc of updatedDocs) {
+      const old = existing.find(e => e.metadata?.topic === doc.metadata?.topic);
+      if (old) this.store.delete(old.id);
+    }
+
+    // Embed and add new/updated docs
+    const texts = toEmbed.map(d => d.text);
+    const embeddings = await embedBatch(texts);
+    for (let i = 0; i < toEmbed.length; i++) {
+      this.store.add("docs", toEmbed[i].text, embeddings[i], toEmbed[i].metadata);
+    }
+
+    this.store.save();
+    console.log(chalk.gray(`  🧠 Merged: ${newDocs.length} new + ${updatedDocs.length} updated seed docs`));
+  }
+
   async _embedFunctionMap() {
     // Clear old function map entries
     const oldEntries = this.store.getNamespace("functions");

package/src/platform/auto-update.js

@@ -91,25 +91,70 @@ function isNewer(latest, current) {
 }
 
 /**
- * Protect config files before update and restore after.
+ * 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 backupConfigs(cwd) {
-  const configs = [
-    "server/config/settings.json",
-    ".env.local",
-    ".env",
-  ];
+function backupUserFiles(cwd) {
   const backups = {};
-  for (const file of configs) {
+
+  // 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 restoreConfigs(cwd, backups) {
+function restoreUserFiles(cwd, backups) {
   for (const [file, content] of Object.entries(backups)) {
     const fullPath = path.join(cwd, file);
     try {
@@ -144,33 +189,41 @@ function upgrade(cwd, logger) {
   console.log(chalk.blue(`\n  🔄 Wolverine update available: ${current} → ${latest}`));
   if (logger) logger.info("update.start", `Upgrading ${current} → ${latest}`, { from: current, to: latest });
 
-  // Back up configs
-  const configBackups = backupConfigs(cwd);
-  console.log(chalk.gray(`  🔒 Backed up ${Object.keys(configBackups).length} config files`));
+  // Back up ALL user files (server/, .env, configs)
+  const userBackups = backupUserFiles(cwd);
+  console.log(chalk.gray(`  🔒 Backed up ${Object.keys(userBackups).length} user files (server/ protected)`));
 
   try {
-    // Detect install method: git clone or npm package
     const useGit = isGitRepo(cwd);
-    let cmd;
 
     if (useGit) {
-      // Git-cloned: pull latest from origin, then npm install for deps
-      cmd = "git pull origin master && npm install";
-      console.log(chalk.blue(`  📦 Git repo detected — pulling latest`));
+      // Git-cloned: ONLY update framework files, NEVER touch server/
+      // Fetch latest, then selectively checkout only framework dirs
+      console.log(chalk.blue(`  📦 Git repo — selective framework update (server/ untouched)`));
+      execSync("git fetch origin master", { cwd, stdio: "pipe", timeout: 30000 });
+      // Only update: src/, bin/, package.json, examples/, tests/, CLAUDE.md, README.md, CHANGELOG.md
+      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", { cwd, stdio: "pipe", timeout: 120000 });
     } else {
       // npm-installed: update the package
       const isGlobal = __dirname.includes("node_modules") && !cwd.includes("node_modules");
-      cmd = isGlobal
+      const cmd = isGlobal
         ? `npm install -g ${PACKAGE_NAME}@${latest}`
         : `npm install ${PACKAGE_NAME}@${latest}`;
+      console.log(chalk.blue(`  📦 Running: ${cmd}`));
+      execSync(cmd, { cwd, stdio: "pipe", timeout: 120000 });
     }
 
-    console.log(chalk.blue(`  📦 Running: ${cmd}`));
-    execSync(cmd, { cwd, stdio: "pipe", timeout: 120000 });
+    // Restore ALL user files (server/, .env, .wolverine/) — belt AND suspenders
+    restoreUserFiles(cwd, userBackups);
+    console.log(chalk.gray(`  🔒 Restored ${Object.keys(userBackups).length} user files`));
 
-    // Restore configs (npm might have overwritten them)
-    restoreConfigs(cwd, configBackups);
-    console.log(chalk.gray(`  🔒 Restored config files`));
+    // Merge new brain seed docs into existing brain (append, don't replace)
+    try {
+      const brainMerged = _mergeBrainSeeds(cwd);
+      if (brainMerged > 0) console.log(chalk.gray(`  🧠 Merged ${brainMerged} new seed docs into brain`));
+    } catch {}
 
     // Clear version cache
     _currentVersion = null;
@@ -180,8 +233,8 @@ function upgrade(cwd, logger) {
 
     return { success: true, from: current, to: latest };
   } catch (err) {
-    // Restore configs on failure
-    restoreConfigs(cwd, configBackups);
+    // Restore user files on failure
+    restoreUserFiles(cwd, userBackups);
     const errMsg = (err.message || "").slice(0, 100);
     console.log(chalk.yellow(`  ⚠️  Update failed: ${errMsg}`));
     if (logger) logger.warn("update.failed", `Upgrade failed: ${errMsg}`, { from: current, to: latest });
@@ -211,6 +264,51 @@ 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.