@toyako/hive 1.0.0

package/src/adapters/CodexAdapter.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+import OpenAI from "openai";
+import { AgentAdapter, AgentResult, ReviewResult, Task } from "../types";
+import { extractJson, normalizeText } from "../utils/OutputNormalizer";
+import { loadAdapterConfig } from "../runtime/RuntimeConfig";
+
+const REVIEWER_PROMPT = fs.readFileSync(path.join(__dirname, "../prompts/reviewer.txt"), "utf-8");
+
+const HEALTH_PROMPT = `Create JSON:
+
+{"runtime":"working","number":17}
+
+Return JSON only.`;
+
+function loadConfig(): { apiKey: string; baseURL: string; model: string } {
+  return loadAdapterConfig("codex", "OPENAI");
+}
+
+export class CodexAdapter implements AgentAdapter {
+  name = "codex";
+  role = "developer" as const;
+  capabilities = ["coding", "refactor"];
+  version = "2.1.0";
+
+  private client: OpenAI | null = null;
+  private config = loadConfig();
+
+  private getClient(): OpenAI {
+    if (!this.client) {
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseURL,
+      });
+    }
+    return this.client;
+  }
+
+  async detect(): Promise<boolean> {
+    // Only check if API key exists — don't make API calls
+    // API verification is done by health()
+    return !!this.config.apiKey;
+  }
+
+  async health(): Promise<boolean> {
+    try {
+      const result = await this.chat(HEALTH_PROMPT);
+      const parsed = extractJson(result);
+      return !!(parsed && parsed.runtime === "working" && parsed.number === 17);
+    } catch {
+      return false;
+    }
+  }
+
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    try {
+      const output = await this.chat(prompt);
+      return { success: true, output: output || "[Codex] Completed" };
+    } catch (err: any) {
+      return { success: false, output: "", error: err.message };
+    }
+  }
+
+  async review(task: Task): Promise<ReviewResult> {
+    const resultContext = task.result || "No execution result available";
+    const prompt = `${REVIEWER_PROMPT}
+
+---
+
+执行结果：
+${normalizeText(resultContext)}
+
+---
+
+请审核以上结果并返回 JSON。`;
+
+    try {
+      const output = await this.chat(prompt);
+      const parsed = extractJson(output);
+      if (parsed && parsed.decision) {
+        return {
+          decision: parsed.decision === "PASS" ? "PASS" : "FAIL",
+          score: typeof parsed.score === "number" ? parsed.score : 0,
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+        };
+      }
+      const text = output.toLowerCase();
+      if (text.includes('"pass"')) return { decision: "PASS", score: 75, issues: [] };
+      return { decision: "FAIL", score: 30, issues: ["Could not parse structured review output", output.slice(0, 200)] };
+    } catch (err: any) {
+      return { decision: "FAIL", score: 0, issues: [`Review execution failed: ${err.message}`] };
+    }
+  }
+
+  private async chat(prompt: string): Promise<string> {
+    const client = this.getClient();
+    const res = await client.chat.completions.create({
+      model: this.config.model,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 4096,
+    });
+    const msg = res.choices?.[0]?.message;
+    // Mimo API returns response in reasoning_content for reasoning models
+    // Check both content and reasoning_content
+    return msg?.content || (msg as any)?.reasoning_content || "";
+  }
+}

package/src/adapters/HermesAdapter.ts

