wolverine-ai 1.0.0

package/src/index.js

@@ -0,0 +1,94 @@
+// Wolverine Node.js — Public API
+
+const { heal } = require("./core/wolverine");
+const { WolverineRunner } = require("./core/runner");
+const { requestRepair } = require("./core/ai-client");
+const { parseError } = require("./core/error-parser");
+const { getModel, getModelConfig, MODEL_ROLES } = require("./core/models");
+const { applyPatch } = require("./core/patcher");
+const { verifyFix } = require("./core/verifier");
+const { HealthMonitor } = require("./core/health-monitor");
+const { Sandbox, SandboxViolationError } = require("./security/sandbox");
+const { RateLimiter } = require("./security/rate-limiter");
+const { detectInjection } = require("./security/injection-detector");
+const { SecretRedactor } = require("./security/secret-redactor");
+const { AdminAuth } = require("./security/admin-auth");
+const { BackupManager } = require("./backup/backup-manager");
+const { EventLogger, EVENT_TYPES, SEVERITY } = require("./logger/event-logger");
+const { TokenTracker } = require("./logger/token-tracker");
+const { AgentEngine } = require("./agent/agent-engine");
+const { ResearchAgent } = require("./agent/research-agent");
+const { GoalLoop } = require("./agent/goal-loop");
+const { spawnAgent, spawnParallel, exploreAndFix } = require("./agent/sub-agents");
+const { McpRegistry } = require("./mcp/mcp-registry");
+const { McpSecurity } = require("./mcp/mcp-security");
+const { PerfMonitor } = require("./monitor/perf-monitor");
+const { DashboardServer } = require("./dashboard/server");
+const { Notifier } = require("./notifications/notifier");
+const { Brain } = require("./brain/brain");
+const { VectorStore } = require("./brain/vector-store");
+const { embed, embedBatch, compact } = require("./brain/embedder");
+const { scanProject } = require("./brain/function-map");
+const { detect: detectSystem } = require("./core/system-info");
+const { ClusterManager } = require("./core/cluster-manager");
+const { loadConfig, getConfig } = require("./core/config");
+const { sqlGuard, SafeDB, scanForInjection } = require("./skills/sql");
+
+module.exports = {
+  // Core
+  heal,
+  WolverineRunner,
+  requestRepair,
+  parseError,
+  applyPatch,
+  verifyFix,
+  HealthMonitor,
+  // Models
+  getModel,
+  getModelConfig,
+  MODEL_ROLES,
+  // Security
+  Sandbox,
+  SandboxViolationError,
+  RateLimiter,
+  detectInjection,
+  SecretRedactor,
+  AdminAuth,
+  // Backup
+  BackupManager,
+  // Logger
+  EventLogger,
+  EVENT_TYPES,
+  SEVERITY,
+  TokenTracker,
+  // Agent
+  AgentEngine,
+  ResearchAgent,
+  GoalLoop,
+  spawnAgent,
+  spawnParallel,
+  exploreAndFix,
+  McpRegistry,
+  McpSecurity,
+  // Monitor
+  PerfMonitor,
+  // Dashboard
+  DashboardServer,
+  // Notifications
+  Notifier,
+  // Brain
+  Brain,
+  VectorStore,
+  embed,
+  embedBatch,
+  compact,
+  scanProject,
+  detectSystem,
+  ClusterManager,
+  loadConfig,
+  getConfig,
+  // Skills
+  sqlGuard,
+  SafeDB,
+  scanForInjection,
+};

package/src/logger/event-logger.js

