wolverine-ai 1.5.1 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "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

@@ -47,6 +47,12 @@
     "startDelayMs": 10000
   },
 
+  "errorMonitor": {
+    "defaultThreshold": 3,
+    "windowMs": 30000,
+    "cooldownMs": 60000
+  },
+
   "dashboard": {},
 
   "cors": {

package/src/core/ai-client.js

@@ -335,7 +335,7 @@ async function _chatCallWithHistory(openai, { model, messages, tools, maxTokens
  * Send an error context to OpenAI and get a repair patch back.
  * Uses CODING_MODEL — routes to correct API automatically.
  */
-async function requestRepair({ filePath, sourceCode, errorMessage, stackTrace }) {
+async function requestRepair({ filePath, sourceCode, backupSourceCode, errorMessage, stackTrace }) {
   const model = getModel("coding");
 
   const systemPrompt = "You are a Node.js debugging expert. Respond with ONLY valid JSON, no markdown fences.";
@@ -357,7 +357,7 @@ ${errorMessage}
 ${stackTrace}
 \`\`\`
 
-## Instructions
+${backupSourceCode ? `## Last Known Working Version\n\`\`\`javascript\n${backupSourceCode}\n\`\`\`\n\nCompare the current broken code with this working version. If the broken code added something that doesn't work, REVERT that addition rather than patching around it.\n` : ""}## Instructions
 1. Identify the root cause of the error.
 2. Not all errors are code bugs. Choose the correct fix type:
    - "Cannot find module 'X'" (not starting with ./ or ../) = missing npm package → use "commands" to npm install

package/src/core/runner.js

@@ -139,6 +139,7 @@ class WolverineRunner {
     this._stabilityTimer = null;
     this._stderrBuffer = "";
     this._healInProgress = false;
+    this._healStatus = null; // { active, file, error, phase, startedAt, iteration }
   }
 
   async start() {
@@ -410,6 +411,7 @@ class WolverineRunner {
   async _healAndRestart() {
     if (this._healInProgress) return;
     this._healInProgress = true;
+    this._healStatus = { active: true, error: this._stderrBuffer.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
 
     try {
       const result = await heal({
@@ -429,14 +431,23 @@ class WolverineRunner {
 
       if (result.healed) {
         this._lastBackupId = result.backupId;
-        const mode = result.mode === "agent" ? "multi-file agent" : "fast path";
+        this.retryCount = 0; // Fresh start after successful heal
+        const mode = result.mode === "agent" ? "multi-file agent" : result.mode || "fast path";
         console.log(chalk.green(`\n🐺 Wolverine healed the error via ${mode}! Restarting...\n`));
 
         if (result.agentStats) {
           console.log(chalk.gray(`   Agent stats: ${result.agentStats.turns} turns, ${result.agentStats.tokens} tokens, ${result.agentStats.filesModified.length} files modified`));
         }
 
+        // Broadcast heal success to dashboard SSE
+        if (this.logger) {
+          this.logger.info("heal.success", `Healed via ${mode}: ${result.explanation?.slice(0, 100)}`, {
+            mode, file: result.agentStats?.filesModified?.[0], duration: Date.now() - (this._healStatus?.startedAt || Date.now()),
+          });
+        }
+
         this._healInProgress = false;
+        this._healStatus = null;
         this._spawn();
       } else {
         console.log(chalk.red(`\n🐺 Wolverine could not heal: ${result.explanation}`));
@@ -479,6 +490,7 @@ class WolverineRunner {
     this._healInProgress = true;
 
     console.log(chalk.yellow(`\n🐺 Wolverine healing caught error on ${routePath}...`));
+    this._healStatus = { active: true, route: routePath, error: errorDetails?.message?.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
     this.logger.info("heal.error_monitor", `Healing caught 500 on ${routePath}`, { route: routePath });
 
     // Build a synthetic stderr from the error details
@@ -506,16 +518,28 @@ class WolverineRunner {
 
       if (result.healed) {
         console.log(chalk.green(`\n🐺 Wolverine healed ${routePath} via ${result.mode}! Restarting...\n`));
+        this.retryCount = 0; // Fresh start after successful heal
         this.errorMonitor.clearRoute(routePath);
+
+        // Broadcast heal success to dashboard SSE
+        if (this.logger) {
+          this.logger.info("heal.success", `Healed ${routePath} via ${result.mode}: ${result.explanation?.slice(0, 100)}`, {
+            mode: result.mode, route: routePath, duration: Date.now() - (this._healStatus?.startedAt || Date.now()),
+          });
+        }
+
         this._healInProgress = false;
+        this._healStatus = null;
         this.restart();
       } else {
         console.log(chalk.red(`\n🐺 Could not heal ${routePath}: ${result.explanation}`));
         this._healInProgress = false;
+        this._healStatus = null;
       }
     } catch (err) {
       console.log(chalk.red(`\n🐺 Error during heal: ${err.message}`));
       this._healInProgress = false;
+      this._healStatus = null;
     }
   }
 

package/src/core/wolverine.js

@@ -83,16 +83,22 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
   let openaiClient = null;
   try { openaiClient = getClient(); } catch { /* will fail later */ }
 
-  const injectionResult = await detectInjection(parsed.errorMessage, parsed.stackTrace, { openaiClient });
-
-  if (logger) logger.info(EVENT_TYPES.HEAL_INJECTION_SCAN, `Injection scan: ${injectionResult.safe ? "clean" : "BLOCKED"}`, injectionResult);
-
-  if (!injectionResult.safe) {
-    console.log(chalk.red("  🚨 BLOCKED: Potential prompt injection detected."));
-    if (logger) logger.critical(EVENT_TYPES.SECURITY_INJECTION_DETECTED, "Injection detected — repair blocked", injectionResult);
-    return { healed: false, explanation: "Prompt injection detected — repair blocked" };
+  // Skip injection scan on empty/trivial stderr (prevents false positives on clean restarts)
+  const stderrContent = (parsed.errorMessage || "").trim() + (parsed.stackTrace || "").trim();
+  if (stderrContent.length < 20) {
+    console.log(chalk.gray("  🛡️  Stderr too short for injection scan — skipping"));
+  } else {
+    const injectionResult = await detectInjection(parsed.errorMessage, parsed.stackTrace, { openaiClient });
+
+    if (logger) logger.info(EVENT_TYPES.HEAL_INJECTION_SCAN, `Injection scan: ${injectionResult.safe ? "clean" : "BLOCKED"}`, injectionResult);
+
+    if (!injectionResult.safe) {
+      console.log(chalk.red("  🚨 BLOCKED: Potential prompt injection detected."));
+      if (logger) logger.critical(EVENT_TYPES.SECURITY_INJECTION_DETECTED, "Injection detected — repair blocked", injectionResult);
+      return { healed: false, explanation: "Prompt injection detected — repair blocked" };
+    }
+    console.log(chalk.green("  ✅ Clean — no injection detected."));
   }
-  console.log(chalk.green("  ✅ Clean — no injection detected."));
 
   // 4b. Check if this is a human-required issue (expired keys, billing, etc.)
   if (notifier) {
@@ -128,6 +134,26 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
   // 5. Read the source file (if available) + get brain context
   const sourceCode = hasFile ? sandbox.readFile(parsed.filePath) : "";
 
+  // 5b. Get last known good version from backup (helps AI revert vs patch)
+  let backupSourceCode = "";
+  if (hasFile && backupManager) {
+    try {
+      const fs = require("fs");
+      const path = require("path");
+      const stableBackups = backupManager.getAll().filter(b => b.status === "stable" || b.status === "verified");
+      if (stableBackups.length > 0) {
+        const latest = stableBackups[stableBackups.length - 1];
+        const relPath = path.relative(cwd, parsed.filePath).replace(/[/\\]/g, "__");
+        const backupFile = path.join(cwd, ".wolverine", "backups", latest.id, relPath);
+        if (fs.existsSync(backupFile)) {
+          backupSourceCode = fs.readFileSync(backupFile, "utf-8");
+          if (backupSourceCode === sourceCode) backupSourceCode = ""; // Same — no useful diff
+          else console.log(chalk.gray(`  📋 Found last known good version (backup ${latest.id})`));
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
   let brainContext = "";
   // Inject relevant skill context (claw-code: pre-enrich prompt with matched tools)
   if (skills) {
@@ -183,7 +209,7 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
         console.log(chalk.yellow(`  🧠 Fast path (${getModel("coding")})...`));
         try {
           const repair = await requestRepair({
-            filePath: parsed.filePath, sourceCode,
+            filePath: parsed.filePath, sourceCode, backupSourceCode,
             errorMessage: parsed.errorMessage, stackTrace: parsed.stackTrace,
           });
           rateLimiter.record(errorSignature);
@@ -243,7 +269,7 @@ async function heal({ stderr, cwd, sandbox, notifier, rateLimiter, backupManager
         const agentResult = await agent.run({
           errorMessage: parsed.errorMessage, stackTrace: parsed.stackTrace,
           primaryFile: parsed.filePath, sourceCode,
-          brainContext: fullContext,
+          brainContext: fullContext + (backupSourceCode ? `\n\nLAST KNOWN WORKING VERSION of ${parsed.filePath}:\n${backupSourceCode}\nIf the broken code added something that doesn't work, revert it rather than patching around it.` : ""),
         });
         rateLimiter.record(errorSignature, agentResult.totalTokens);
 

package/src/dashboard/server.js

@@ -871,6 +871,7 @@ ${context ? "\nBrain:\n" + context : ""}`,
       backups: this.backupManager ? this.backupManager.getStats() : {},
       health: this.healthMonitor ? this.healthMonitor.getStats() : {},
       errorMonitor: this.errorMonitor ? this.errorMonitor.getStats() : {},
+      heal: this.runner ? this.runner._healStatus : null,
     }));
   }