@@ -0,0 +1,196 @@
+import { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import OpenAI from "openai";
+import { AgentAdapter, AgentResult, ReviewResult, Task, MessageEnvelope } from "../types";
+import { extractJson, normalizeText } from "../utils/OutputNormalizer";
+import { loadAdapterConfig } from "../runtime/RuntimeConfig";
+
+const HERMES_BIN = findBinary("hermes");
+
+const REVIEWER_PROMPT = fs.readFileSync(path.join(__dirname, "../prompts/reviewer.txt"), "utf-8");
+
+function findBinary(name: string): string {
+  const localPath = path.join(process.env.HOME || "/home/liu", ".local/bin", name);
+  if (fs.existsSync(localPath)) return localPath;
+  const hermesPath = path.join(process.env.HOME || "/home/liu", ".hermes/node/bin", name);
+  if (fs.existsSync(hermesPath)) return hermesPath;
+  return name;
+}
+
+function loadRuntimeConfig(): { model: string; apiKey: string; baseURL: string } {
+  return loadAdapterConfig("hermes", "OPENAI");
+}
+
+function createClient(): OpenAI {
+  const cfg = loadRuntimeConfig();
+  return new OpenAI({ apiKey: cfg.apiKey, baseURL: cfg.baseURL });
+}
+
+export class HermesAdapter implements AgentAdapter {
+  name = "hermes";
+  role = "planner" as const;
+  capabilities = ["planning", "coding", "review", "research"];
+  version = "0.15.1";
+
+  async detect(): Promise<boolean> {
+    // Try CLI first
+    try {
+      const result = await this.exec(HERMES_BIN, ["--version"], {}, 5000);
+      if (result.exitCode === 0 && result.stdout.includes("Hermes")) return true;
+    } catch (e) {
+      console.debug("[HermesAdapter] CLI detection failed:", e instanceof Error ? e.message : e);
+    }
+    // Fallback: check API key
+    const cfg = loadRuntimeConfig();
+    return !!cfg.apiKey;
+  }
+
+  async health(): Promise<boolean> {
+    try {
+      const cfg = loadRuntimeConfig();
+      if (!cfg.apiKey) return false;
+      const client = createClient();
+      const res = await client.chat.completions.create({
+        model: cfg.model,
+        messages: [
+          { role: "system", content: "You are a health check probe." },
+          { role: "user", content: 'Return this exact JSON: {"runtime":"working","number":17}' },
+        ],
+        max_tokens: 100,
+      });
+      const content = res.choices[0]?.message?.content || "";
+      const parsed = extractJson(content);
+      return !!(parsed && parsed.runtime === "working" && parsed.number === 17);
+    } catch (e) {
+      console.debug("[HermesAdapter] Runtime check failed:", e instanceof Error ? e.message : e);
+      return false;
+    }
+  }
+
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    const cfg = loadRuntimeConfig();
+
+    try {
+      const client = createClient();
+      const res = await client.chat.completions.create({
+        model: cfg.model,
+        messages: [
+          { role: "system", content: "You are a planning and execution assistant. Produce clear, actionable output." },
+          { role: "user", content: prompt },
+        ],
+        max_tokens: 16000,
+      });
+
+      let content = res.choices[0]?.message?.content || "";
+      if (!content && (res.choices[0]?.message as any)?.reasoning_content) {
+        content = (res.choices[0]?.message as any).reasoning_content;
+      }
+
+      if (content) return { success: true, output: content };
+      return { success: false, output: "", error: "Empty response from model" };
+    } catch (err: any) {
+      return { success: false, output: "", error: err.message };
+    }
+  }
+
+  async review(task: Task): Promise<ReviewResult> {
+    const resultContext = task.result || "No execution result available";
+    const cfg = loadRuntimeConfig();
+
+    const prompt = `${REVIEWER_PROMPT}
+
+---
+
+执行结果：
+${normalizeText(resultContext)}
+
+---
+
+请审核以上结果并返回 JSON。`;
+
+    try {
+      const client = createClient();
+      const res = await client.chat.completions.create({
+        model: cfg.model,
+        messages: [
+          { role: "system", content: "You are a code reviewer. Return structured JSON reviews." },
+          { role: "user", content: prompt },
+        ],
+        max_tokens: 4000,
+      });
+
+      let content = res.choices[0]?.message?.content || "";
+      if (!content && (res.choices[0]?.message as any)?.reasoning_content) {
+        content = (res.choices[0]?.message as any).reasoning_content;
+      }
+
+      const parsed = extractJson(content);
+      if (parsed && parsed.decision) {
+        return {
+          decision: parsed.decision === "PASS" ? "PASS" : "FAIL",
+          score: typeof parsed.score === "number" ? parsed.score : 0,
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+        };
+      }
+
+      const text = content.toLowerCase();
+      if (text.includes('"pass"')) return { decision: "PASS", score: 75, issues: [] };
+
+      return { decision: "FAIL", score: 30, issues: ["Could not parse structured review output", content.slice(0, 200)] };
+    } catch (err: any) {
+      return { decision: "FAIL", score: 0, issues: [`Review execution failed: ${err.message}`] };
+    }
+  }
+
+  async converse(messages: MessageEnvelope[]): Promise<MessageEnvelope> {
+    const cfg = loadRuntimeConfig();
+    const lastMsg = messages[messages.length - 1];
+    const chatMessages = messages.map(m => ({
+      role: (m.from === "hermes" ? "assistant" : "user") as "assistant" | "user",
+      content: typeof m.payload === "string" ? m.payload : JSON.stringify(m.payload),
+    }));
+
+    try {
+      const client = createClient();
+      const res = await client.chat.completions.create({ model: cfg.model, messages: chatMessages, max_tokens: 8000 });
+      let content = res.choices[0]?.message?.content || "";
+      if (!content && (res.choices[0]?.message as any)?.reasoning_content) {
+        content = (res.choices[0]?.message as any).reasoning_content;
+      }
+
+      return {
+        id: `conv-${Date.now()}`, taskId: lastMsg.taskId, conversationId: lastMsg.conversationId,
+        from: "hermes", to: lastMsg.from, type: "CONVERSATION_MESSAGE",
+        payload: content || "[Hermes] No response",
+        metadata: { hopCount: lastMsg.metadata.hopCount + 1, maxHops: lastMsg.metadata.maxHops, priority: lastMsg.metadata.priority, routingPath: [...lastMsg.metadata.routingPath, "hermes"] },
+        timestamp: Date.now(),
+      };
+    } catch (err: any) {
+      return {
+        id: `conv-err-${Date.now()}`, taskId: lastMsg.taskId, conversationId: lastMsg.conversationId,
+        from: "hermes", to: lastMsg.from, type: "ERROR", payload: `Converse failed: ${err.message}`,
+        metadata: { hopCount: lastMsg.metadata.hopCount + 1, maxHops: lastMsg.metadata.maxHops, priority: lastMsg.metadata.priority, routingPath: [...lastMsg.metadata.routingPath, "hermes"] },
+        timestamp: Date.now(),
+      };
+    }
+  }
+
+  supportsFeature?(feature: string): boolean {
+    return this.capabilities.includes(feature);
+  }
+
+  private exec(cmd: string, args: string[], opts: { cwd?: string }, timeout: number = 600_000) {
+    return new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
+      const env = { ...process.env, HERMES_QUIET: "1", HERMES_MAX_ITERATIONS: "1" };
+      const proc = spawn(cmd, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "", stderr = "";
+      proc.stdout.on("data", (d: Buffer) => stdout += d.toString());
+      proc.stderr.on("data", (d: Buffer) => stderr += d.toString());
+      const timer = setTimeout(() => { proc.kill("SIGTERM"); reject(new Error(`TIMEOUT after ${timeout}ms`)); }, timeout);
+      proc.on("close", (code: number | null) => { clearTimeout(timer); resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: code ?? 1 }); });
+      proc.on("error", (err: Error) => { clearTimeout(timer); reject(err); });
+    });
+  }
+}

