macro-agent 0.1.2 → 0.1.4

package/src/cognitive/__tests__/session-converter.test.ts

@@ -0,0 +1,423 @@
+import { describe, it, expect } from "vitest";
+import type { ExtendedSessionUpdate } from "acp-factory";
+import {
+  convertUpdatesToSession,
+  updateSessionFromEvent,
+} from "../session-converter.js";
+import type { CognitiveAgentSession, CognitiveTask } from "../types.js";
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+function makeUpdate(
+  overrides: Record<string, unknown>,
+): ExtendedSessionUpdate {
+  return overrides as unknown as ExtendedSessionUpdate;
+}
+
+function makeTask(description = "Analyze trajectory"): CognitiveTask {
+  return { description };
+}
+
+function makeEmptySession(): CognitiveAgentSession {
+  return {
+    id: "test-session",
+    agentType: "claude-code",
+    task: makeTask(),
+    state: "running",
+    messages: [],
+    toolCalls: [],
+    startTime: new Date(),
+    metadata: {},
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe("convertUpdatesToSession", () => {
+  it("creates session with correct metadata", () => {
+    const session = convertUpdatesToSession(
+      [],
+      "sess-1",
+      "claude-code",
+      makeTask("test task"),
+    );
+
+    expect(session.id).toBe("sess-1");
+    expect(session.agentType).toBe("claude-code");
+    expect(session.task.description).toBe("test task");
+    expect(session.state).toBe("running");
+    expect(session.messages).toEqual([]);
+    expect(session.toolCalls).toEqual([]);
+  });
+
+  it("processes all updates in order", () => {
+    const updates = [
+      makeUpdate({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Thinking about the analysis..." },
+      }),
+      makeUpdate({
+        sessionUpdate: "tool_call",
+        toolCallId: "tc-1",
+        title: "read_file",
+        rawInput: { path: "input/data.json" },
+      }),
+      makeUpdate({
+        sessionUpdate: "tool_call_update",
+        toolCallId: "tc-1",
+        status: "completed",
+        content: [{ type: "text", text: '{"data": "value"}' }],
+      }),
+    ];
+
+    const session = convertUpdatesToSession(
+      updates,
+      "sess-2",
+      "claude-code",
+      makeTask(),
+    );
+
+    expect(session.messages).toHaveLength(1);
+    expect(session.messages[0]!.content).toBe(
+      "Thinking about the analysis...",
+    );
+    expect(session.toolCalls).toHaveLength(1);
+    expect(session.toolCalls[0]!.name).toBe("read_file");
+    expect(session.toolCalls[0]!.output).toBe('{"data": "value"}');
+  });
+});
+
+describe("updateSessionFromEvent", () => {
+  describe("agent_message_chunk", () => {
+    it("creates assistant message", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Hello" },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(1);
+      expect(session.messages[0]!.role).toBe("assistant");
+      expect(session.messages[0]!.content).toBe("Hello");
+    });
+
+    it("ignores non-text content", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "image", url: "..." },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(0);
+    });
+  });
+
+  describe("user_message_chunk", () => {
+    it("creates user message", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "user_message_chunk",
+          content: { type: "text", text: "Do the analysis" },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(1);
+      expect(session.messages[0]!.role).toBe("user");
+    });
+  });
+
+  describe("agent_thought_chunk", () => {
+    it("creates assistant message", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "agent_thought_chunk",
+          content: { type: "text", text: "Let me think..." },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(1);
+      expect(session.messages[0]!.role).toBe("assistant");
+      expect(session.messages[0]!.content).toBe("Let me think...");
+    });
+  });
+
+  describe("tool_call", () => {
+    it("creates tool call entry", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "write_file",
+          rawInput: { path: "output/result.json", content: "{}" },
+        }),
+      );
+
+      expect(session.toolCalls).toHaveLength(1);
+      expect(session.toolCalls[0]!.id).toBe("tc-1");
+      expect(session.toolCalls[0]!.name).toBe("write_file");
+      expect(session.toolCalls[0]!.input).toEqual({
+        path: "output/result.json",
+        content: "{}",
+      });
+      expect(session.toolCalls[0]!.startTime).toBeInstanceOf(Date);
+    });
+
+    it("generates ID when toolCallId is missing", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          title: "read_file",
+          rawInput: {},
+        }),
+      );
+
+      expect(session.toolCalls[0]!.id).toBeTruthy();
+      expect(session.toolCalls[0]!.id).toContain("tc_");
+    });
+
+    it("defaults name to unknown when title is missing", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-2",
+        }),
+      );
+
+      expect(session.toolCalls[0]!.name).toBe("unknown");
+    });
+  });
+
+  describe("tool_call_update", () => {
+    it("updates existing tool call with output on completion", () => {
+      const session = makeEmptySession();
+
+      // Create tool call first
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "read_file",
+          rawInput: { path: "input/data.json" },
+        }),
+      );
+
+      // Then update it
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-1",
+          status: "completed",
+          content: [{ type: "text", text: "file contents here" }],
+        }),
+      );
+
+      expect(session.toolCalls[0]!.output).toBe("file contents here");
+      expect(session.toolCalls[0]!.endTime).toBeInstanceOf(Date);
+      expect(session.toolCalls[0]!.error).toBeUndefined();
+    });
+
+    it("sets error on failed status", () => {
+      const session = makeEmptySession();
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "read_file",
+          rawInput: {},
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-1",
+          status: "failed",
+        }),
+      );
+
+      expect(session.toolCalls[0]!.error).toBe("Tool call failed");
+      expect(session.toolCalls[0]!.endTime).toBeInstanceOf(Date);
+    });
+
+    it("handles diff content blocks", () => {
+      const session = makeEmptySession();
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "edit_file",
+          rawInput: {},
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-1",
+          status: "completed",
+          content: [{ type: "diff", diff: "- old\n+ new" }],
+        }),
+      );
+
+      expect(session.toolCalls[0]!.output).toBe("- old\n+ new");
+    });
+
+    it("concatenates multiple content blocks", () => {
+      const session = makeEmptySession();
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "search",
+          rawInput: {},
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-1",
+          status: "completed",
+          content: [
+            { type: "text", text: "Result 1" },
+            { type: "text", text: "Result 2" },
+          ],
+        }),
+      );
+
+      expect(session.toolCalls[0]!.output).toBe("Result 1\nResult 2");
+    });
+
+    it("ignores update for non-existent tool call", () => {
+      const session = makeEmptySession();
+
+      // Update without a preceding tool_call — should not throw
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "nonexistent",
+          status: "completed",
+          content: [{ type: "text", text: "output" }],
+        }),
+      );
+
+      expect(session.toolCalls).toHaveLength(0);
+    });
+  });
+
+  describe("plan", () => {
+    it("creates assistant message with plan content", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "plan",
+          plan: { steps: ["step1", "step2"] },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(1);
+      expect(session.messages[0]!.role).toBe("assistant");
+      expect(session.messages[0]!.content).toContain("[Plan]");
+    });
+  });
+
+  describe("unknown events", () => {
+    it("stores update type in metadata", () => {
+      const session = makeEmptySession();
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "compaction_started",
+        }),
+      );
+
+      expect(session.metadata.lastUpdate).toBe("compaction_started");
+    });
+  });
+
+  describe("interleaved events", () => {
+    it("handles messages interleaved with tool calls", () => {
+      const session = makeEmptySession();
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Let me read the file" },
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "read_file",
+          rawInput: { path: "input/data.json" },
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call_update",
+          toolCallId: "tc-1",
+          status: "completed",
+          content: [{ type: "text", text: "{}" }],
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Now I'll write the output" },
+        }),
+      );
+
+      updateSessionFromEvent(
+        session,
+        makeUpdate({
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-2",
+          title: "write_file",
+          rawInput: { path: "output/result.json" },
+        }),
+      );
+
+      expect(session.messages).toHaveLength(2);
+      expect(session.toolCalls).toHaveLength(2);
+      expect(session.toolCalls[0]!.output).toBe("{}");
+      expect(session.toolCalls[1]!.name).toBe("write_file");
+    });
+  });
+});

