macro-agent 0.2.4 → 0.2.6

package/src/agent-detection/registry.ts

@@ -1,200 +0,0 @@
-/**
- * CLI Agent Definitions Registry
- *
- * Maintains a registry of known CLI coding agents with their
- * detection and headless invocation configurations.
- */
-
-import type { CLIAgentDefinition } from "./types.js";
-
-// =============================================================================
-// Built-in Agent Definitions
-// =============================================================================
-
-const CLAUDE_CODE: CLIAgentDefinition = {
-  id: "claude-code",
-  name: "Claude Code",
-  description: "Anthropic's CLI coding agent",
-  binary: "claude",
-  versionArgs: ["--version"],
-  headless: {
-    promptFlag: "-p",
-    defaultFlags: ["--output-format", "stream-json"],
-  },
-  modelFlag: "--model",
-  cwdFlag: "--cwd",
-  vendor: "Anthropic",
-};
-
-const CODEX: CLIAgentDefinition = {
-  id: "codex",
-  name: "Codex",
-  description: "OpenAI's CLI coding agent",
-  binary: "codex",
-  versionArgs: ["--version"],
-  headless: {
-    subcommand: "exec",
-    promptFlag: "",
-    defaultFlags: ["--full-auto"],
-  },
-  modelFlag: "--model",
-  cwdFlag: "--path",
-  vendor: "OpenAI",
-};
-
-const GEMINI_CLI: CLIAgentDefinition = {
-  id: "gemini-cli",
-  name: "Gemini CLI",
-  description: "Google's CLI coding agent",
-  binary: "gemini",
-  versionArgs: ["--version"],
-  headless: {
-    promptFlag: "-p",
-  },
-  modelFlag: "--model",
-  vendor: "Google",
-};
-
-const OPENCODE: CLIAgentDefinition = {
-  id: "opencode",
-  name: "OpenCode",
-  description: "Anomaly's CLI coding agent",
-  binary: "opencode",
-  versionArgs: ["--version"],
-  headless: {
-    subcommand: "run",
-    promptFlag: "",
-  },
-  modelFlag: "--model",
-  vendor: "Anomaly",
-};
-
-const AIDER: CLIAgentDefinition = {
-  id: "aider",
-  name: "Aider",
-  description: "AI pair programming in your terminal",
-  binary: "aider",
-  versionArgs: ["--version"],
-  headless: {
-    promptFlag: "--message",
-    defaultFlags: ["--yes"],
-  },
-  modelFlag: "--model",
-  vendor: "Aider",
-};
-
-const GOOSE: CLIAgentDefinition = {
-  id: "goose",
-  name: "Goose",
-  description: "Block's CLI coding agent",
-  binary: "goose",
-  versionArgs: ["--version"],
-  headless: {
-    subcommand: "run",
-    promptFlag: "-t",
-    defaultFlags: ["--no-session"],
-  },
-  modelFlag: "--model",
-  vendor: "Block",
-};
-
-/**
- * All built-in agent definitions.
- */
-export const BUILTIN_AGENTS: readonly CLIAgentDefinition[] = [
-  CLAUDE_CODE,
-  CODEX,
-  GEMINI_CLI,
-  OPENCODE,
-  AIDER,
-  GOOSE,
-];
-
-// =============================================================================
-// Agent Registry
-// =============================================================================
-
-/**
- * Registry of known CLI coding agent definitions.
- *
- * Provides lookup by ID and supports adding custom agent definitions.
- */
-export class AgentRegistry {
-  private readonly agents: Map<string, CLIAgentDefinition> = new Map();
-
-  constructor(definitions?: CLIAgentDefinition[]) {
-    // Register built-in agents
-    for (const def of BUILTIN_AGENTS) {
-      this.agents.set(def.id, def);
-    }
-
-    // Register additional definitions
-    if (definitions) {
-      for (const def of definitions) {
-        this.agents.set(def.id, def);
-      }
-    }
-  }
-
-  /**
-   * Get an agent definition by ID.
-   */
-  get(id: string): CLIAgentDefinition | undefined {
-    return this.agents.get(id);
-  }
-
-  /**
-   * Check if an agent definition exists.
-   */
-  has(id: string): boolean {
-    return this.agents.has(id);
-  }
-
-  /**
-   * Register a new agent definition (or override an existing one).
-   */
-  register(definition: CLIAgentDefinition): void {
-    this.agents.set(definition.id, definition);
-  }
-
-  /**
-   * Remove an agent definition by ID.
-   */
-  remove(id: string): boolean {
-    return this.agents.delete(id);
-  }
-
-  /**
-   * List all registered agent definitions.
-   */
-  list(): CLIAgentDefinition[] {
-    return Array.from(this.agents.values());
-  }
-
-  /**
-   * List agent definitions, optionally excluding disabled agents.
-   */
-  listEnabled(disabledIds?: string[]): CLIAgentDefinition[] {
-    if (!disabledIds || disabledIds.length === 0) {
-      return this.list();
-    }
-    const disabled = new Set(disabledIds);
-    return this.list().filter((def) => !disabled.has(def.id));
-  }
-
-  /**
-   * Get the number of registered agent definitions.
-   */
-  get size(): number {
-    return this.agents.size;
-  }
-}
-
-/**
- * Create a new AgentRegistry with built-in agents and optional custom definitions.
- */
-export function createAgentRegistry(
-  additionalAgents?: CLIAgentDefinition[]
-): AgentRegistry {
-  return new AgentRegistry(additionalAgents);
-}

