wolverine-ai 1.0.0

package/src/core/ai-client.js

@@ -0,0 +1,387 @@
+const OpenAI = require("openai");
+const { getModel } = require("./models");
+
+let client = null;
+let _tracker = null;
+
+/**
+ * Set the global token tracker. Called once from runner on startup.
+ */
+function setTokenTracker(tracker) { _tracker = tracker; }
+
+/**
+ * Extract token counts from any OpenAI response usage object.
+ */
+function _extractTokens(usage) {
+  if (!usage) return { input: 0, output: 0 };
+  return {
+    input: usage.prompt_tokens || usage.input_tokens || 0,
+    output: usage.completion_tokens || usage.output_tokens || 0,
+  };
+}
+
+/**
+ * Track a call if tracker is set.
+ */
+function _track(model, category, usage, tool) {
+  if (!_tracker) return;
+  const { input, output } = _extractTokens(usage);
+  _tracker.record(model, category, input, output, tool);
+}
+
+function getClient() {
+  if (!client) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "OPENAI_API_KEY is not set. Add it to .env.local or set it as an environment variable."
+      );
+    }
+    client = new OpenAI({ apiKey });
+  }
+  return client;
+}
+
+/**
+ * Detect if a model uses the Responses API vs Chat Completions.
+ * Codex models and some newer models use /v1/responses.
+ */
+function isResponsesModel(model) {
+  return /codex/i.test(model);
+}
+
+/**
+ * Detect if a model uses internal reasoning tokens (o-series, gpt-5-nano, etc.)
+ * These models need higher token limits because reasoning consumes most of the budget.
+ */
+function isReasoningModel(model) {
+  return /^o[1-9]|^gpt-5-nano|^gpt-5\.4-nano/.test(model);
+}
+
+/**
+ * Build the token limit param for Chat Completions API.
+ * Reasoning models get 4x the limit to accommodate thinking tokens.
+ */
+function tokenParam(model, limit) {
+  // Reasoning models need headroom for chain-of-thought
+  const effectiveLimit = isReasoningModel(model) ? Math.max(limit * 4, 4096) : limit;
+
+  if (isResponsesModel(model)) {
+    return { max_output_tokens: effectiveLimit };
+  }
+  const usesNewParam = /^(o[1-9]|gpt-5|gpt-4o)/.test(model) || model.includes("nano");
+  if (usesNewParam) {
+    return { max_completion_tokens: effectiveLimit };
+  }
+  return { max_tokens: limit };
+}
+
+/**
+ * Unified AI call — automatically routes to Responses API or Chat Completions
+ * based on the model name.
+ *
+ * @param {object} params
+ * @param {string} params.model - Model name
+ * @param {string} params.systemPrompt - System/instructions prompt
+ * @param {string} params.userPrompt - User message
+ * @param {number} params.maxTokens - Max response tokens
+ * @param {Array}  params.tools - Tool definitions (optional)
+ * @param {string} params.toolChoice - Tool choice strategy (optional)
+ * @returns {{ content: string, toolCalls: Array|null, usage: object }}
+ */
+async function aiCall({ model, systemPrompt, userPrompt, maxTokens = 2048, tools, toolChoice, category = "chat", tool }) {
+  const openai = getClient();
+
+  let result;
+  if (isResponsesModel(model)) {
+    result = await _responsesCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools });
+  } else {
+    result = await _chatCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice });
+  }
+
+  _track(model, category, result.usage, tool);
+  return result;
+}
+
+/**
+ * Responses API call — for codex and responses-only models.
+ */
+async function _responsesCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools }) {
+  const params = {
+    model,
+    input: [
+      ...(systemPrompt ? [{ role: "developer", content: systemPrompt }] : []),
+      { role: "user", content: userPrompt },
+    ],
+    max_output_tokens: maxTokens,
+  };
+
+  // Convert chat-style tools to responses-style tools
+  if (tools && tools.length > 0) {
+    params.tools = tools.map(t => {
+      if (t.type === "function" && t.function) {
+        // Chat Completions style → Responses style
+        return {
+          type: "function",
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters,
+          strict: true,
+        };
+      }
+      return t;
+    });
+  }
+
+  const response = await openai.responses.create(params);
+
+  // Extract text content and tool calls from response output
+  let content = "";
+  let toolCalls = null;
+
+  if (response.output) {
+    for (const item of response.output) {
+      if (item.type === "message" && item.content) {
+        for (const block of item.content) {
+          if (block.type === "output_text") {
+            content += block.text;
+          }
+        }
+      } else if (item.type === "function_call") {
+        if (!toolCalls) toolCalls = [];
+        toolCalls.push({
+          id: item.call_id || item.id,
+          type: "function",
+          function: {
+            name: item.name,
+            arguments: item.arguments,
+          },
+        });
+      }
+    }
+  }
+
+  // Fallback: some responses have output_text directly
+  if (!content && response.output_text) {
+    content = response.output_text;
+  }
+
+  return {
+    content: content.trim(),
+    toolCalls,
+    usage: response.usage || {},
+    _raw: response,
+  };
+}
+
+/**
+ * Chat Completions API call — for standard chat models.
+ */
+async function _chatCall(openai, { model, systemPrompt, userPrompt, maxTokens, tools, toolChoice }) {
+  const messages = [];
+  if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+  messages.push({ role: "user", content: userPrompt });
+
+  // Some models (gpt-5-nano, o-series) don't support temperature
+  const noTemp = /^(o[1-9]|gpt-5)/.test(model);
+
+  const params = {
+    model,
+    messages,
+    ...(!noTemp ? { temperature: 0 } : {}),
+    ...tokenParam(model, maxTokens),
+  };
+
+  if (tools && tools.length > 0) {
+    params.tools = tools;
+    params.tool_choice = toolChoice || "auto";
+  }
+
+  const response = await openai.chat.completions.create(params);
+  const choice = response.choices[0];
+
+  return {
+    content: (choice.message.content || "").trim(),
+    toolCalls: choice.message.tool_calls || null,
+    usage: response.usage || {},
+    _raw: response,
+    _message: choice.message,
+  };
+}
+
+/**
+ * Build a Responses API conversation continuation with tool results.
+ * For multi-turn agent loops with codex models.
+ */
+async function aiCallWithHistory({ model, messages, tools, maxTokens = 4096, category = "chat", tool }) {
+  const openai = getClient();
+
+  let result;
+  if (isResponsesModel(model)) {
+    result = await _responsesCallWithHistory(openai, { model, messages, tools, maxTokens });
+  } else {
+    result = await _chatCallWithHistory(openai, { model, messages, tools, maxTokens });
+  }
+
+  _track(model, category, result.usage, tool);
+  return result;
+}
+
+async function _responsesCallWithHistory(openai, { model, messages, tools, maxTokens }) {
+  // Convert chat-style messages to responses input format
+  const input = messages.map(msg => {
+    if (msg.role === "system") {
+      return { role: "developer", content: msg.content };
+    }
+    if (msg.role === "tool") {
+      return {
+        type: "function_call_output",
+        call_id: msg.tool_call_id,
+        output: msg.content,
+      };
+    }
+    if (msg.role === "assistant" && msg.tool_calls) {
+      // Emit function_call items for each tool call
+      return msg.tool_calls.map(tc => ({
+        type: "function_call",
+        call_id: tc.id,
+        name: tc.function.name,
+        arguments: tc.function.arguments,
+      }));
+    }
+    if (msg.role === "assistant") {
+      return { role: "assistant", content: msg.content || "" };
+    }
+    return { role: msg.role, content: msg.content };
+  }).flat();
+
+  const params = {
+    model,
+    input,
+    max_output_tokens: maxTokens,
+  };
+
+  if (tools && tools.length > 0) {
+    params.tools = tools.map(t => {
+      if (t.type === "function" && t.function) {
+        return {
+          type: "function",
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters,
+          strict: true,
+        };
+      }
+      return t;
+    });
+  }
+
+  const response = await openai.responses.create(params);
+
+  // Build a chat-compatible response
+  let content = "";
+  let toolCalls = null;
+
+  if (response.output) {
+    for (const item of response.output) {
+      if (item.type === "message" && item.content) {
+        for (const block of item.content) {
+          if (block.type === "output_text") content += block.text;
+        }
+      } else if (item.type === "function_call") {
+        if (!toolCalls) toolCalls = [];
+        toolCalls.push({
+          id: item.call_id || item.id,
+          type: "function",
+          function: {
+            name: item.name,
+            arguments: item.arguments,
+          },
+        });
+      }
+    }
+  }
+
+  if (!content && response.output_text) content = response.output_text;
+
+  // Return in chat-compatible format so the agent engine doesn't need to change
+  const message = { role: "assistant", content: content.trim() || null };
+  if (toolCalls) message.tool_calls = toolCalls;
+
+  return {
+    choices: [{ message }],
+    usage: response.usage || {},
+  };
+}
+
+async function _chatCallWithHistory(openai, { model, messages, tools, maxTokens }) {
+  const noTemp = /^(o[1-9]|gpt-5)/.test(model);
+  const params = {
+    model,
+    messages,
+    ...(!noTemp ? { temperature: 0 } : {}),
+    ...tokenParam(model, maxTokens),
+  };
+
+  if (tools && tools.length > 0) {
+    params.tools = tools;
+    params.tool_choice = "auto";
+  }
+
+  return openai.chat.completions.create(params);
+}
+
+/**
+ * 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 }) {
+  const model = getModel("coding");
+
+  const systemPrompt = "You are a Node.js debugging expert. Respond with ONLY valid JSON, no markdown fences.";
+  const userPrompt = `A server crashed with the following error. Analyze and produce a fix.
+
+## File: ${filePath}
+
+\`\`\`javascript
+${sourceCode}
+\`\`\`
+
+## Error Message
+\`\`\`
+${errorMessage}
+\`\`\`
+
+## Stack Trace
+\`\`\`
+${stackTrace}
+\`\`\`
+
+## Instructions
+1. Identify the root cause of the error.
+2. Produce a minimal fix — change only what is necessary.
+3. Respond with ONLY valid JSON in this exact format:
+
+{
+  "explanation": "Brief explanation of what went wrong and what the fix does",
+  "changes": [
+    {
+      "file": "the file path",
+      "old": "the exact lines to replace (copy verbatim from the source)",
+      "new": "the replacement lines"
+    }
+  ]
+}`;
+
+  const result = await aiCall({ model, systemPrompt, userPrompt, maxTokens: 2048, category: "heal" });
+  const content = result.content;
+  const cleaned = content.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+
+  try {
+    return JSON.parse(cleaned);
+  } catch (parseErr) {
+    throw new Error(`Failed to parse AI response as JSON.\nRaw response:\n${content}`);
+  }
+}
+
+module.exports = { requestRepair, getClient, tokenParam, aiCall, aiCallWithHistory, isResponsesModel, setTokenTracker };

package/src/core/cluster-manager.js

@@ -0,0 +1,144 @@
+const cluster = require("cluster");
+const path = require("path");
+const chalk = require("chalk");
+const { detect, logSystemInfo } = require("./system-info");
+
+/**
+ * Cluster Manager — auto-scaling worker management.
+ *
+ * Detects machine capabilities and forks the optimal number of workers.
+ * Each worker runs a wolverine instance managing the server process.
+ * The master manages workers, restarts crashed ones, and balances load.
+ *
+ * Modes:
+ * - single:  1 worker (small machines, dev, containers)
+ * - auto:    detect cores → fork optimal workers
+ * - fixed:   user specifies exact worker count
+ *
+ * Load balancing uses Node's built-in round-robin (default on Linux)
+ * or OS-level distribution (Windows).
+ */
+
+class ClusterManager {
+  constructor(options = {}) {
+    this.scriptPath = options.scriptPath;
+    this.mode = options.mode || "auto";       // single, auto, fixed
+    this.fixedWorkers = options.workers || 0;
+    this.logger = options.logger;
+
+    this._systemInfo = null;
+    this._workerCount = 0;
+    this._workers = new Map();  // pid → { id, startTime, restarts }
+    this._shuttingDown = false;
+  }
+
+  /**
+   * Initialize — detect system, decide worker count, fork if needed.
+   * Returns true if this process is the master, false if it's a worker.
+   */
+  init() {
+    this._systemInfo = detect();
+
+    if (this.mode === "single" || !cluster.isPrimary) {
+      return { isMaster: cluster.isPrimary, workers: 1, systemInfo: this._systemInfo };
+    }
+
+    // Determine worker count
+    if (this.mode === "fixed" && this.fixedWorkers > 0) {
+      this._workerCount = this.fixedWorkers;
+    } else {
+      this._workerCount = this._systemInfo.recommended.workers;
+    }
+
+    // Single core / small machine — don't cluster
+    if (this._workerCount <= 1) {
+      return { isMaster: true, workers: 1, systemInfo: this._systemInfo, clustered: false };
+    }
+
+    console.log(chalk.blue.bold("\n  🔄 Cluster Mode"));
+    logSystemInfo(this._systemInfo);
+    console.log(chalk.blue(`  🔄 Forking ${this._workerCount} workers...\n`));
+
+    // Fork workers
+    for (let i = 0; i < this._workerCount; i++) {
+      this._forkWorker();
+    }
+
+    // Handle worker exits
+    cluster.on("exit", (worker, code, signal) => {
+      if (this._shuttingDown) return;
+
+      const info = this._workers.get(worker.process.pid);
+      const restarts = info ? info.restarts : 0;
+
+      console.log(chalk.yellow(`  🔄 Worker ${worker.process.pid} died (code: ${code}, signal: ${signal})`));
+
+      if (this.logger) {
+        this.logger.warn("cluster.worker_died", `Worker ${worker.process.pid} died`, {
+          pid: worker.process.pid, code, signal, restarts,
+        });
+      }
+
+      this._workers.delete(worker.process.pid);
+
+      // Respawn with backoff if crashing repeatedly
+      if (restarts < 5) {
+        const delay = Math.min(1000 * Math.pow(2, restarts), 30000);
+        console.log(chalk.gray(`  🔄 Respawning in ${delay / 1000}s (restart #${restarts + 1})`));
+        setTimeout(() => this._forkWorker(restarts + 1), delay);
+      } else {
+        console.log(chalk.red(`  🔄 Worker exceeded max restarts (5) — not respawning`));
+      }
+    });
+
+    // Graceful shutdown
+    const shutdown = () => {
+      this._shuttingDown = true;
+      console.log(chalk.yellow("\n  🔄 Shutting down cluster..."));
+      for (const [pid] of this._workers) {
+        try { process.kill(pid, "SIGTERM"); } catch {}
+      }
+      setTimeout(() => process.exit(0), 5000);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+
+    return { isMaster: true, workers: this._workerCount, systemInfo: this._systemInfo, clustered: true };
+  }
+
+  /**
+   * Get cluster status for dashboard.
+   */
+  getStatus() {
+    return {
+      clustered: this._workerCount > 1,
+      mode: this.mode,
+      totalWorkers: this._workerCount,
+      activeWorkers: this._workers.size,
+      workers: Array.from(this._workers.entries()).map(([pid, info]) => ({
+        pid,
+        id: info.id,
+        uptime: Math.round((Date.now() - info.startTime) / 1000),
+        restarts: info.restarts,
+      })),
+      system: this._systemInfo,
+    };
+  }
+
+  _forkWorker(restarts = 0) {
+    const worker = cluster.fork({
+      WOLVERINE_WORKER_ID: this._workers.size + 1,
+    });
+
+    this._workers.set(worker.process.pid, {
+      id: this._workers.size + 1,
+      startTime: Date.now(),
+      restarts,
+    });
+
+    console.log(chalk.green(`  🔄 Worker ${worker.process.pid} started`));
+  }
+}
+
+module.exports = { ClusterManager };

package/src/core/config.js

@@ -0,0 +1,89 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Config Loader — reads wolverine.config.js, falls back to env vars.
+ *
+ * Priority:
+ * 1. Environment variables (highest — for CI/Docker overrides)
+ * 2. wolverine.config.js (project settings)
+ * 3. Hardcoded defaults (lowest)
+ */
+
+let _config = null;
+
+function loadConfig() {
+  if (_config) return _config;
+
+  // Load from server/config/settings.json
+  const configPath = path.join(process.cwd(), "server", "config", "settings.json");
+  let fileConfig = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      fileConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch (err) {
+      console.log(`  ⚠️  Failed to load server/config/settings.json: ${err.message}`);
+    }
+  }
+
+  _config = {
+    models: {
+      reasoning:  process.env.REASONING_MODEL    || fileConfig.models?.reasoning  || "gpt-4o",
+      coding:     process.env.CODING_MODEL       || fileConfig.models?.coding     || "gpt-4o",
+      chat:       process.env.CHAT_MODEL         || fileConfig.models?.chat       || "gpt-4o-mini",
+      tool:       process.env.TOOL_MODEL         || fileConfig.models?.tool       || "gpt-4o-mini",
+      classifier: process.env.CLASSIFIER_MODEL   || fileConfig.models?.classifier || "gpt-4o-mini",
+      audit:      process.env.AUDIT_MODEL        || fileConfig.models?.audit      || "gpt-4o-mini",
+      compacting: process.env.COMPACTING_MODEL   || fileConfig.models?.compacting || "gpt-4o-mini",
+      research:   process.env.RESEARCH_MODEL     || fileConfig.models?.research   || "gpt-4o",
+      embedding:  process.env.TEXT_EMBEDDING_MODEL || fileConfig.models?.embedding || "text-embedding-3-small",
+    },
+
+    server: {
+      port:        parseInt(process.env.PORT, 10)                    || fileConfig.server?.port        || 3000,
+      maxRetries:  parseInt(process.env.WOLVERINE_MAX_RETRIES, 10)   || fileConfig.server?.maxRetries  || 3,
+      maxMemoryMB: parseInt(process.env.WOLVERINE_MAX_MEMORY_MB, 10) || fileConfig.server?.maxMemoryMB || 512,
+    },
+
+    telemetry: {
+      enabled:            process.env.WOLVERINE_TELEMETRY !== "false" && (fileConfig.telemetry?.enabled !== false),
+      heartbeatIntervalMs: parseInt(process.env.WOLVERINE_HEARTBEAT_INTERVAL_MS, 10) || fileConfig.telemetry?.heartbeatIntervalMs || 60000,
+      platformUrl:        process.env.WOLVERINE_PLATFORM_URL || fileConfig.telemetry?.platformUrl || "https://api.wolverinenode.xyz",
+    },
+
+    rateLimiting: {
+      maxCallsPerWindow: parseInt(process.env.WOLVERINE_RATE_MAX_CALLS, 10)       || fileConfig.rateLimiting?.maxCallsPerWindow || 10,
+      windowMs:          parseInt(process.env.WOLVERINE_RATE_WINDOW_MS, 10)        || fileConfig.rateLimiting?.windowMs          || 600000,
+      minGapMs:          parseInt(process.env.WOLVERINE_RATE_MIN_GAP_MS, 10)       || fileConfig.rateLimiting?.minGapMs          || 5000,
+      maxTokensPerHour:  parseInt(process.env.WOLVERINE_RATE_MAX_TOKENS_HOUR, 10)  || fileConfig.rateLimiting?.maxTokensPerHour  || 100000,
+    },
+
+    healthCheck: {
+      intervalMs:   parseInt(process.env.WOLVERINE_HEALTH_INTERVAL_MS, 10)      || fileConfig.healthCheck?.intervalMs   || 15000,
+      timeoutMs:    parseInt(process.env.WOLVERINE_HEALTH_TIMEOUT_MS, 10)       || fileConfig.healthCheck?.timeoutMs    || 5000,
+      failThreshold: parseInt(process.env.WOLVERINE_HEALTH_FAIL_THRESHOLD, 10)  || fileConfig.healthCheck?.failThreshold || 3,
+      startDelayMs: parseInt(process.env.WOLVERINE_HEALTH_START_DELAY_MS, 10)   || fileConfig.healthCheck?.startDelayMs || 10000,
+    },
+
+    dashboard: {
+      port: parseInt(process.env.WOLVERINE_DASHBOARD_PORT, 10) || fileConfig.dashboard?.port || null,
+    },
+  };
+
+  return _config;
+}
+
+/**
+ * Get a config value by dot path: getConfig("models.reasoning")
+ */
+function getConfig(dotPath) {
+  const config = loadConfig();
+  return dotPath.split(".").reduce((obj, key) => obj?.[key], config);
+}
+
+/**
+ * Reset config cache (for testing).
+ */
+function resetConfig() { _config = null; }
+
+module.exports = { loadConfig, getConfig, resetConfig };

