wolverine-ai 6.1.2 → 6.2.1

package/wolverine-claw/index.js

@@ -0,0 +1,322 @@
+/**
+ * Wolverine Claw — OpenClaw agentic agent with Wolverine self-healing.
+ *
+ * This is the entry point for the claw environment. It bootstraps the OpenClaw
+ * gateway and Pi agent runtime, wrapped by Wolverine's process manager for
+ * automatic crash recovery, healing, and workspace backup.
+ *
+ * Usage:
+ *   node bin/wolverine-claw.js              (under wolverine healing)
+ *   node wolverine-claw/index.js            (direct, no healing)
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+// Load claw-specific config
+function loadClawConfig() {
+  const configPath = path.join(__dirname, "config", "settings.json");
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    // Strip comment keys (keys starting with _)
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch (err) {
+    console.error(`[CLAW] Failed to load config: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+const config = loadClawConfig();
+
+// Gateway state
+let gateway = null;
+let shutdownCalled = false;
+
+/**
+ * Start the OpenClaw gateway with wolverine integration.
+ */
+async function start() {
+  const gatewayPort = config.gateway?.port || 18789;
+  const gatewayHost = config.gateway?.host || "127.0.0.1";
+
+  console.log(`[CLAW] Starting Wolverine Claw...`);
+  console.log(`[CLAW] Gateway: ws://${gatewayHost}:${gatewayPort}`);
+  console.log(`[CLAW] Workspace: ${path.resolve(config.workspace?.path || "wolverine-claw/workspace")}`);
+
+  // Ensure workspace directory exists
+  const workspacePath = path.resolve(config.workspace?.path || "wolverine-claw/workspace");
+  if (!fs.existsSync(workspacePath)) {
+    fs.mkdirSync(workspacePath, { recursive: true });
+  }
+
+  try {
+    // Try to use openclaw as npm dependency
+    const openclaw = require("openclaw");
+
+    // Configure OpenClaw with our settings
+    const clawConfig = {
+      gateway: {
+        port: gatewayPort,
+        host: gatewayHost,
+      },
+      agent: {
+        model: config.agent?.model || config.models?.coding || "claude-sonnet-4-6",
+        maxTurns: config.agent?.maxTurns || 25,
+      },
+      channels: buildChannelConfig(config.channels),
+      skills: config.skills || {},
+      security: config.security || {},
+    };
+
+    // Start gateway via openclaw SDK
+    if (openclaw.createGateway) {
+      gateway = await openclaw.createGateway(clawConfig);
+      await gateway.start();
+    } else if (openclaw.Gateway) {
+      gateway = new openclaw.Gateway(clawConfig);
+      await gateway.start();
+    } else if (openclaw.start) {
+      gateway = await openclaw.start(clawConfig);
+    } else {
+      // Fallback: spawn openclaw CLI as child process
+      console.log("[CLAW] OpenClaw SDK API not found, falling back to CLI mode...");
+      await startClawCLI(gatewayPort, gatewayHost);
+      return;
+    }
+
+    console.log(`[CLAW] Gateway running on ws://${gatewayHost}:${gatewayPort}`);
+
+    // Register wolverine integration plugin
+    await registerWolverinePlugin(gateway);
+
+    // Report health to wolverine parent via IPC
+    reportHealth("running");
+
+  } catch (err) {
+    if (err.code === "MODULE_NOT_FOUND" && err.message.includes("openclaw")) {
+      console.log("[CLAW] OpenClaw not installed, starting standalone agent...");
+      await startStandaloneAgent();
+    } else {
+      console.error(`[CLAW] Startup failed: ${err.message}`);
+      console.error(err.stack);
+      reportHealth("error", err.message);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Fallback: start wolverine's built-in standalone agent.
+ * No external deps needed — uses wolverine's own AI client + tools.
+ */
+async function startStandaloneAgent() {
+  try {
+    // Load dotenv for AI keys
+    const dotenv = require("dotenv");
+    dotenv.config({ path: path.resolve(__dirname, "..", ".env.local") });
+    dotenv.config({ path: path.resolve(__dirname, "..", ".env") });
+
+    const { startRepl } = require("../src/claw/standalone-agent");
+    reportHealth("running");
+    await startRepl(config, { cwd: path.resolve(__dirname, "..") });
+  } catch (err) {
+    console.error(`[CLAW] Standalone agent failed: ${err.message}`);
+    console.error(err.stack);
+
+    // Last resort: try CLI mode
+    const gatewayPort = config.gateway?.port || 18789;
+    const gatewayHost = config.gateway?.host || "127.0.0.1";
+    await startClawCLI(gatewayPort, gatewayHost);
+  }
+}
+
+/**
+ * Fallback: spawn openclaw gateway via CLI (npx openclaw gateway).
+ */
+async function startClawCLI(port, host) {
+  const { spawn } = require("child_process");
+
+  // Build the config file for openclaw CLI
+  const clawConfigPath = path.join(__dirname, ".claw-runtime-config.yml");
+  const yamlConfig = buildClawYaml(config, port, host);
+  fs.writeFileSync(clawConfigPath, yamlConfig);
+
+  console.log(`[CLAW] Spawning: npx openclaw gateway --port ${port}`);
+
+  const child = spawn("npx", ["openclaw", "gateway", "--port", String(port)], {
+    cwd: path.resolve(__dirname, ".."),
+    stdio: ["inherit", "inherit", "pipe"],
+    env: {
+      ...process.env,
+      OPENCLAW_CONFIG: clawConfigPath,
+      OPENCLAW_GATEWAY_PORT: String(port),
+      OPENCLAW_GATEWAY_HOST: host,
+    },
+    shell: true,
+  });
+
+  let stderrBuffer = "";
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderrBuffer += text;
+    process.stderr.write(chunk);
+
+    // Report errors to wolverine parent
+    if (text.includes("Error") || text.includes("FATAL")) {
+      reportError(text, stderrBuffer);
+    }
+  });
+
+  child.on("exit", (code, signal) => {
+    if (!shutdownCalled) {
+      console.error(`[CLAW] Gateway exited unexpectedly (code=${code}, signal=${signal})`);
+      reportHealth("crashed", `exit code ${code}`);
+      process.exit(code || 1);
+    }
+  });
+
+  gateway = child;
+  reportHealth("running");
+}
+
+/**
+ * Build channel config from settings, filtering to enabled channels only.
+ */
+function buildChannelConfig(channels) {
+  if (!channels) return {};
+  const result = {};
+  for (const [name, cfg] of Object.entries(channels)) {
+    if (name.startsWith("_")) continue;
+    if (cfg.enabled) {
+      result[name] = { ...cfg };
+      delete result[name].enabled;
+    }
+  }
+  return result;
+}
+
+/**
+ * Build a YAML config string for openclaw CLI fallback.
+ */
+function buildClawYaml(cfg, port, host) {
+  const lines = [
+    `# Auto-generated by Wolverine Claw — do not edit manually`,
+    `gateway:`,
+    `  port: ${port}`,
+    `  host: "${host}"`,
+    ``,
+  ];
+
+  if (cfg.agent?.model) {
+    lines.push(`agent:`);
+    lines.push(`  model: "${cfg.agent.model}"`);
+    lines.push(`  maxTurns: ${cfg.agent.maxTurns || 25}`);
+    lines.push(``);
+  }
+
+  // Add enabled channels
+  const channels = cfg.channels || {};
+  const enabledChannels = Object.entries(channels).filter(([k, v]) => !k.startsWith("_") && v.enabled);
+  if (enabledChannels.length > 0) {
+    lines.push(`channels:`);
+    for (const [name, chanCfg] of enabledChannels) {
+      lines.push(`  ${name}:`);
+      for (const [key, val] of Object.entries(chanCfg)) {
+        if (key === "enabled") continue;
+        if (typeof val === "string") lines.push(`    ${key}: "${val}"`);
+        else if (Array.isArray(val)) lines.push(`    ${key}: [${val.map(v => `"${v}"`).join(", ")}]`);
+        else lines.push(`    ${key}: ${val}`);
+      }
+    }
+    lines.push(``);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Register wolverine self-healing integration as an OpenClaw plugin.
+ */
+async function registerWolverinePlugin(gw) {
+  try {
+    const pluginPath = path.join(__dirname, "plugins", "wolverine-integration.js");
+    if (fs.existsSync(pluginPath)) {
+      const plugin = require(pluginPath);
+      if (typeof plugin.register === "function") {
+        await plugin.register(gw, config);
+        console.log("[CLAW] Wolverine integration plugin loaded");
+      }
+    }
+  } catch (err) {
+    console.warn(`[CLAW] Plugin load warning: ${err.message}`);
+  }
+}
+
+/**
+ * Report health status to wolverine parent process via IPC.
+ */
+function reportHealth(status, detail) {
+  if (typeof process.send === "function") {
+    try {
+      process.send({
+        type: "claw_health",
+        status,
+        detail: detail || null,
+        timestamp: Date.now(),
+        gateway: {
+          port: config.gateway?.port || 18789,
+          host: config.gateway?.host || "127.0.0.1",
+        },
+      });
+    } catch {}
+  }
+}
+
+/**
+ * Report errors to wolverine parent process via IPC for healing.
+ */
+function reportError(message, stderr) {
+  if (typeof process.send === "function") {
+    try {
+      process.send({
+        type: "route_error",
+        path: "claw://gateway",
+        method: "INTERNAL",
+        statusCode: 500,
+        message: message.trim().slice(0, 500),
+        stack: stderr.slice(-2000),
+        file: null,
+        line: null,
+        timestamp: Date.now(),
+      });
+    } catch {}
+  }
+}
+
+// Graceful shutdown
+function shutdown(signal) {
+  if (shutdownCalled) return;
+  shutdownCalled = true;
+  console.log(`\n[CLAW] Shutting down (${signal})...`);
+
+  if (gateway) {
+    if (typeof gateway.stop === "function") {
+      gateway.stop();
+    } else if (typeof gateway.kill === "function") {
+      gateway.kill("SIGTERM");
+    }
+  }
+
+  reportHealth("stopped");
+  setTimeout(() => process.exit(0), 2000);
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+// Start
+start().catch((err) => {
+  console.error(`[CLAW] Fatal: ${err.message}`);
+  process.exit(1);
+});

package/wolverine-claw/plugins/wolverine-integration.js

@@ -0,0 +1,283 @@
+/**
+ * Wolverine Integration Plugin for OpenClaw
+ *
+ * Gives the claw agent access to wolverine's self-healing capabilities:
+ * - Brain: semantic memory, project context, and learning
+ * - Backup: workspace snapshots and rollback
+ * - Healing: error diagnosis and auto-fix pipeline
+ * - Health: process monitoring and status reporting
+ *
+ * This plugin registers as an OpenClaw skill/extension, adding wolverine-specific
+ * tools to the agent's toolkit.
+ */
+
+const path = require("path");
+const fs = require("fs");
+
+const PLUGIN_NAME = "wolverine-integration";
+
+/**
+ * Register the wolverine integration with the OpenClaw gateway.
+ */
+async function register(gateway, config) {
+  const projectRoot = path.resolve(__dirname, "../..");
+
+  // Register wolverine tools as OpenClaw tools/skills
+  const tools = buildWolverineTools(projectRoot, config);
+
+  if (gateway.registerTools) {
+    gateway.registerTools(PLUGIN_NAME, tools);
+  } else if (gateway.addTools) {
+    gateway.addTools(tools);
+  } else if (gateway.skills?.register) {
+    gateway.skills.register(PLUGIN_NAME, {
+      description: "Wolverine self-healing integration — backup, brain, and health tools",
+      tools,
+    });
+  }
+
+  // Hook into gateway events for self-healing
+  if (gateway.on) {
+    gateway.on("error", (err) => handleGatewayError(err, projectRoot));
+    gateway.on("agent:error", (err) => handleAgentError(err, projectRoot));
+    gateway.on("skill:error", (err) => handleSkillError(err, projectRoot));
+  }
+
+  // Periodic health reporting
+  const healthInterval = setInterval(() => {
+    reportToWolverine("claw_heartbeat", {
+      uptime: process.uptime(),
+      memory: process.memoryUsage(),
+      timestamp: Date.now(),
+    });
+  }, 30000);
+
+  // Cleanup on shutdown
+  if (gateway.on) {
+    gateway.on("shutdown", () => clearInterval(healthInterval));
+  }
+}
+
+/**
+ * Build wolverine-specific tools for the OpenClaw agent.
+ */
+function buildWolverineTools(projectRoot, config) {
+  return [
+    {
+      name: "wolverine_backup",
+      description: "Create a backup snapshot of the claw workspace",
+      parameters: {
+        type: "object",
+        properties: {
+          reason: { type: "string", description: "Reason for backup" },
+        },
+        required: ["reason"],
+      },
+      execute: async ({ reason }) => {
+        try {
+          const { BackupManager } = require(path.join(projectRoot, "src/backup/backup-manager"));
+          const manager = new BackupManager(projectRoot);
+          const id = manager.createBackup(`claw: ${reason}`);
+          return `Backup created: ${id}`;
+        } catch (err) {
+          return `[ERROR] Backup failed: ${err.message}`;
+        }
+      },
+    },
+    {
+      name: "wolverine_rollback",
+      description: "Rollback workspace to a previous backup",
+      parameters: {
+        type: "object",
+        properties: {
+          backupId: { type: "string", description: "Backup ID to rollback to (or 'latest')" },
+        },
+        required: ["backupId"],
+      },
+      execute: async ({ backupId }) => {
+        try {
+          const { BackupManager } = require(path.join(projectRoot, "src/backup/backup-manager"));
+          const manager = new BackupManager(projectRoot);
+          if (backupId === "latest") {
+            const result = manager.rollbackLatest();
+            return result.success ? `Rolled back to latest backup` : `Rollback failed: ${result.error}`;
+          }
+          const result = manager.rollback(backupId);
+          return result.success ? `Rolled back to ${backupId}` : `Rollback failed: ${result.error}`;
+        } catch (err) {
+          return `[ERROR] Rollback failed: ${err.message}`;
+        }
+      },
+    },
+    {
+      name: "wolverine_brain_search",
+      description: "Search wolverine's semantic memory for relevant context (past fixes, patterns, learnings)",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          limit: { type: "number", description: "Max results (default 5)" },
+        },
+        required: ["query"],
+      },
+      execute: async ({ query, limit }) => {
+        try {
+          const { Brain } = require(path.join(projectRoot, "src/brain/brain"));
+          const brain = new Brain(projectRoot);
+          await brain.init();
+          const results = await brain.search(query, { limit: limit || 5 });
+          if (!results || results.length === 0) return "No relevant memories found.";
+          return results.map((r, i) => `${i + 1}. [${r.score?.toFixed(2) || "?"}] ${r.content?.slice(0, 200) || r.text?.slice(0, 200)}`).join("\n");
+        } catch (err) {
+          return `[ERROR] Brain search failed: ${err.message}`;
+        }
+      },
+    },
+    {
+      name: "wolverine_brain_learn",
+      description: "Store a new learning in wolverine's brain memory",
+      parameters: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "What was learned" },
+          category: { type: "string", description: "Category: fix, pattern, warning, optimization" },
+        },
+        required: ["content"],
+      },
+      execute: async ({ content, category }) => {
+        try {
+          const { Brain } = require(path.join(projectRoot, "src/brain/brain"));
+          const brain = new Brain(projectRoot);
+          await brain.init();
+          await brain.addDocument({
+            content,
+            namespace: category || "learnings",
+            source: "wolverine-claw",
+            timestamp: Date.now(),
+          });
+          return "Learning stored in brain.";
+        } catch (err) {
+          return `[ERROR] Brain learn failed: ${err.message}`;
+        }
+      },
+    },
+    {
+      name: "wolverine_health",
+      description: "Get wolverine system health status (process, memory, backups, heal history)",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        const status = {
+          uptime: `${Math.floor(process.uptime())}s`,
+          memory: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`,
+          pid: process.pid,
+          nodeVersion: process.version,
+        };
+
+        try {
+          const { BackupManager } = require(path.join(projectRoot, "src/backup/backup-manager"));
+          const manager = new BackupManager(projectRoot);
+          const stats = manager.getStats();
+          status.backups = `${stats.total} total (${stats.stable} stable)`;
+        } catch {}
+
+        return JSON.stringify(status, null, 2);
+      },
+    },
+    {
+      name: "wolverine_list_backups",
+      description: "List all available workspace backups",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        try {
+          const { BackupManager } = require(path.join(projectRoot, "src/backup/backup-manager"));
+          const manager = new BackupManager(projectRoot);
+          const backups = manager.list();
+          if (!backups || backups.length === 0) return "No backups found.";
+          return backups.map(b => `${b.id} — ${b.reason || "manual"} (${b.status || "unknown"}) ${b.timestamp || ""}`).join("\n");
+        } catch (err) {
+          return `[ERROR] List backups failed: ${err.message}`;
+        }
+      },
+    },
+    {
+      name: "wolverine_self_heal",
+      description: "Trigger wolverine's self-healing pipeline on a specific error",
+      parameters: {
+        type: "object",
+        properties: {
+          error: { type: "string", description: "Error message or stack trace" },
+          file: { type: "string", description: "File where error occurred (optional)" },
+        },
+        required: ["error"],
+      },
+      execute: async ({ error, file }) => {
+        // Report to parent wolverine process for healing
+        reportToWolverine("route_error", {
+          path: "claw://agent",
+          method: "INTERNAL",
+          statusCode: 500,
+          message: error.slice(0, 500),
+          stack: error,
+          file: file || null,
+          line: null,
+          timestamp: Date.now(),
+        });
+        return "Error reported to wolverine healing pipeline.";
+      },
+    },
+  ];
+}
+
+/**
+ * Handle gateway errors — report to wolverine for healing.
+ */
+function handleGatewayError(err, projectRoot) {
+  console.error(`[CLAW] Gateway error: ${err.message}`);
+  reportToWolverine("route_error", {
+    path: "claw://gateway",
+    method: "INTERNAL",
+    statusCode: 500,
+    message: err.message,
+    stack: err.stack,
+    file: null,
+    line: null,
+    timestamp: Date.now(),
+  });
+}
+
+/**
+ * Handle agent errors.
+ */
+function handleAgentError(err, projectRoot) {
+  console.error(`[CLAW] Agent error: ${err.message}`);
+  reportToWolverine("route_error", {
+    path: "claw://agent",
+    method: "INTERNAL",
+    statusCode: 500,
+    message: err.message,
+    stack: err.stack,
+    file: null,
+    line: null,
+    timestamp: Date.now(),
+  });
+}
+
+/**
+ * Handle skill errors.
+ */
+function handleSkillError(err, projectRoot) {
+  console.warn(`[CLAW] Skill error (non-fatal): ${err.message}`);
+}
+
+/**
+ * Report to wolverine parent process via IPC.
+ */
+function reportToWolverine(type, data) {
+  if (typeof process.send === "function") {
+    try {
+      process.send({ type, ...data });
+    } catch {}
+  }
+}
+
+module.exports = { register, PLUGIN_NAME };

package/wolverine-claw/workspace/.gitignore

@@ -0,0 +1,5 @@
+# Wolverine Claw workspace — agent-generated files
+# Keep .gitkeep but ignore everything else
+*
+!.gitkeep
+!.gitignore