package/src/agent-detection/types.ts

@@ -1,184 +0,0 @@
-/**
- * CLI Agent Auto-Detection Types
- *
- * Type definitions for detecting installed CLI coding agents
- * and constructing headless invocation commands.
- */
-
-// =============================================================================
-// Agent Definition
-// =============================================================================
-
-/**
- * Headless invocation configuration for a CLI agent.
- */
-export interface HeadlessConfig {
-  /** Subcommand before prompt (e.g., "exec" for codex, "run" for goose) */
-  subcommand?: string;
-
-  /** Flag to pass the prompt. Empty string means prompt is positional. */
-  promptFlag: string;
-
-  /** Default flags always included in headless mode */
-  defaultFlags?: string[];
-}
-
-/**
- * Definition of a known CLI coding agent.
- * Describes how to detect and invoke the agent in headless mode.
- */
-export interface CLIAgentDefinition {
-  /** Unique identifier (e.g., "claude-code", "codex") */
-  id: string;
-
-  /** Human-readable display name */
-  name: string;
-
-  /** Short description */
-  description: string;
-
-  /** The binary/command name to invoke */
-  binary: string;
-
-  /** Arguments to check version (typically ["--version"]) */
-  versionArgs: string[];
-
-  /** Headless invocation configuration */
-  headless: HeadlessConfig;
-
-  /** Flag for model selection (e.g., "--model") */
-  modelFlag?: string;
-
-  /** Flag for working directory (e.g., "--cwd", "--path") */
-  cwdFlag?: string;
-
-  /** Provider/vendor name */
-  vendor: string;
-}
-
-// =============================================================================
-// Detection Results
-// =============================================================================
-
-/**
- * Result of detecting a single CLI agent on the system.
- */
-export interface DetectedAgent {
-  /** Agent definition ID */
-  id: string;
-
-  /** Human-readable name */
-  name: string;
-
-  /** Whether the binary was found on PATH */
-  installed: boolean;
-
-  /** Parsed version string (e.g., "1.2.3") */
-  version?: string;
-
-  /** Absolute path to binary */
-  path?: string;
-
-  /** The full agent definition (for client display) */
-  definition: CLIAgentDefinition;
-
-  /** When detection was performed (epoch ms) */
-  detectedAt: number;
-}
-
-/**
- * Result of a full detection scan across all known agents.
- */
-export interface DetectionResult {
-  /** All agents (installed and not installed) */
-  agents: DetectedAgent[];
-
-  /** Number of agents scanned */
-  scanned: number;
-
-  /** Detection duration in milliseconds */
-  durationMs: number;
-
-  /** Whether detection is still in progress */
-  pending?: boolean;
-}
-
-// =============================================================================
-// Command Builder
-// =============================================================================
-
-/**
- * Options for building a spawn command.
- */
-export interface SpawnCommandOptions {
-  /** Model to use (passed via modelFlag) */
-  model?: string;
-
-  /** Working directory (passed via cwdFlag) */
-  cwd?: string;
-}
-
-/**
- * Result of building a spawn command.
- */
-export interface SpawnCommand {
-  /** The binary/command to execute */
-  command: string;
-
-  /** Arguments to pass to the command */
-  args: string[];
-}
-
-// =============================================================================
-// Detection Configuration
-// =============================================================================
-
-/**
- * Configuration for the agent detection system.
- */
-export interface AgentDetectionConfig {
-  /** Whether agent detection is enabled (default: true) */
-  enabled?: boolean;
-
-  /** Cache TTL in milliseconds (default: 60000) */
-  cacheTtlMs?: number;
-
-  /** Timeout for `which` calls in milliseconds (default: 5000) */
-  whichTimeoutMs?: number;
-
-  /** Timeout for version checks in milliseconds (default: 10000) */
-  versionTimeoutMs?: number;
-
-  /** Additional custom agent definitions to include */
-  additionalAgents?: CLIAgentDefinition[];
-
-  /** Agent IDs to exclude from detection */
-  disabledAgents?: string[];
-}
-
-// =============================================================================
-// Errors
-// =============================================================================
-
-/**
- * Error codes for agent detection operations.
- */
-export type AgentDetectionErrorCode =
-  | "UNKNOWN_AGENT"
-  | "AGENT_NOT_INSTALLED"
-  | "DETECTION_FAILED"
-  | "DETECTION_TIMEOUT";
-
-/**
- * Error thrown by agent detection operations.
- */
-export class AgentDetectionError extends Error {
-  constructor(
-    message: string,
-    public readonly code: AgentDetectionErrorCode,
-    public readonly agentId?: string
-  ) {
-    super(message);
-    this.name = "AgentDetectionError";
-  }
-}