package/src/cognitive/__tests__/workspace-handler.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Workspace Handler Tests
+ *
+ * Tests the bridge between OpenHive's workspace.execute MAP messages
+ * and MacroAgentBackend. Uses mocked backend to verify:
+ * - Message parsing and routing
+ * - Spawn config construction from workspace params
+ * - Result collection from workspace output directory
+ * - Error handling and timeout
+ * - Response message format
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import {
+  handleWorkspaceExecute,
+  isWorkspaceExecuteMessage,
+  type WorkspaceHandlerDeps,
+  type WorkspaceExecuteParams,
+} from "../workspace-handler.js";
+import type { MacroAgentBackend } from "../macro-agent-backend.js";
+import type { CognitiveAgentSession } from "../types.js";
+
+function createMockSession(overrides?: Partial<CognitiveAgentSession>): CognitiveAgentSession {
+  return {
+    id: "cognitive_test123",
+    agentType: "claude-code",
+    task: { description: "test task" },
+    state: "completed",
+    messages: [],
+    toolCalls: [],
+    startTime: new Date(),
+    endTime: new Date(),
+    metadata: {},
+    ...overrides,
+  };
+}
+
+function createMockBackend(session?: CognitiveAgentSession): MacroAgentBackend {
+  const mockSession = session || createMockSession();
+  return {
+    name: "macro-agent",
+    supportedTypes: ["claude-code"],
+    spawn: vi.fn().mockResolvedValue(mockSession),
+    getSession: vi.fn().mockResolvedValue(mockSession),
+    terminate: vi.fn().mockResolvedValue(undefined),
+    isAvailable: vi.fn().mockResolvedValue(true),
+    listSessions: vi.fn().mockResolvedValue([mockSession]),
+  } as unknown as MacroAgentBackend;
+}
+
+describe("isWorkspaceExecuteMessage", () => {
+  it("should return true for workspace.execute messages", () => {
+    expect(
+      isWorkspaceExecuteMessage({
+        method: "x-openhive/learning.workspace.execute",
+      }),
+    ).toBe(true);
+  });
+
+  it("should return false for other messages", () => {
+    expect(isWorkspaceExecuteMessage({ method: "ping" })).toBe(false);
+    expect(isWorkspaceExecuteMessage({ method: "_macro/cognitive/command" })).toBe(false);
+    expect(isWorkspaceExecuteMessage({})).toBe(false);
+  });
+});
+
+describe("handleWorkspaceExecute", () => {
+  let sentMessages: object[];
+  let deps: WorkspaceHandlerDeps;
+
+  beforeEach(() => {
+    sentMessages = [];
+  });
+
+  function setupDeps(backend: MacroAgentBackend): WorkspaceHandlerDeps {
+    deps = {
+      backend,
+      sendToHub: (msg) => sentMessages.push(msg),
+    };
+    return deps;
+  }
+
+  it("should spawn an analyst and send success result", async () => {
+    const session = createMockSession({ state: "completed", result: "analysis done" });
+    const backend = createMockBackend(session);
+    setupDeps(backend);
+
+    const params: WorkspaceExecuteParams = {
+      request_id: "req-001",
+      prompt: "Analyze these trajectories",
+      cwd: "/tmp/test-workspace",
+      system_context: "You are an analysis agent",
+      timeout: 5000,
+    };
+
+    await handleWorkspaceExecute(deps, params);
+
+    // Backend should have been called with correct config
+    expect(backend.spawn).toHaveBeenCalledOnce();
+    const spawnCall = (backend.spawn as any).mock.calls[0][0];
+    expect(spawnCall.agentType).toBe("claude-code");
+    expect(spawnCall.task.description).toBe("Analyze these trajectories");
+    expect(spawnCall.cwd).toBe("/tmp/test-workspace");
+    expect(spawnCall.systemPromptAdditions).toBe("You are an analysis agent");
+    expect(spawnCall.timeout).toBe(5000);
+
+    // Result should be sent back
+    expect(sentMessages.length).toBe(1);
+    const result = sentMessages[0] as any;
+    expect(result.jsonrpc).toBe("2.0");
+    expect(result.method).toBe("x-openhive/learning.workspace.result");
+    expect(result.params.request_id).toBe("req-001");
+    expect(result.params.success).toBe(true);
+    expect(result.params.duration_ms).toBeGreaterThanOrEqual(0);
+  });
+
+  it("should send failure result when session fails", async () => {
+    const session = createMockSession({
+      state: "failed",
+      error: "Agent crashed",
+    });
+    const backend = createMockBackend(session);
+    setupDeps(backend);
+
+    await handleWorkspaceExecute(deps, {
+      request_id: "req-002",
+      prompt: "test",
+      cwd: "/tmp/test",
+    });
+
+    const result = sentMessages[0] as any;
+    expect(result.params.success).toBe(false);
+    expect(result.params.error).toBe("Agent crashed");
+  });
+
+  it("should send error result when spawn throws", async () => {
+    const backend = createMockBackend();
+    (backend.spawn as any).mockRejectedValue(new Error("Spawn failed"));
+    setupDeps(backend);
+
+    await handleWorkspaceExecute(deps, {
+      request_id: "req-003",
+      prompt: "test",
+      cwd: "/tmp/test",
+    });
+
+    const result = sentMessages[0] as any;
+    expect(result.params.success).toBe(false);
+    expect(result.params.error).toBe("Spawn failed");
+    expect(result.params.request_id).toBe("req-003");
+  });
+
+  it("should read output files from workspace directory", async () => {
+    // Create a temp workspace with output files
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ws-handler-test-"));
+    const outputDir = path.join(tmpDir, "output");
+    fs.mkdirSync(outputDir);
+    fs.writeFileSync(
+      path.join(outputDir, "analysis.json"),
+      JSON.stringify({ success: true, keySteps: [0, 1], abstractable: true }),
+    );
+
+    const session = createMockSession({ state: "completed" });
+    const backend = createMockBackend(session);
+    setupDeps(backend);
+
+    await handleWorkspaceExecute(deps, {
+      request_id: "req-004",
+      prompt: "analyze",
+      cwd: tmpDir,
+    });
+
+    const result = sentMessages[0] as any;
+    expect(result.params.success).toBe(true);
+    expect(result.params.structured).toEqual({
+      success: true,
+      keySteps: [0, 1],
+      abstractable: true,
+    });
+
+    // Cleanup
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it("should use session result as fallback when no output files", async () => {
+    const session = createMockSession({
+      state: "completed",
+      result: { playbooks: ["pb-1"] },
+    });
+    const backend = createMockBackend(session);
+    setupDeps(backend);
+
+    await handleWorkspaceExecute(deps, {
+      request_id: "req-005",
+      prompt: "test",
+      cwd: "/nonexistent/path",
+    });
+
+    const result = sentMessages[0] as any;
+    expect(result.params.success).toBe(true);
+    expect(result.params.structured).toEqual({ playbooks: ["pb-1"] });
+  });
+
+  it("should use default timeout when not specified", async () => {
+    const session = createMockSession();
+    const backend = createMockBackend(session);
+    setupDeps(backend);
+
+    await handleWorkspaceExecute(deps, {
+      request_id: "req-006",
+      prompt: "test",
+      cwd: "/tmp/test",
+    });
+
+    const spawnCall = (backend.spawn as any).mock.calls[0][0];
+    expect(spawnCall.timeout).toBe(300_000);
+  });
+});

package/src/cognitive/analyst-role.ts

@@ -0,0 +1,59 @@
+/**
+ * Analyst Role Definition
+ *
+ * Cognitive analysis agent for Atlas workspace templates.
+ * Minimal capabilities: reads input files, writes output files, calls done().
+ * No git, no spawning, no workspace isolation (cognitive-core manages workspaces).
+ *
+ * Registered programmatically by MacroAgentBackend in Phase 1.
+ * Moves to team YAML in Phase 2.
+ */
+
+import type { RoleDefinition } from "../roles/types.js";
+import {
+  FILE_CAPABILITIES,
+  EXEC_CAPABILITIES,
+  LIFECYCLE_CAPABILITIES,
+} from "../roles/capabilities.js";
+
+export const AnalystRole: RoleDefinition = {
+  name: "analyst",
+  displayName: "Analyst",
+  description: "Cognitive analysis agent for workspace templates",
+
+  capabilities: [
+    FILE_CAPABILITIES.READ,
+    FILE_CAPABILITIES.WRITE,
+    EXEC_CAPABILITIES.COMMAND,
+    LIFECYCLE_CAPABILITIES.DONE,
+  ],
+
+  workspace: {
+    type: "none",
+  },
+
+  lifecycle: {
+    type: "ephemeral",
+    taskBound: true,
+    cascadeTerminate: true,
+    selfCleanup: true,
+  },
+
+  protocol: {
+    subscriptions: [],
+    canEmit: ["WORKER_DONE"],
+  },
+
+  systemPrompt: `You are an analysis agent. Your workspace contains input/ and output/ directories.
+
+1. Read the input files described in your task
+2. Perform the requested analysis
+3. Write your results to output/ in the exact JSON schema specified in the task
+4. Call done({ status: "completed", summary: "Brief description of analysis performed" })
+
+IMPORTANT:
+- Do NOT commit, push, or spawn other agents
+- Do NOT modify files outside the workspace
+- Focus only on reading input, performing analysis, and writing output
+- You MUST call done() when finished`,
+};