agentshire 1.0.0

package/src/plugin/__tests__/hook-translator.test.ts

@@ -0,0 +1,197 @@
+// @desc Tests for hook-translator: OpenClaw hooks → AgentEvent translation
+import { describe, it, expect } from 'vitest'
+import { hookToAgentEvent } from '../hook-translator.js'
+import type { AgentEvent } from '../../contracts/events.js'
+
+describe('hookToAgentEvent', () => {
+  it('before_agent_start → system.init AgentEvent', () => {
+    const result = hookToAgentEvent('before_agent_start', {
+      sessionId: 'sess-1',
+      model: 'claude-3',
+      persona: 'steward',
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'system',
+      subtype: 'init',
+      sessionId: 'sess-1',
+      model: 'claude-3',
+      persona: 'steward',
+    })
+  })
+
+  it('before_agent_start uses defaults when payload is empty', () => {
+    const result = hookToAgentEvent('before_agent_start', {}) as AgentEvent
+    expect(result).toMatchObject({
+      type: 'system',
+      subtype: 'init',
+      model: 'unknown',
+    })
+    expect((result as any).sessionId).toMatch(/^oc-session-/)
+  })
+
+  it('llm_output with text content → text event', () => {
+    const result = hookToAgentEvent('llm_output', {
+      assistantTexts: ['first chunk', 'full response'],
+    }) as AgentEvent
+
+    expect(result).toEqual({ type: 'text', content: 'full response' })
+  })
+
+  it('llm_output with empty text → null', () => {
+    const result = hookToAgentEvent('llm_output', { assistantTexts: [''] })
+    expect(result).toBeNull()
+  })
+
+  it('before_tool_call → tool_use event', () => {
+    const result = hookToAgentEvent('before_tool_call', {
+      toolCallId: 'tc-1',
+      toolName: 'read_file',
+      params: { path: '/foo.ts' },
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'tool_use',
+      toolUseId: 'tc-1',
+      name: 'read_file',
+      input: { path: '/foo.ts' },
+    })
+  })
+
+  it('after_tool_call → tool_result event (array)', () => {
+    const result = hookToAgentEvent('after_tool_call', {
+      toolCallId: 'tc-1',
+      toolName: 'bash',
+      result: 'ok',
+    }) as AgentEvent[]
+
+    expect(Array.isArray(result)).toBe(true)
+    expect(result[0]).toMatchObject({
+      type: 'tool_result',
+      toolUseId: 'tc-1',
+      name: 'bash',
+      output: 'ok',
+    })
+  })
+
+  it('after_tool_call with media output includes media_output event', () => {
+    const result = hookToAgentEvent('after_tool_call', {
+      toolCallId: 'tc-2',
+      toolName: 'image',
+      result: 'saved to /tmp/output.png',
+      params: {},
+    }) as AgentEvent[]
+
+    expect(result).toHaveLength(2)
+    expect(result[1]).toMatchObject({
+      type: 'media_output',
+      kind: 'image',
+      path: '/tmp/output.png',
+    })
+  })
+
+  it('subagent_spawned → sub_agent.started event', () => {
+    const result = hookToAgentEvent('subagent_spawned', {
+      childSessionKey: 'child-1',
+      agentType: 'researcher',
+      task: 'find bugs',
+      model: 'gpt-4',
+      label: 'Bug Hunter',
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'sub_agent',
+      subtype: 'started',
+      agentId: 'child-1',
+      agentType: 'researcher',
+      task: 'find bugs',
+      model: 'gpt-4',
+      displayName: 'Bug Hunter',
+    })
+  })
+
+  it('subagent_ended → sub_agent.done event', () => {
+    const result = hookToAgentEvent('subagent_ended', {
+      targetSessionKey: 'child-1',
+      outcome: 'ok',
+      result: 'found 3 bugs',
+      toolCalls: 5,
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'sub_agent',
+      subtype: 'done',
+      agentId: 'child-1',
+      result: 'found 3 bugs',
+      toolCalls: 5,
+      status: 'completed',
+    })
+  })
+
+  it('subagent_ended with error outcome → status=failed', () => {
+    const result = hookToAgentEvent('subagent_ended', {
+      targetSessionKey: 'child-2',
+      outcome: 'error',
+      reason: 'timeout',
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'sub_agent',
+      subtype: 'done',
+      status: 'failed',
+    })
+  })
+
+  it('agent_end → turn_end event', () => {
+    const result = hookToAgentEvent('agent_end', {
+      usage: { inputTokens: 100, outputTokens: 50 },
+      toolCalls: 3,
+      durationMs: 1200,
+    }) as AgentEvent[]
+
+    expect(Array.isArray(result)).toBe(true)
+    const turnEnd = result.find((e: any) => e.type === 'turn_end')
+    expect(turnEnd).toMatchObject({
+      type: 'turn_end',
+      usage: { inputTokens: 100, outputTokens: 50 },
+      toolCalls: 3,
+      durationMs: 1200,
+    })
+  })
+
+  it('agent_end with error includes error event before turn_end', () => {
+    const result = hookToAgentEvent('agent_end', {
+      success: false,
+      error: 'Out of tokens',
+    }) as AgentEvent[]
+
+    expect(result[0]).toMatchObject({
+      type: 'error',
+      message: 'Out of tokens',
+      recoverable: false,
+    })
+    expect(result[result.length - 1]).toMatchObject({ type: 'turn_end' })
+  })
+
+  it('unknown hook → null', () => {
+    expect(hookToAgentEvent('some_random_hook', {})).toBeNull()
+  })
+
+  it('llm_input → thinking_delta event', () => {
+    const result = hookToAgentEvent('llm_input', {}) as AgentEvent
+    expect(result).toEqual({ type: 'thinking_delta', delta: '' })
+  })
+
+  it('session_end → system.done event', () => {
+    const result = hookToAgentEvent('session_end', {
+      sessionId: 'sess-1',
+    }) as AgentEvent
+
+    expect(result).toMatchObject({
+      type: 'system',
+      subtype: 'done',
+      result: 'session_end',
+      sessionId: 'sess-1',
+    })
+  })
+})