package/src/adapters/MockClaudeAdapter.ts

@@ -0,0 +1,70 @@
+import { AgentAdapter, AgentResult, ReviewResult, Task } from "../types";
+
+/**
+ * Mock Claude Adapter
+ * Simulates code review.
+ *
+ * Behavior:
+ * - failCount: how many times to fail before passing (default: 0 = always pass)
+ * - score: base score for reviews
+ */
+export class MockClaudeAdapter implements AgentAdapter {
+  name = "claude";
+  role = "reviewer" as const;
+  capabilities = ["review", "architecture"];
+
+  private failCount: number;
+  private baseScore: number;
+  private callCount = 0;
+
+  constructor(opts?: { failCount?: number; score?: number }) {
+    this.failCount = opts?.failCount ?? 0;
+    this.baseScore = opts?.score ?? 85;
+  }
+
+  async detect(): Promise<boolean> {
+    return true;
+  }
+
+  async health(): Promise<boolean> {
+    return true;
+  }
+
+  async execute(task: Task): Promise<AgentResult> {
+    return { success: true, output: "[MockClaude] Review-only agent" };
+  }
+
+  async review(task: Task): Promise<ReviewResult> {
+    await this.sleep(300);
+    this.callCount++;
+
+    if (this.callCount <= this.failCount) {
+      return {
+        decision: "FAIL",
+        score: Math.max(30, this.baseScore - 40),
+        issues: [
+          `Mock issue #1: simulated code smell (review ${this.callCount}/${this.failCount})`,
+          `Mock issue #2: needs refactoring`,
+        ],
+      };
+    }
+
+    return {
+      decision: "PASS",
+      score: this.baseScore,
+      issues: [],
+    };
+  }
+
+  getCallCount(): number {
+    return this.callCount;
+  }
+
+  reset(): void {
+    this.callCount = 0;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+  }
+}

package/src/adapters/MockCodexAdapter.ts

@@ -0,0 +1,36 @@
+import { AgentAdapter, AgentResult, Task } from "../types";
+
+/**
+ * Mock Codex Adapter
+ * Simulates code execution with a small delay.
+ * Returns deterministic output for testing.
+ */
+export class MockCodexAdapter implements AgentAdapter {
+  name = "codex";
+  role = "developer" as const;
+  capabilities = ["coding", "refactor"];
+
+  async detect(): Promise<boolean> {
+    return true;
+  }
+
+  async health(): Promise<boolean> {
+    return true;
+  }
+
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    // Simulate work
+    await this.sleep(500);
+
+    const instr = instruction || task.instruction;
+    return {
+      success: true,
+      output: `[MockCodex] Completed: "${instr}"\nFiles modified: src/Component.vue, src/styles.css`,
+      files: ["src/Component.vue", "src/styles.css"],
+    };
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(r => setTimeout(r, ms));
+  }
+}