package/src/api/__tests__/server.test.ts

@@ -1,292 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import supertest from "supertest";
-import { createApiServer } from "../server.js";
-import type { MacroAgentSystemV2 } from "../../boot-v2.js";
-
-// =============================================================================
-// Mock System
-// =============================================================================
-
-function createMockSystem(): MacroAgentSystemV2 {
-  return {
-    agentManager: {
-      get: vi.fn(),
-      list: vi.fn().mockReturnValue([]),
-      getHierarchy: vi.fn(),
-      getChildren: vi.fn().mockReturnValue([]),
-      spawn: vi.fn(),
-      terminate: vi.fn(),
-      resume: vi.fn(),
-      continueAgent: vi.fn(),
-      forkAgent: vi.fn(),
-      prompt: vi.fn(),
-      promptUntilDone: vi.fn(),
-      getSession: vi.fn(),
-      hasActiveSession: vi.fn(),
-      isPrompting: vi.fn(),
-      supportsInjection: vi.fn(),
-      isProcessRunning: vi.fn(),
-      respondToPermission: vi.fn(),
-      cancelPermission: vi.fn(),
-      setPermissionMode: vi.fn(),
-      getPermissionMode: vi.fn(),
-      getOrCreateHeadManager: vi.fn(),
-      listHeadManagers: vi.fn().mockReturnValue([]),
-      onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
-      setSpawnInterceptor: vi.fn(),
-      getRoleRegistry: vi.fn(),
-      setOpenTasksSocketPath: vi.fn(),
-      close: vi.fn(),
-    } as any,
-    agentStore: {
-      listAgents: vi.fn().mockReturnValue([]),
-      getAgent: vi.fn(),
-    } as any,
-    inboxAdapter: {
-      checkInbox: vi.fn().mockResolvedValue([]),
-    } as any,
-    tasksAdapter: {
-      listTasks: vi.fn().mockResolvedValue([]),
-      queryReady: vi.fn().mockResolvedValue([]),
-      connected: true,
-    } as any,
-    controlServer: {
-      getUnhealthyAgents: vi.fn().mockReturnValue([]),
-    } as any,
-    triggerSystem: {
-      queue: {
-        getAgentsWithEvents: vi.fn().mockReturnValue([]),
-      },
-    } as any,
-    roleRegistry: {} as any,
-    controlSocketPath: "/tmp/test-control.sock",
-    shutdown: vi.fn(),
-  };
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe("API Server", () => {
-  let system: MacroAgentSystemV2;
-  let request: supertest.SuperTest<supertest.Test>;
-
-  beforeEach(() => {
-    system = createMockSystem();
-    const server = createApiServer(system, { port: 0 });
-    request = supertest(server.app) as any;
-  });
-
-  // ── Health ───────────────────────────────────────────────────────
-
-  it("GET /api/health returns 200 with ok: true", async () => {
-    const res = await request.get("/api/health");
-    expect(res.status).toBe(200);
-    expect(res.body.ok).toBe(true);
-    expect(res.body.version).toBe("0.1.1");
-    expect(typeof res.body.uptime).toBe("number");
-  });
-
-  // ── Agents ──────────────────────────────────────────────────────
-
-  it("GET /api/agents returns agent list", async () => {
-    const mockAgents = [
-      { id: "a1", role: "worker", state: "running", task: "do stuff" },
-      { id: "a2", role: "coordinator", state: "running", task: "manage" },
-    ];
-    (system.agentManager.list as any).mockReturnValue(mockAgents);
-
-    const res = await request.get("/api/agents");
-    expect(res.status).toBe(200);
-    expect(res.body.agents).toHaveLength(2);
-    expect(res.body.total).toBe(2);
-  });
-
-  it("GET /api/agents with state filter", async () => {
-    const mockAgents = [
-      { id: "a1", role: "worker", state: "running", task: "do stuff" },
-    ];
-    (system.agentManager.list as any).mockReturnValue(mockAgents);
-
-    const res = await request.get("/api/agents?state=running");
-    expect(res.status).toBe(200);
-    expect((system.agentManager.list as any)).toHaveBeenCalledWith(
-      expect.objectContaining({ state: "running" })
-    );
-    expect(res.body.agents).toHaveLength(1);
-  });
-
-  it("GET /api/agents/:id returns agent", async () => {
-    const mockAgent = {
-      id: "a1",
-      role: "worker",
-      state: "running",
-      task: "do stuff",
-    };
-    (system.agentManager.get as any).mockReturnValue(mockAgent);
-
-    const res = await request.get("/api/agents/a1");
-    expect(res.status).toBe(200);
-    expect(res.body.id).toBe("a1");
-  });
-
-  it("GET /api/agents/:id returns 404 for missing", async () => {
-    (system.agentManager.get as any).mockReturnValue(null);
-
-    const res = await request.get("/api/agents/nonexistent");
-    expect(res.status).toBe(404);
-    expect(res.body.error).toBe("Agent not found");
-  });
-
-  it("GET /api/agents/:id/hierarchy returns tree", async () => {
-    const mockHierarchy = {
-      root: {
-        agent: { id: "a1", role: "coordinator" },
-        children: [
-          { agent: { id: "a2", role: "worker" }, children: [] },
-        ],
-      },
-      depth: 2,
-      totalAgents: 2,
-    };
-    (system.agentManager.getHierarchy as any).mockReturnValue(mockHierarchy);
-
-    const res = await request.get("/api/agents/a1/hierarchy");
-    expect(res.status).toBe(200);
-    expect(res.body.root.agent.id).toBe("a1");
-    expect(res.body.totalAgents).toBe(2);
-  });
-
-  it("GET /api/agents/:id/hierarchy returns 404 for missing", async () => {
-    (system.agentManager.getHierarchy as any).mockReturnValue(null);
-
-    const res = await request.get("/api/agents/nonexistent/hierarchy");
-    expect(res.status).toBe(404);
-  });
-
-  // ── Spawn / Delete ──────────────────────────────────────────────
-
-  it("POST /api/agents spawns agent", async () => {
-    const mockSpawned = { id: "a-new", session_id: "s1" };
-    (system.agentManager.spawn as any).mockResolvedValue(mockSpawned);
-
-    const res = await request
-      .post("/api/agents")
-      .send({ task: "build feature X", role: "worker" });
-
-    expect(res.status).toBe(201);
-    expect(res.body.id).toBe("a-new");
-    expect((system.agentManager.spawn as any)).toHaveBeenCalledWith(
-      expect.objectContaining({ task: "build feature X", role: "worker" })
-    );
-  });
-
-  it("POST /api/agents returns 400 when task is missing", async () => {
-    const res = await request.post("/api/agents").send({});
-    expect(res.status).toBe(400);
-    expect(res.body.error).toContain("task");
-  });
-
-  it("DELETE /api/agents/:id terminates", async () => {
-    (system.agentManager.get as any).mockReturnValue({
-      id: "a1",
-      state: "running",
-    });
-    (system.agentManager.terminate as any).mockResolvedValue(undefined);
-
-    const res = await request.delete("/api/agents/a1?reason=cancelled");
-    expect(res.status).toBe(200);
-    expect(res.body.ok).toBe(true);
-    expect((system.agentManager.terminate as any)).toHaveBeenCalledWith(
-      "a1",
-      "cancelled"
-    );
-  });
-
-  it("DELETE /api/agents/:id returns 404 for missing", async () => {
-    (system.agentManager.get as any).mockReturnValue(null);
-
-    const res = await request.delete("/api/agents/nonexistent");
-    expect(res.status).toBe(404);
-  });
-
-  // ── Tasks ───────────────────────────────────────────────────────
-
-  it("GET /api/tasks returns tasks", async () => {
-    const mockTasks = [
-      { id: "t1", title: "Task 1", status: "open" },
-      { id: "t2", title: "Task 2", status: "in_progress" },
-    ];
-    (system.tasksAdapter.listTasks as any).mockResolvedValue(mockTasks);
-
-    const res = await request.get("/api/tasks");
-    expect(res.status).toBe(200);
-    expect(res.body.tasks).toHaveLength(2);
-  });
-
-  it("GET /api/tasks/ready returns ready tasks", async () => {
-    const mockTasks = [{ id: "t1", title: "Ready Task", status: "open" }];
-    (system.tasksAdapter.queryReady as any).mockResolvedValue(mockTasks);
-
-    const res = await request.get("/api/tasks/ready");
-    expect(res.status).toBe(200);
-    expect(res.body.tasks).toHaveLength(1);
-  });
-
-  // ── Metrics ─────────────────────────────────────────────────────
-
-  it("GET /api/metrics returns snapshot", async () => {
-    (system.agentStore.listAgents as any).mockReturnValue([
-      { state: "running", role: "worker", team: "alpha" },
-      { state: "stopped", role: "coordinator", team: "alpha" },
-    ]);
-    (system.tasksAdapter.listTasks as any).mockResolvedValue([
-      { status: "open" },
-      { status: "closed" },
-    ]);
-
-    const res = await request.get("/api/metrics");
-    expect(res.status).toBe(200);
-    expect(res.body.agents).toBeDefined();
-    expect(res.body.agents.running).toBe(1);
-    expect(res.body.agents.stopped).toBe(1);
-    expect(typeof res.body.uptime).toBe("number");
-  });
-
-  it("GET /api/metrics/agents returns agent metrics", async () => {
-    (system.agentStore.listAgents as any).mockReturnValue([
-      { state: "running" },
-      { state: "running" },
-      { state: "failed" },
-    ]);
-
-    const res = await request.get("/api/metrics/agents");
-    expect(res.status).toBe(200);
-    expect(res.body.total).toBe(3);
-    expect(res.body.running).toBe(2);
-    expect(res.body.failed).toBe(1);
-  });
-
-  // ── Teams ───────────────────────────────────────────────────────
-
-  it("GET /api/teams returns team grouping", async () => {
-    (system.agentStore.listAgents as any).mockReturnValue([
-      { team: "alpha", role: "worker" },
-      { team: "alpha", role: "coordinator" },
-      { team: "beta", role: "worker" },
-    ]);
-
-    const res = await request.get("/api/teams");
-    expect(res.status).toBe(200);
-    expect(res.body.teams).toHaveLength(2);
-
-    const alpha = res.body.teams.find(
-      (t: any) => t.name === "alpha"
-    );
-    expect(alpha).toBeDefined();
-    expect(alpha.agentCount).toBe(2);
-    expect(alpha.roles).toContain("worker");
-    expect(alpha.roles).toContain("coordinator");
-  });
-});

package/src/api/index.ts

@@ -1,8 +0,0 @@
-/**
- * REST API public exports.
- *
- * @module api
- */
-
-export { createApiServer } from "./server.js";
-export type { ApiServer, ApiServerConfig, HealthResponse, ErrorResponse } from "./types.js";