package/src/core/error-parser.js

@@ -0,0 +1,87 @@
+const path = require("path");
+
+/**
+ * Parse a Node.js error/stack trace string and extract the relevant file + line info.
+ * Returns { filePath, line, column, errorMessage, stackTrace }
+ */
+function parseError(stderr) {
+  const lines = stderr.split("\n").map(l => l.replace(/\r$/, ""));
+
+  // Find the error message line (usually contains "Error:" or "TypeError:" etc.)
+  let errorMessage = "";
+  let stackTrace = stderr;
+
+  for (const line of lines) {
+    if (/^\w*Error:/.test(line.trim()) || /^\w*TypeError:/.test(line.trim())) {
+      errorMessage = line.trim();
+      break;
+    }
+  }
+
+  if (!errorMessage) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("at ")) {
+        errorMessage = trimmed;
+      }
+    }
+  }
+
+  let filePath = null;
+  let line = null;
+  let column = null;
+
+  // 1. First line of stderr — Node prints "filepath.js:line" for syntax/reference errors
+  const firstLineMatch = lines[0] && lines[0].match(/^(.+\.[a-zA-Z]+):(\d+)$/);
+  if (firstLineMatch) {
+    filePath = firstLineMatch[1];
+    line = parseInt(firstLineMatch[2], 10);
+  }
+
+  // 2. Try to find a user-land file in the stack trace (not node_modules, not node: internal)
+  const stackFrames = stderr.match(/at\s+.+\(.+:\d+:\d+\)/g) || [];
+  let foundUserFile = false;
+  for (const stackLine of stackFrames) {
+    const match = stackLine.match(/\(([^)]+):(\d+):(\d+)\)/);
+    if (match) {
+      const candidate = match[1];
+      if (!candidate.includes("node_modules") &&
+          !candidate.includes("node:") &&
+          !candidate.startsWith("internal/")) {
+        filePath = candidate;
+        line = parseInt(match[2], 10);
+        column = parseInt(match[3], 10);
+        foundUserFile = true;
+        break;
+      }
+    }
+  }
+
+  // 3. If no user-land file in stack, try the generic stack trace patterns
+  //    BUT only if we didn't already have a file from the first line
+  if (!foundUserFile && !filePath) {
+    const fileMatch = stderr.match(/\(([^)]+):(\d+):(\d+)\)/) ||
+                      stderr.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+    if (fileMatch) {
+      filePath = fileMatch[1];
+      line = parseInt(fileMatch[2], 10);
+      column = parseInt(fileMatch[3], 10);
+    }
+  }
+
+  // Normalize Git Bash paths on Windows: /c/Users/... → C:/Users/...
+  if (filePath) {
+    filePath = filePath.replace(/^\/([a-zA-Z])\//, "$1:/");
+    filePath = path.resolve(filePath);
+  }
+
+  return {
+    filePath,
+    line,
+    column,
+    errorMessage,
+    stackTrace,
+  };
+}
+
+module.exports = { parseError };