package/src/plugin/auto-config.ts

@@ -0,0 +1,131 @@
+import { join } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { fileURLToPath } from "node:url";
+import { stateDir } from "./paths.js";
+
+const AGENT_ID = "town-steward";
+const CHANNEL_ID = "agentshire";
+const TEMPLATE_DIR = "town-workspace";
+
+function getPluginDir(): string {
+  return join(fileURLToPath(import.meta.url), "../../..");
+}
+
+function ensureTownWorkspace(): string {
+  const agentDir = join(stateDir(), `workspace-${AGENT_ID}`);
+  const templateDir = join(getPluginDir(), TEMPLATE_DIR);
+  if (!existsSync(templateDir)) {
+    console.warn(
+      `[agentshire] Template workspace not found at ${templateDir}`,
+    );
+    return agentDir;
+  }
+
+  mkdirSync(agentDir, { recursive: true });
+
+  const pluginDir = getPluginDir();
+  const SDK_DEFAULT_MARKERS = [
+    "# SOUL.md - Who You Are",
+    "# IDENTITY.md - Who Am I?",
+  ];
+  for (const file of readdirSync(templateDir)) {
+    const src = join(templateDir, file);
+    const dst = join(agentDir, file);
+    if (!existsSync(dst)) {
+      copyFileSync(src, dst);
+    } else {
+      const existing = readFileSync(dst, "utf-8");
+      if (SDK_DEFAULT_MARKERS.some((m) => existing.startsWith(m))) {
+        copyFileSync(src, dst);
+      }
+    }
+  }
+
+  const defaultsPath = join(agentDir, "town-defaults.json");
+  if (existsSync(defaultsPath)) {
+    try {
+      const data = JSON.parse(readFileSync(defaultsPath, "utf-8"));
+      const resolve = (p: string) => p && !p.startsWith("/") ? join(pluginDir, p) : p;
+      if (data.steward) data.steward.personaFile = resolve(data.steward.personaFile ?? "");
+      if (Array.isArray(data.citizens)) {
+        data.citizens = data.citizens.map((c: any) => ({ ...c, personaFile: resolve(c.personaFile ?? "") }));
+      }
+      writeFileSync(defaultsPath, JSON.stringify(data, null, 2), "utf-8");
+    } catch {}
+  }
+
+  console.log(`[agentshire] Initialized workspace at ${agentDir}`);
+  return agentDir;
+}
+
+export async function ensureTownAgentConfig(): Promise<void> {
+  try {
+    const configPath = join(stateDir(), "openclaw.json");
+    if (!existsSync(configPath)) return;
+
+    const raw = readFileSync(configPath, "utf-8");
+    const cfg = JSON.parse(raw);
+
+    const agents: any[] = cfg.agents?.list ?? [];
+    const hasAgent = agents.some((a: any) => a.id === AGENT_ID);
+
+    const bindings: any[] = cfg.bindings ?? [];
+    const hasBinding = bindings.some(
+      (b: any) => b.match?.channel === CHANNEL_ID && b.agentId === AGENT_ID,
+    );
+
+    let dirty = false;
+    const workspaceDir = ensureTownWorkspace();
+
+    if (!hasAgent) {
+      cfg.agents = cfg.agents ?? {};
+      cfg.agents.list = cfg.agents.list ?? [];
+      cfg.agents.list.push({
+        id: AGENT_ID,
+        name: "shire",
+        workspace: workspaceDir,
+        identity: { name: "shire", emoji: "🏘️" },
+      });
+      dirty = true;
+    }
+
+    if (!hasBinding) {
+      cfg.bindings = cfg.bindings ?? [];
+      cfg.bindings.push({
+        type: "route",
+        agentId: AGENT_ID,
+        comment: "Route agentshire channel to dedicated steward agent",
+        match: { channel: CHANNEL_ID },
+      });
+      dirty = true;
+    }
+
+    const DEFAULT_TIMEOUT = 600;
+    const subagents = cfg.agents?.defaults?.subagents ?? {};
+    if (!subagents.runTimeoutSeconds || subagents.runTimeoutSeconds < DEFAULT_TIMEOUT) {
+      cfg.agents = cfg.agents ?? {};
+      cfg.agents.defaults = cfg.agents.defaults ?? {};
+      cfg.agents.defaults.subagents = {
+        ...subagents,
+        runTimeoutSeconds: Math.max(subagents.runTimeoutSeconds ?? 0, DEFAULT_TIMEOUT),
+      };
+      dirty = true;
+    }
+
+    if (!dirty) return;
+
+    writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+    console.log(
+      `[agentshire] Auto-configured ${AGENT_ID} agent + binding in openclaw.json`,
+    );
+  } catch (err) {
+    console.error("[agentshire] Failed to auto-configure agent:", err);
+  }
+}