wolverine-ai 1.0.0

package/src/core/health-monitor.js

@@ -0,0 +1,129 @@
+const http = require("http");
+const chalk = require("chalk");
+
+/**
+ * Health Monitor — periodically pings the server to detect hangs, freezes,
+ * and unresponsive states that don't produce a crash/exit.
+ *
+ * Works like PM2's health check: if the server stops responding,
+ * wolverine treats it as a crash and triggers the heal cycle.
+ */
+class HealthMonitor {
+  constructor(options = {}) {
+    this.port = options.port || parseInt(process.env.PORT, 10) || 3000;
+    this.path = options.path || "/health";
+    this.intervalMs = options.intervalMs || 15000;       // check every 15s
+    this.timeoutMs = options.timeoutMs || 5000;          // 5s timeout per check
+    this.failThreshold = options.failThreshold || 3;     // 3 consecutive fails = dead
+    this.startDelayMs = options.startDelayMs || 10000;   // wait 10s before first check
+
+    this._timer = null;
+    this._consecutiveFailures = 0;
+    this._onUnhealthy = null;
+    this._running = false;
+    this._totalChecks = 0;
+    this._totalPasses = 0;
+  }
+
+  /**
+   * Start monitoring. Calls onUnhealthy callback when the server is deemed dead.
+   */
+  start(onUnhealthy) {
+    this._onUnhealthy = onUnhealthy;
+    this._consecutiveFailures = 0;
+    this._running = true;
+
+    // Delay first check to let the server boot
+    this._timer = setTimeout(() => {
+      if (!this._running) return;
+      this._check();
+      this._timer = setInterval(() => this._check(), this.intervalMs);
+    }, this.startDelayMs);
+  }
+
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearTimeout(this._timer);
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  reset() {
+    this._consecutiveFailures = 0;
+  }
+
+  getStats() {
+    return {
+      totalChecks: this._totalChecks,
+      totalPasses: this._totalPasses,
+      consecutiveFailures: this._consecutiveFailures,
+      uptimePercent: this._totalChecks > 0
+        ? Math.round((this._totalPasses / this._totalChecks) * 100)
+        : 100,
+    };
+  }
+
+  _check() {
+    if (!this._running) return;
+    this._totalChecks++;
+
+    const req = http.request(
+      {
+        hostname: "127.0.0.1",
+        port: this.port,
+        path: this.path,
+        method: "GET",
+        timeout: this.timeoutMs,
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => { body += chunk; });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 400) {
+            this._onPass();
+          } else {
+            this._onFail(`HTTP ${res.statusCode}`);
+          }
+        });
+      }
+    );
+
+    req.on("timeout", () => {
+      req.destroy();
+      this._onFail("timeout");
+    });
+
+    req.on("error", (err) => {
+      // ECONNREFUSED means the server isn't listening — this is expected
+      // right after a crash/restart, so only count it if we've been checking a while
+      this._onFail(err.code || err.message);
+    });
+
+    req.end();
+  }
+
+  _onPass() {
+    if (this._consecutiveFailures > 0) {
+      console.log(chalk.green(`  💓 Health check passed (recovered after ${this._consecutiveFailures} failures)`));
+    }
+    this._consecutiveFailures = 0;
+    this._totalPasses++;
+  }
+
+  _onFail(reason) {
+    this._consecutiveFailures++;
+    console.log(chalk.yellow(`  💔 Health check failed (${this._consecutiveFailures}/${this.failThreshold}): ${reason}`));
+
+    if (this._consecutiveFailures >= this.failThreshold) {
+      console.log(chalk.red(`\n🚨 Server unresponsive after ${this.failThreshold} consecutive health check failures.`));
+      this._consecutiveFailures = 0; // reset to avoid re-triggering immediately
+      if (this._onUnhealthy) {
+        this._onUnhealthy(reason);
+      }
+    }
+  }
+}
+
+module.exports = { HealthMonitor };

package/src/core/models.js