@@ -0,0 +1,237 @@
+const fs = require("fs");
+const path = require("path");
+const { EventEmitter } = require("events");
+
+/**
+ * Event Logger — central event bus and persistence layer for all wolverine activity.
+ *
+ * Every action wolverine takes is logged as a structured event:
+ * - Crashes, heals, rollbacks, verification results
+ * - Performance metrics, health checks
+ * - Agent actions (multi-file analysis, research, optimization)
+ * - Security events (injection attempts, sandbox violations)
+ *
+ * Events are:
+ * 1. Emitted live via EventEmitter (for dashboard SSE streaming)
+ * 2. Persisted to .wolverine/events/ as daily JSON files
+ * 3. Queryable by type, time range, severity
+ */
+
+const EVENT_TYPES = {
+  // Process lifecycle
+  PROCESS_START: "process.start",
+  PROCESS_CRASH: "process.crash",
+  PROCESS_HEALTHY: "process.healthy",
+  PROCESS_STOP: "process.stop",
+
+  // Healing pipeline
+  HEAL_START: "heal.start",
+  HEAL_PARSE: "heal.parse",
+  HEAL_INJECTION_SCAN: "heal.injection_scan",
+  HEAL_AI_REQUEST: "heal.ai_request",
+  HEAL_AI_RESPONSE: "heal.ai_response",
+  HEAL_PATCH_APPLIED: "heal.patch_applied",
+  HEAL_PATCH_FAILED: "heal.patch_failed",
+  HEAL_VERIFIED: "heal.verified",
+  HEAL_VERIFICATION_FAILED: "heal.verification_failed",
+  HEAL_ROLLBACK: "heal.rollback",
+  HEAL_SUCCESS: "heal.success",
+  HEAL_FAILED: "heal.failed",
+
+  // Agent activity
+  AGENT_TURN: "agent.turn",
+  AGENT_FILE_READ: "agent.file_read",
+  AGENT_FILE_WRITE: "agent.file_write",
+  AGENT_RESEARCH: "agent.research",
+  AGENT_COMPLETE: "agent.complete",
+
+  // Security
+  SECURITY_INJECTION_DETECTED: "security.injection_detected",
+  SECURITY_SANDBOX_VIOLATION: "security.sandbox_violation",
+  SECURITY_RATE_LIMITED: "security.rate_limited",
+
+  // Backup
+  BACKUP_CREATED: "backup.created",
+  BACKUP_VERIFIED: "backup.verified",
+  BACKUP_STABLE: "backup.stable",
+  BACKUP_ROLLBACK: "backup.rollback",
+  BACKUP_PRUNED: "backup.pruned",
+
+  // Performance monitoring
+  PERF_SLOW_ENDPOINT: "perf.slow_endpoint",
+  PERF_SPIKE_DETECTED: "perf.spike_detected",
+  PERF_ATTACK_DETECTED: "perf.attack_detected",
+  PERF_OPTIMIZATION: "perf.optimization",
+
+  // Notifications
+  NOTIFY_HUMAN_REQUIRED: "notify.human_required",
+
+  // Health checks
+  HEALTH_PASS: "health.pass",
+  HEALTH_FAIL: "health.fail",
+  HEALTH_UNRESPONSIVE: "health.unresponsive",
+};
+
+const SEVERITY = {
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error",
+  CRITICAL: "critical",
+};
+
+class EventLogger extends EventEmitter {
+  constructor(projectRoot) {
+    super();
+    this.projectRoot = path.resolve(projectRoot);
+    this.eventsDir = path.join(this.projectRoot, ".wolverine", "events");
+    this._ensureDir();
+
+    // In-memory ring buffer for recent events (dashboard queries)
+    this._recentEvents = [];
+    this._maxRecent = 1000;
+
+    // Secret redactor — if set, all events get redacted before persist/emit
+    this.redactor = null;
+
+    // Session tracking
+    this.sessionId = Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 6);
+    this.sessionStart = Date.now();
+    this._eventCount = 0;
+  }
+
+  /**
+   * Attach a SecretRedactor. All events will be redacted before storage/emit.
+   */
+  setRedactor(redactor) {
+    this.redactor = redactor;
+  }
+
+  /**
+   * Log an event. This is the primary API.
+   *
+   * @param {string} type - One of EVENT_TYPES
+   * @param {string} severity - One of SEVERITY
+   * @param {string} message - Human-readable description
+   * @param {object} data - Structured metadata
+   */
+  log(type, severity, message, data = {}) {
+    // Redact secrets before they hit storage or the wire
+    const safeMessage = this.redactor ? this.redactor.redact(message) : message;
+    const safeData = this.redactor ? this.redactor.redactObject(data) : data;
+
+    const event = {
+      id: `${this.sessionId}-${(++this._eventCount).toString(36)}`,
+      type,
+      severity,
+      message: safeMessage,
+      data: safeData,
+      timestamp: Date.now(),
+      iso: new Date().toISOString(),
+      sessionId: this.sessionId,
+    };
+
+    // In-memory ring buffer
+    this._recentEvents.push(event);
+    if (this._recentEvents.length > this._maxRecent) {
+      this._recentEvents.shift();
+    }
+
+    // Persist to daily file
+    this._persist(event);
+
+    // Emit for live streaming (dashboard SSE)
+    this.emit("event", event);
+
+    return event;
+  }
+
+  // Convenience methods
+  info(type, message, data) { return this.log(type, SEVERITY.INFO, message, data); }
+  warn(type, message, data) { return this.log(type, SEVERITY.WARN, message, data); }
+  error(type, message, data) { return this.log(type, SEVERITY.ERROR, message, data); }
+  critical(type, message, data) { return this.log(type, SEVERITY.CRITICAL, message, data); }
+  debug(type, message, data) { return this.log(type, SEVERITY.DEBUG, message, data); }
+
+  /**
+   * Query recent events by type and/or severity.
+   */
+  query({ type, severity, limit = 100, since } = {}) {
+    let results = this._recentEvents;
+
+    if (type) {
+      results = results.filter(e => e.type === type || e.type.startsWith(type + "."));
+    }
+    if (severity) {
+      results = results.filter(e => e.severity === severity);
+    }
+    if (since) {
+      results = results.filter(e => e.timestamp >= since);
+    }
+
+    return results.slice(-limit);
+  }
+
+  /**
+   * Get summary stats for the current session.
+   */
+  getSessionStats() {
+    const counts = {};
+    for (const event of this._recentEvents) {
+      const category = event.type.split(".")[0];
+      counts[category] = (counts[category] || 0) + 1;
+    }
+
+    const errors = this._recentEvents.filter(e => e.severity === SEVERITY.ERROR || e.severity === SEVERITY.CRITICAL);
+    const heals = this._recentEvents.filter(e => e.type === EVENT_TYPES.HEAL_SUCCESS);
+    const rollbacks = this._recentEvents.filter(e => e.type === EVENT_TYPES.HEAL_ROLLBACK);
+
+    return {
+      sessionId: this.sessionId,
+      uptime: Date.now() - this.sessionStart,
+      totalEvents: this._eventCount,
+      categories: counts,
+      errors: errors.length,
+      heals: heals.length,
+      rollbacks: rollbacks.length,
+    };
+  }
+
+  /**
+   * Load events from a specific date's log file.
+   */
+  loadDay(dateStr) {
+    const filePath = path.join(this.eventsDir, `${dateStr}.jsonl`);
+    if (!fs.existsSync(filePath)) return [];
+
+    const lines = fs.readFileSync(filePath, "utf-8").trim().split("\n");
+    return lines.filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  }
+
+  /**
+   * Get all available log dates.
+   */
+  getAvailableDates() {
+    if (!fs.existsSync(this.eventsDir)) return [];
+    return fs.readdirSync(this.eventsDir)
+      .filter(f => f.endsWith(".jsonl"))
+      .map(f => f.replace(".jsonl", ""))
+      .sort();
+  }
+
+  // -- Private --
+
+  _ensureDir() {
+    fs.mkdirSync(this.eventsDir, { recursive: true });
+  }
+
+  _persist(event) {
+    const dateStr = new Date(event.timestamp).toISOString().slice(0, 10);
+    const filePath = path.join(this.eventsDir, `${dateStr}.jsonl`);
+    fs.appendFileSync(filePath, JSON.stringify(event) + "\n", "utf-8");
+  }
+}
+
+module.exports = { EventLogger, EVENT_TYPES, SEVERITY };

