@creativeintelligence/abbie 0.1.0

package/src/lib/agent-adapters.ts

@@ -0,0 +1,412 @@
+/**
+ * Agent Adapter System
+ *
+ * Extensible abstraction for spawning different AI coding agent CLIs.
+ * Each adapter knows how to:
+ * - Build the command line invocation for its agent
+ * - Handle prompt input (stdin, file, or inline)
+ * - Capture output (file, stdout, or streaming)
+ *
+ * Adding a new agent:
+ * 1. Add the agent to Agent enum in types.ts
+ * 2. Create an adapter implementing AgentAdapter
+ * 3. Register it in AGENT_ADAPTERS map
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AgentType } from "./types.js";
+
+/**
+ * Context passed to agent adapters for command building
+ */
+export interface AgentCommandContext {
+  /** Unique session ID */
+  sessionId: string;
+  /** Path to prompt file */
+  promptPath: string;
+  /** Path for output (if agent supports file output) */
+  outputPath: string;
+  /** Working directory */
+  cwd: string;
+  /** Optional model override */
+  model?: string;
+  /** Trace ID for event correlation */
+  traceId?: string;
+  /** Project name */
+  project?: string;
+  /** Environment variables to inject */
+  envVars: Record<string, string>;
+}
+
+/**
+ * Result of building an agent command
+ */
+export interface AgentCommandResult {
+  /** The shell command to execute */
+  command: string;
+  /** Whether the agent writes structured output to outputPath */
+  writesOutputFile: boolean;
+  /** Whether the agent reads prompt from stdin */
+  readsStdin: boolean;
+  /** Session ID environment variable name (for hooks/tracking) */
+  sessionEnvVar: string;
+}
+
+/**
+ * Agent adapter interface
+ */
+export interface AgentAdapter {
+  /** Agent type identifier */
+  readonly type: AgentType;
+  /** Human-readable name */
+  readonly name: string;
+  /** Whether this agent is available (CLI installed) */
+  isAvailable(): Promise<boolean>;
+  /** Build command for terminal mode (tmux window) */
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult;
+  /** Build command for headless mode (subprocess) */
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult;
+}
+
+/**
+ * Base class with common utilities
+ */
+abstract class BaseAdapter implements AgentAdapter {
+  abstract readonly type: AgentType;
+  abstract readonly name: string;
+
+  protected localBin = join(homedir(), ".local", "bin");
+
+  async isAvailable(): Promise<boolean> {
+    const { execSync } = await import("node:child_process");
+    try {
+      execSync(`which ${this.type}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  abstract buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult;
+  abstract buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult;
+
+  protected buildEnvPrefix(ctx: AgentCommandContext): string {
+    const vars = Object.entries(ctx.envVars)
+      .map(([k, v]) => `${k}=${v}`)
+      .join(" ");
+    return vars ? `env ${vars}` : "";
+  }
+
+  protected readPromptContent(promptPath: string): string {
+    if (existsSync(promptPath)) {
+      return readFileSync(promptPath, "utf-8").trim().replace(/'/g, "'\\''");
+    }
+    return "";
+  }
+}
+
+/**
+ * Claude Code adapter
+ */
+class ClaudeAdapter extends BaseAdapter {
+  readonly type = "claude" as const;
+  readonly name = "Claude Code";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const { randomUUID } = require("node:crypto");
+    const claudeSessionId = randomUUID();
+    const claudePath = join(this.localBin, "claude");
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    const command = `cat '${ctx.promptPath}' | ${envPrefix} CLAUDE_SESSION_ID=${ctx.sessionId} '${claudePath}' -p --dangerously-skip-permissions --output-format text --session-id ${claudeSessionId}`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: true,
+      sessionEnvVar: "CLAUDE_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * Codex CLI adapter
+ */
+class CodexAdapter extends BaseAdapter {
+  readonly type = "codex" as const;
+  readonly name = "Codex CLI";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const codexPath = join(this.localBin, "codex");
+    const modelFlag = ctx.model ? ` --model '${ctx.model}'` : "";
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    // Note: codex 0.98.0's `-o` (--output-last-message) doesn't reliably
+    // write the response file. Stdout capture handles output instead.
+    const command = `cat '${ctx.promptPath}' | ${envPrefix} CODEX_SESSION_ID=${ctx.sessionId} '${codexPath}' exec - --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check${modelFlag}`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: true,
+      sessionEnvVar: "CODEX_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * GitHub Copilot CLI adapter
+ */
+class CopilotAdapter extends BaseAdapter {
+  readonly type = "copilot" as const;
+  readonly name = "GitHub Copilot CLI";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const promptContent = this.readPromptContent(ctx.promptPath);
+    const modelFlag = ctx.model ? ` --model '${ctx.model}'` : "";
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    const command = `${envPrefix} COPILOT_SESSION_ID=${ctx.sessionId} copilot -p '${promptContent}' --yolo --stream off${modelFlag}`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: false,
+      sessionEnvVar: "COPILOT_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * Gemini CLI adapter
+ */
+class GeminiAdapter extends BaseAdapter {
+  readonly type = "gemini" as const;
+  readonly name = "Gemini CLI";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const promptContent = this.readPromptContent(ctx.promptPath);
+    const modelFlag = ctx.model ? ` -m '${ctx.model}'` : "";
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    const command = `${envPrefix} GEMINI_SESSION_ID=${ctx.sessionId} gemini -p '${promptContent}'${modelFlag}`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: false,
+      sessionEnvVar: "GEMINI_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * OpenCode adapter (SST's opencode CLI)
+ */
+class OpenCodeAdapter extends BaseAdapter {
+  readonly type = "opencode" as const;
+  readonly name = "OpenCode";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const promptContent = this.readPromptContent(ctx.promptPath);
+    const modelFlag = ctx.model ? ` -m '${ctx.model}'` : "";
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    // opencode run supports JSON format output
+    const command = `${envPrefix} OPENCODE_SESSION_ID=${ctx.sessionId} opencode run '${promptContent}'${modelFlag} --format json`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: false,
+      sessionEnvVar: "OPENCODE_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * Factory Droid adapter
+ */
+class DroidAdapter extends BaseAdapter {
+  readonly type = "droid" as const;
+  readonly name = "Factory Droid";
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const promptContent = this.readPromptContent(ctx.promptPath);
+    const modelFlag = ctx.model ? ` --model '${ctx.model}'` : "";
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    // droid supports interactive mode by default, use -m for message mode
+    const command = `${envPrefix} DROID_SESSION_ID=${ctx.sessionId} droid -m '${promptContent}'${modelFlag}`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: false,
+      sessionEnvVar: "DROID_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * Pi coding agent adapter
+ */
+class PiAdapter extends BaseAdapter {
+  readonly type = "pi" as const;
+  readonly name = "Pi Coding Agent";
+
+  async isAvailable(): Promise<boolean> {
+    // Pi may be installed via npm link from the fork
+    const { execSync } = await import("node:child_process");
+    try {
+      execSync("which pi", { stdio: "ignore" });
+      return true;
+    } catch {
+      // Check if fork exists and is built
+      const forkPath = join(
+        homedir(),
+        "Developer",
+        "forks",
+        "pi-mono",
+        "packages",
+        "coding-agent",
+        "dist",
+        "cli.js",
+      );
+      return existsSync(forkPath);
+    }
+  }
+
+  buildTerminalCommand(ctx: AgentCommandContext): AgentCommandResult {
+    const promptContent = this.readPromptContent(ctx.promptPath);
+    const envPrefix = this.buildEnvPrefix(ctx);
+
+    // Disable extensions for orchestrated runs so a broken local extension
+    // cannot block session startup.
+    const modelFlags = ctx.model
+      ? ` --model '${ctx.model}'`
+      : " --provider google --model gemini-2.5-flash-lite";
+
+    // pi supports interactive mode, -p for prompt
+    const command = `${envPrefix} PI_SESSION_ID=${ctx.sessionId} pi --no-extensions${modelFlags} -p '${promptContent}'`;
+
+    return {
+      command,
+      writesOutputFile: false,
+      readsStdin: false,
+      sessionEnvVar: "PI_SESSION_ID",
+    };
+  }
+
+  buildHeadlessCommand(ctx: AgentCommandContext): AgentCommandResult {
+    return this.buildTerminalCommand(ctx);
+  }
+}
+
+/**
+ * Registry of all agent adapters
+ */
+export const AGENT_ADAPTERS: Record<AgentType, AgentAdapter> = {
+  claude: new ClaudeAdapter(),
+  codex: new CodexAdapter(),
+  copilot: new CopilotAdapter(),
+  gemini: new GeminiAdapter(),
+  opencode: new OpenCodeAdapter(),
+  droid: new DroidAdapter(),
+  pi: new PiAdapter(),
+};
+
+/**
+ * Get adapter for an agent type
+ */
+export function getAgentAdapter(agent: AgentType): AgentAdapter {
+  const adapter = AGENT_ADAPTERS[agent];
+  if (!adapter) {
+    throw new Error(`Unknown agent type: ${agent}`);
+  }
+  return adapter;
+}
+
+/**
+ * Check which agents are available on the system
+ */
+export async function getAvailableAgents(): Promise<AgentType[]> {
+  const available: AgentType[] = [];
+  for (const [type, adapter] of Object.entries(AGENT_ADAPTERS)) {
+    if (await adapter.isAvailable()) {
+      available.push(type as AgentType);
+    }
+  }
+  return available;
+}
+
+/**
+ * All agents (flat list — no core/extended distinction)
+ */
+export const ALL_AGENTS = Object.values(AGENT_ADAPTERS).map((a) => a.type);
+
+/**
+ * Agent metadata for display
+ */
+export const AGENT_METADATA: Record<
+  AgentType,
+  { name: string; description: string; installCmd?: string }
+> = {
+  claude: {
+    name: "Claude Code",
+    description: "Anthropic's official CLI for Claude",
+  },
+  codex: {
+    name: "Codex CLI",
+    description: "OpenAI's coding agent CLI",
+  },
+  copilot: {
+    name: "GitHub Copilot CLI",
+    description: "GitHub Copilot in the terminal",
+  },
+  gemini: {
+    name: "Gemini CLI",
+    description: "Google's Gemini CLI",
+  },
+  opencode: {
+    name: "OpenCode",
+    description: "SST's open source coding agent (multi-provider)",
+    installCmd: "curl -fsSL https://opencode.ai/install | bash",
+  },
+  droid: {
+    name: "Factory Droid",
+    description: "Factory AI's enterprise coding agent",
+    installCmd: "curl -fsSL https://app.factory.ai/cli | sh",
+  },
+  pi: {
+    name: "Pi Coding Agent",
+    description: "Extensible TypeScript coding agent",
+    installCmd: "npm install -g @mariozechner/pi-coding-agent",
+  },
+};