macro-agent 0.2.4 → 0.2.6

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

@@ -1,423 +0,0 @@
-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

@@ -1,221 +0,0 @@
-/**
- * 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

@@ -1,59 +0,0 @@
-/**
- * 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`,
-};