package/src/logger/pricing.js

@@ -0,0 +1,96 @@
+/**
+ * Model Pricing — maps model names to per-million-token costs.
+ *
+ * Users can override in .wolverine/pricing.json. Defaults based on
+ * OpenAI published pricing as of April 2026.
+ *
+ * All values are USD per 1 million tokens.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_PRICING = {
+  // GPT-5.4 family
+  "gpt-5.4":        { input: 2.50,  output: 15.00 },
+  "gpt-5.4-mini":   { input: 0.75,  output: 4.50 },
+  "gpt-5.4-nano":   { input: 0.20,  output: 1.25 },
+
+  // GPT-5 family (estimated from 5.4 pricing)
+  "gpt-5-nano":     { input: 0.15,  output: 1.00 },
+
+  // GPT-4o family
+  "gpt-4o":         { input: 2.50,  output: 10.00 },
+  "gpt-4o-mini":    { input: 0.15,  output: 0.60 },
+
+  // O-series reasoning
+  "o4-mini":                { input: 1.10,  output: 4.40 },
+  "o4-mini-deep-research":  { input: 2.00,  output: 8.00 },
+
+  // Codex
+  "gpt-5.1-codex-mini":    { input: 1.50,  output: 6.00 },
+  "codex-mini-latest":      { input: 1.50,  output: 6.00 },
+  "gpt-5.3-codex":         { input: 2.50,  output: 10.00 },
+
+  // Embeddings
+  "text-embedding-3-small": { input: 0.02,  output: 0.00 },
+  "text-embedding-3-large": { input: 0.13,  output: 0.00 },
+
+  // Fallback for unknown models
+  "_default":               { input: 1.00,  output: 4.00 },
+};
+
+let _customPricing = null;
+
+/**
+ * Get pricing for a model. Checks custom overrides first, then defaults.
+ * Returns { input, output } in USD per million tokens.
+ */
+function getModelPricing(modelName) {
+  // Check custom pricing
+  if (_customPricing && _customPricing[modelName]) {
+    return _customPricing[modelName];
+  }
+
+  // Check defaults — try exact match, then prefix match
+  if (DEFAULT_PRICING[modelName]) {
+    return DEFAULT_PRICING[modelName];
+  }
+
+  // Prefix matching: "gpt-5.4-mini-2026-03" → "gpt-5.4-mini"
+  for (const [key, val] of Object.entries(DEFAULT_PRICING)) {
+    if (key !== "_default" && modelName.startsWith(key)) {
+      return val;
+    }
+  }
+
+  return DEFAULT_PRICING._default;
+}
+
+/**
+ * Calculate cost in USD for a given model and token counts.
+ */
+function calculateCost(modelName, inputTokens, outputTokens) {
+  const pricing = getModelPricing(modelName);
+  const inputCost = (inputTokens / 1_000_000) * pricing.input;
+  const outputCost = (outputTokens / 1_000_000) * pricing.output;
+  return {
+    input: inputCost,
+    output: outputCost,
+    total: inputCost + outputCost,
+  };
+}
+
+/**
+ * Load custom pricing overrides from .wolverine/pricing.json.
+ */
+function loadCustomPricing(projectRoot) {
+  const pricingPath = path.join(projectRoot, ".wolverine", "pricing.json");
+  if (fs.existsSync(pricingPath)) {
+    try {
+      _customPricing = JSON.parse(fs.readFileSync(pricingPath, "utf-8"));
+    } catch {}
+  }
+}
+
+module.exports = { getModelPricing, calculateCost, loadCustomPricing, DEFAULT_PRICING };