package/src/adapters/OpenClawAdapter.ts

@@ -0,0 +1,172 @@
+import { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import { AgentAdapter, AgentResult, ReviewResult, Task, MessageEnvelope } from "../types";
+import { extractJson, normalizeText } from "../utils/OutputNormalizer";
+
+const OPENCLAW_BIN = findBinary("openclaw");
+
+const REVIEWER_PROMPT = fs.readFileSync(path.join(__dirname, "../prompts/reviewer.txt"), "utf-8");
+
+function findBinary(name: string): string {
+  // Check WSL paths first
+  const hermesPath = path.join(process.env.HOME || "/home/liu", ".hermes/node/bin", name);
+  if (fs.existsSync(hermesPath)) return hermesPath;
+
+  // Check common Windows paths via /mnt/c
+  const winPaths = [
+    "/mnt/c/Program Files/nodejs/" + name,
+    "/mnt/c/Program Files/nodejs/" + name + ".cmd",
+  ];
+  for (const wp of winPaths) {
+    if (fs.existsSync(wp)) return wp;
+  }
+
+  return name;
+}
+
+export class OpenClawAdapter implements AgentAdapter {
+  name = "openclaw";
+  role = "reviewer" as const;
+  capabilities = ["review", "code-analysis", "security-scan", "refactor"];
+  version = "0.2.0";
+
+  async detect(): Promise<boolean> {
+    try {
+      const result = await this.exec(OPENCLAW_BIN, ["--version"], {}, 5000);
+      return result.exitCode === 0 && result.stdout.includes("OpenClaw");
+    } catch {
+      return false;
+    }
+  }
+
+  async health(): Promise<boolean> {
+    // Check if gateway is running via `openclaw health`
+    // If gateway is down, return false (degraded, not crash)
+    try {
+      const result = await this.exec(OPENCLAW_BIN, ["health"], {}, 8000);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async execute(task: Task, instruction?: string): Promise<AgentResult> {
+    const prompt = instruction || task.instruction;
+    const cwd = task.workingDirectory || process.cwd();
+
+    // `openclaw agent` runs one agent turn via the Gateway
+    const args = ["agent", "-p", prompt];
+
+    try {
+      const result = await this.exec(OPENCLAW_BIN, args, { cwd }, task.timeout);
+      if (result.exitCode === 0) {
+        return { success: true, output: result.stdout || "[OpenClaw] Completed" };
+      } else {
+        return { success: false, output: result.stdout || "", error: result.stderr || `Exit code: ${result.exitCode}` };
+      }
+    } catch (err: any) {
+      return { success: false, output: "", error: err.message };
+    }
+  }
+
+  async review(task: Task): Promise<ReviewResult> {
+    const cwd = task.workingDirectory || process.cwd();
+    const resultContext = task.result || "No execution result available";
+
+    const prompt = `${REVIEWER_PROMPT}
+
+---
+
+执行结果：
+${normalizeText(resultContext)}
+
+---
+
+请审核以上结果并返回 JSON。`;
+
+    const args = ["agent", "-p", prompt];
+
+    try {
+      const result = await this.exec(OPENCLAW_BIN, args, { cwd }, task.timeout);
+
+      if (result.exitCode !== 0) {
+        return { decision: "FAIL", score: 0, issues: [`OpenClaw CLI error: ${result.stderr || "unknown"}`] };
+      }
+
+      const parsed = extractJson(result.stdout);
+      if (parsed && parsed.decision) {
+        return {
+          decision: parsed.decision === "PASS" ? "PASS" : "FAIL",
+          score: typeof parsed.score === "number" ? parsed.score : 0,
+          issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+        };
+      }
+
+      const text = result.stdout.toLowerCase();
+      if (text.includes('"pass"')) return { decision: "PASS", score: 75, issues: [] };
+
+      return { decision: "FAIL", score: 30, issues: ["Could not parse structured review output", result.stdout.slice(0, 200)] };
+    } catch (err: any) {
+      return { decision: "FAIL", score: 0, issues: [`Review execution failed: ${err.message}`] };
+    }
+  }
+
+  async converse(messages: MessageEnvelope[]): Promise<MessageEnvelope> {
+    const context = messages.map(m => `[${m.from}]: ${typeof m.payload === 'string' ? m.payload : JSON.stringify(m.payload)}`).join("\n\n");
+    const lastMsg = messages[messages.length - 1];
+
+    try {
+      const result = await this.exec(OPENCLAW_BIN, ["agent", "-p", context], {}, 120_000);
+      return {
+        id: `conv-${Date.now()}`,
+        taskId: lastMsg.taskId,
+        conversationId: lastMsg.conversationId,
+        from: "openclaw",
+        to: lastMsg.from,
+        type: "CONVERSATION_MESSAGE",
+        payload: result.stdout || "[OpenClaw] No response",
+        metadata: {
+          hopCount: lastMsg.metadata.hopCount + 1,
+          maxHops: lastMsg.metadata.maxHops,
+          priority: lastMsg.metadata.priority,
+          routingPath: [...lastMsg.metadata.routingPath, "openclaw"],
+        },
+        timestamp: Date.now(),
+      };
+    } catch (err: any) {
+      return {
+        id: `conv-err-${Date.now()}`,
+        taskId: lastMsg.taskId,
+        conversationId: lastMsg.conversationId,
+        from: "openclaw",
+        to: lastMsg.from,
+        type: "ERROR",
+        payload: `Converse failed: ${err.message}`,
+        metadata: {
+          hopCount: lastMsg.metadata.hopCount + 1,
+          maxHops: lastMsg.metadata.maxHops,
+          priority: lastMsg.metadata.priority,
+          routingPath: [...lastMsg.metadata.routingPath, "openclaw"],
+        },
+        timestamp: Date.now(),
+      };
+    }
+  }
+
+  supportsFeature(feature: string): boolean {
+    return this.capabilities.includes(feature);
+  }
+
+  private exec(cmd: string, args: string[], opts: { cwd?: string }, timeout: number = 600_000) {
+    return new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
+      const proc = spawn(cmd, args, { cwd: opts.cwd, env: { ...process.env }, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "", stderr = "";
+      proc.stdout.on("data", (d: Buffer) => stdout += d.toString());
+      proc.stderr.on("data", (d: Buffer) => stderr += d.toString());
+      const timer = setTimeout(() => { proc.kill("SIGTERM"); reject(new Error(`TIMEOUT after ${timeout}ms`)); }, timeout);
+      proc.on("close", (code: number | null) => { clearTimeout(timer); resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: code ?? 1 }); });
+      proc.on("error", (err: Error) => { clearTimeout(timer); reject(err); });
+    });
+  }
+}

package/src/adapters/registry.ts

@@ -0,0 +1,54 @@
+/**
+ * Adapter Registry — auto-discovery of all available adapters.
+ *
+ * To add a new adapter:
+ * 1. Create the adapter file in adapters/
+ * 2. Add the import and entry below
+ * 3. cli.ts automatically picks it up
+ */
+import { AgentAdapter } from "../types";
+import { CodexAdapter } from "./CodexAdapter";
+import { ClaudeAdapter } from "./ClaudeAdapter";
+import { HermesAdapter } from "./HermesAdapter";
+import { OpenClawAdapter } from "./OpenClawAdapter";
+import { MockCodexAdapter } from "./MockCodexAdapter";
+import { MockClaudeAdapter } from "./MockClaudeAdapter";
+
+export interface AdapterEntry {
+  name: string;
+  factory: () => AgentAdapter;
+  mock?: () => AgentAdapter;
+}
+
+/**
+ * All registered adapters. Add new adapters here.
+ */
+export const ADAPTER_REGISTRY: AdapterEntry[] = [
+  { name: "codex", factory: () => new CodexAdapter(), mock: () => new MockCodexAdapter() },
+  { name: "claude", factory: () => new ClaudeAdapter(), mock: () => new MockClaudeAdapter() },
+  { name: "hermes", factory: () => new HermesAdapter() },
+  { name: "openclaw", factory: () => new OpenClawAdapter() },
+];
+
+/**
+ * Get all real adapter factories.
+ */
+export function getAllAdapters(): AgentAdapter[] {
+  return ADAPTER_REGISTRY.map(e => e.factory());
+}
+
+/**
+ * Get all mock adapter factories (for dry-run).
+ */
+export function getMockAdapters(): AgentAdapter[] {
+  return ADAPTER_REGISTRY
+    .filter(e => e.mock)
+    .map(e => e.mock!());
+}
+
+/**
+ * Get adapter names.
+ */
+export function getAdapterNames(): string[] {
+  return ADAPTER_REGISTRY.map(e => e.name);
+}