@@ -0,0 +1,132 @@
+/**
+ * Model Configuration — centralized model selection for every AI task.
+ *
+ * Users configure models in .env.local to optimize spend:
+ *
+ *   REASONING_MODEL   — Deep analysis, complex debugging (most expensive, most capable)
+ *   CODING_MODEL      — Code repair generation (important, needs strong coding ability)
+ *   CHAT_MODEL        — Explanations, summaries (good but cheaper)
+ *   AUDIT_MODEL       — Security scans, injection detection (runs on every error)
+ *   UTILITY_MODEL     — JSON formatting, regex validation, simple classification (cheapest)
+ *
+ * Defaults use gpt-4o tiers. Users can swap in any OpenAI-compatible model.
+ */
+
+const MODEL_ROLES = {
+  // Deep reasoning — used for multi-step debugging when a simple fix fails
+  reasoning: {
+    envKey: "REASONING_MODEL",
+    default: "gpt-5.4",
+    description: "Deep analysis and complex multi-step debugging",
+    tier: "premium",
+  },
+
+  // Code generation — the main repair model
+  coding: {
+    envKey: "CODING_MODEL",
+    default: "gpt-5.3-codex",
+    description: "Code repair and fix generation",
+    tier: "premium",
+  },
+
+  // Chat/explanation — used for generating human-readable explanations
+  chat: {
+    envKey: "CHAT_MODEL",
+    default: "gpt-5.4-mini",
+    description: "Explanations, summaries, and user-facing messages",
+    tier: "standard",
+  },
+
+  // Security audit — injection detection, runs on every single error
+  audit: {
+    envKey: "AUDIT_MODEL",
+    default: "gpt-5.4-nano",
+    description: "Security scanning and prompt injection detection",
+    tier: "economy",
+  },
+
+  // Compacting — compresses text before embedding into brain
+  utility: {
+    envKey: "COMPACTING_MODEL",
+    default: "gpt-5.4-nano",
+    description: "Text compaction before brain embedding",
+    tier: "economy",
+  },
+
+  // Tool — chat responses that use function calling (call_endpoint, search_brain)
+  tool: {
+    envKey: "TOOL_MODEL",
+    default: "gpt-4o-mini",
+    description: "Chat with tool calling (must support function calling)",
+    tier: "standard",
+  },
+
+  // Classifier — routes commands to CHAT vs AGENT, picks tiers
+  classifier: {
+    envKey: "CLASSIFIER_MODEL",
+    default: "gpt-4o-mini",
+    description: "Command routing and classification (CHAT/AGENT, SMALL/MEDIUM/LARGE)",
+    tier: "economy",
+  },
+
+  // Research — deep research for solutions when fixes fail
+  research: {
+    envKey: "RESEARCH_MODEL",
+    default: "gpt-4o",
+    description: "Deep research for error solutions and documentation lookup",
+    tier: "premium",
+  },
+
+  // Embedding — vector representations for semantic search
+  embedding: {
+    envKey: "TEXT_EMBEDDING_MODEL",
+    default: "text-embedding-3-small",
+    description: "Text embeddings for brain vector store",
+    tier: "economy",
+  },
+};
+
+/**
+ * Get the configured model for a given role.
+ */
+function getModel(role) {
+  const config = MODEL_ROLES[role];
+  if (!config) {
+    throw new Error(`Unknown model role: "${role}". Valid roles: ${Object.keys(MODEL_ROLES).join(", ")}`);
+  }
+  // Priority: env var → wolverine.config.js → hardcoded default
+  const { getConfig } = require("./config");
+  return process.env[config.envKey] || getConfig(`models.${role}`) || config.default;
+}
+
+/**
+ * Get all model assignments for logging.
+ */
+function getModelConfig() {
+  const config = {};
+  for (const [role, def] of Object.entries(MODEL_ROLES)) {
+    config[role] = {
+      model: process.env[def.envKey] || def.default,
+      source: process.env[def.envKey] ? "env" : "default",
+      tier: def.tier,
+    };
+  }
+  return config;
+}
+
+/**
+ * Log the current model configuration.
+ */
+function logModelConfig(chalk) {
+  const config = getModelConfig();
+  const tierColors = { premium: "cyan", standard: "blue", economy: "gray" };
+
+  for (const [role, info] of Object.entries(config)) {
+    const color = tierColors[info.tier] || "white";
+    const label = `${role.padEnd(10)} → ${info.model}`;
+    const source = info.source === "env" ? "(custom)" : "(default)";
+    console.log(chalk[color](`    ${label} ${source}`));
+  }
+}
+
+module.exports = { getModel, getModelConfig, logModelConfig, MODEL_ROLES };

package/src/core/patcher.js

@@ -0,0 +1,55 @@
+const path = require("path");
+
+/**
+ * Apply a set of changes from the AI repair response.
+ * All file operations go through the sandbox.
+ * Backups are managed by BackupManager (not inline .bak files anymore).
+ *
+ * Returns an array of { file, success, error? } objects.
+ */
+function applyPatch(changes, basePath, sandbox) {
+  const results = [];
+
+  for (const change of changes) {
+    const filePath = path.isAbsolute(change.file)
+      ? change.file
+      : path.resolve(basePath, change.file);
+
+    // All access through sandbox
+    if (!sandbox.exists(filePath)) {
+      results.push({ file: filePath, success: false, error: "File not found" });
+      continue;
+    }
+
+    const original = sandbox.readFile(filePath);
+
+    // Normalize line endings for matching
+    const normalizedOriginal = original.replace(/\r\n/g, "\n");
+    const normalizedOld = change.old.replace(/\r\n/g, "\n");
+
+    if (!normalizedOriginal.includes(normalizedOld)) {
+      results.push({
+        file: filePath,
+        success: false,
+        error: "Could not find the exact text to replace in the source file",
+      });
+      continue;
+    }
+
+    const patched = normalizedOriginal.replace(normalizedOld, change.new.replace(/\r\n/g, "\n"));
+    sandbox.writeFile(filePath, patched);
+
+    results.push({ file: filePath, success: true });
+  }
+
+  return results;
+}
+
+/**
+ * Rollback files from a backup entry using BackupManager.
+ */
+function rollbackFromBackup(backupManager, backupId) {
+  return backupManager.rollbackTo(backupId);
+}
+
+module.exports = { applyPatch, rollbackFromBackup };