package/src/logger/repair-history.js

@@ -0,0 +1,109 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Repair History — dedicated log of every error + resolution + cost.
+ *
+ * Separate from the general event log — this is a structured repair audit trail.
+ * Each entry tracks: what broke, what fixed it, how many tokens it cost, which model.
+ *
+ * Persisted to .wolverine/repair-history.json
+ */
+
+const HISTORY_FILE = ".wolverine/repair-history.json";
+
+class RepairHistory {
+  constructor(projectRoot) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.historyPath = path.join(this.projectRoot, HISTORY_FILE);
+    this._repairs = [];
+    this._load();
+  }
+
+  /**
+   * Record a repair attempt.
+   */
+  record({
+    error,         // error message
+    file,          // file that crashed
+    line,          // line number
+    resolution,    // what was done to fix it
+    success,       // boolean
+    mode,          // "fast" | "agent" | "research"
+    model,         // which model fixed it
+    tokens,        // total tokens used
+    cost,          // USD cost
+    iteration,     // which goal loop iteration
+    duration,      // ms from crash to fix
+    filesModified, // files changed
+  }) {
+    const entry = {
+      id: Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 4),
+      timestamp: Date.now(),
+      iso: new Date().toISOString(),
+      error: (error || "").slice(0, 200),
+      file,
+      line,
+      resolution: (resolution || "").slice(0, 300),
+      success,
+      mode,
+      model,
+      tokens: tokens || 0,
+      cost: Math.round((cost || 0) * 1000000) / 1000000,
+      iteration: iteration || 1,
+      duration: duration || 0,
+      filesModified: filesModified || [],
+    };
+
+    this._repairs.push(entry);
+    this._save();
+    return entry;
+  }
+
+  /**
+   * Get all repair entries.
+   */
+  getAll() {
+    return this._repairs;
+  }
+
+  /**
+   * Get summary stats.
+   */
+  getStats() {
+    const total = this._repairs.length;
+    const successes = this._repairs.filter(r => r.success).length;
+    const failures = total - successes;
+    const totalTokens = this._repairs.reduce((sum, r) => sum + (r.tokens || 0), 0);
+    const totalCost = this._repairs.reduce((sum, r) => sum + (r.cost || 0), 0);
+    const avgTokensPerRepair = total > 0 ? Math.round(totalTokens / total) : 0;
+
+    return {
+      total,
+      successes,
+      failures,
+      successRate: total > 0 ? Math.round((successes / total) * 100) : 0,
+      totalTokens,
+      totalCost: Math.round(totalCost * 10000) / 10000,
+      avgTokensPerRepair,
+    };
+  }
+
+  _load() {
+    if (!fs.existsSync(this.historyPath)) return;
+    try {
+      this._repairs = JSON.parse(fs.readFileSync(this.historyPath, "utf-8"));
+    } catch { this._repairs = []; }
+  }
+
+  _save() {
+    try {
+      fs.mkdirSync(path.dirname(this.historyPath), { recursive: true });
+      const tmp = this.historyPath + ".tmp";
+      fs.writeFileSync(tmp, JSON.stringify(this._repairs, null, 2), "utf-8");
+      fs.renameSync(tmp, this.historyPath);
+    } catch {}
+  }
+}
+
+module.exports = { RepairHistory };