@ag-eco/agentplate-cli 0.13.0

package/src/runtimes/gemini.ts

@@ -0,0 +1,243 @@
+// Gemini CLI runtime adapter for agentplate's AgentRuntime interface.
+// Implements the AgentRuntime contract for Google's `gemini` CLI.
+//
+// Key characteristics:
+// - TUI: `gemini` maintains an interactive Ink-based TUI in tmux
+// - Instruction file: GEMINI.md (read automatically from workspace root)
+// - No hooks: Gemini CLI has no hook/guard mechanism (like Copilot)
+// - Sandbox: `--sandbox` flag + `--approval-mode yolo` for bypass
+// - Headless: `gemini -p "prompt"` for one-shot calls
+// - Transcripts: `--output-format stream-json` produces NDJSON events
+
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { ResolvedModel } from "../types.ts";
+import type {
+	AgentRuntime,
+	HooksDef,
+	OverlayContent,
+	ReadyState,
+	SpawnOpts,
+	TranscriptSummary,
+} from "./types.ts";
+
+/**
+ * Gemini CLI runtime adapter.
+ *
+ * Implements AgentRuntime for Google's `gemini` CLI (Gemini coding agent).
+ * Gemini maintains an interactive Ink-based TUI, similar to Copilot.
+ *
+ * Security: Gemini CLI supports `--sandbox` for filesystem isolation
+ * (Seatbelt on macOS, container-based on Linux) but has no hook/guard
+ * mechanism for per-tool interception. The `_hooks` parameter in
+ * `deployConfig` is unused.
+ *
+ * Instructions are delivered via `GEMINI.md` (Gemini's native context
+ * file convention), which the CLI reads automatically from the workspace.
+ */
+export class GeminiRuntime implements AgentRuntime {
+	/** Unique identifier for this runtime. */
+	readonly id = "gemini";
+
+	/** Stability level. Gemini adapter is experimental — not fully validated. */
+	readonly stability = "experimental" as const;
+
+	/** Relative path to the instruction file within a worktree. */
+	readonly instructionPath = "GEMINI.md";
+
+	/**
+	 * Build the shell command string to spawn an interactive Gemini agent.
+	 *
+	 * Maps SpawnOpts to `gemini` CLI flags:
+	 * - `model` → `-m <model>`
+	 * - `permissionMode === "bypass"` → `--approval-mode yolo`
+	 * - `permissionMode === "ask"` → no approval flag
+	 * - `appendSystemPrompt` and `appendSystemPromptFile` are IGNORED —
+	 *   the `gemini` CLI has no `--append-system-prompt` equivalent.
+	 *   Role definitions are deployed via GEMINI.md instead.
+	 *
+	 * @param opts - Spawn options (model, permissionMode; appendSystemPrompt ignored)
+	 * @returns Shell command string suitable for tmux new-session -c
+	 */
+	buildSpawnCommand(opts: SpawnOpts): string {
+		let cmd = `gemini -m ${opts.model}`;
+
+		if (opts.permissionMode === "bypass") {
+			cmd += " --approval-mode yolo";
+		}
+
+		// appendSystemPrompt and appendSystemPromptFile are intentionally ignored.
+		// The gemini CLI has no --append-system-prompt equivalent. Role definitions
+		// are deployed via GEMINI.md (the instruction file) by deployConfig().
+
+		return cmd;
+	}
+
+	/**
+	 * Build the argv array for a headless one-shot Gemini invocation.
+	 *
+	 * Returns an argv array suitable for `Bun.spawn()`. The `-p` flag
+	 * triggers headless mode — the CLI processes the prompt (including tool
+	 * invocations) and exits. `--yolo` auto-approves tool calls; without it,
+	 * unapproved tool calls fail rather than hang.
+	 *
+	 * Used by merge/resolver.ts and watchdog/triage.ts for AI-assisted operations.
+	 *
+	 * @param prompt - The prompt to pass via `-p`
+	 * @param model - Optional model override
+	 * @returns Argv array for Bun.spawn
+	 */
+	buildPrintCommand(prompt: string, model?: string): string[] {
+		const cmd = ["gemini", "-p", prompt, "--yolo"];
+		if (model !== undefined) {
+			cmd.push("-m", model);
+		}
+		return cmd;
+	}
+
+	/**
+	 * Deploy per-agent instructions to a worktree.
+	 *
+	 * Writes the overlay to `GEMINI.md` in the worktree root (Gemini's
+	 * native context file convention). The CLI reads GEMINI.md automatically
+	 * when starting in a directory that contains one.
+	 *
+	 * The `hooks` parameter is unused — Gemini CLI has no hook mechanism
+	 * for per-tool interception. Security depends on `--sandbox` and
+	 * `--approval-mode` flags instead.
+	 *
+	 * @param worktreePath - Absolute path to the agent's git worktree
+	 * @param overlay - Overlay content to write as GEMINI.md, or undefined to skip
+	 * @param _hooks - Unused for Gemini runtime
+	 */
+	async deployConfig(
+		worktreePath: string,
+		overlay: OverlayContent | undefined,
+		_hooks: HooksDef,
+	): Promise<void> {
+		if (!overlay) return;
+
+		const geminiPath = join(worktreePath, this.instructionPath);
+		await mkdir(dirname(geminiPath), { recursive: true });
+		await Bun.write(geminiPath, overlay.content);
+	}
+
+	/**
+	 * Detect Gemini TUI readiness from a tmux pane content snapshot.
+	 *
+	 * Gemini uses an Ink-based React TUI. Detection requires both a
+	 * prompt indicator AND a Gemini branding indicator:
+	 *
+	 * - Prompt: "> " prefix, placeholder "type your message", or U+276F (❯)
+	 * - Branding: "gemini" visible in the TUI header or status area
+	 *
+	 * No trust dialog phase exists for Gemini (unlike Claude Code).
+	 *
+	 * @param paneContent - Captured tmux pane content to analyze
+	 * @returns Current readiness phase (never "dialog" for Gemini)
+	 */
+	detectReady(paneContent: string): ReadyState {
+		const lower = paneContent.toLowerCase();
+
+		// Prompt indicator: placeholder text, "> " at line start, or ❯ character.
+		const hasPrompt =
+			lower.includes("type your message") ||
+			/^> /m.test(paneContent) ||
+			paneContent.includes("\u276f");
+
+		// Branding indicator: "gemini" visible in TUI header/status.
+		const hasGemini = lower.includes("gemini");
+
+		if (hasPrompt && hasGemini) {
+			return { phase: "ready" };
+		}
+
+		return { phase: "loading" };
+	}
+
+	/**
+	 * Parse a Gemini NDJSON transcript file into normalized token usage.
+	 *
+	 * Gemini's `--output-format stream-json` produces NDJSON with these events:
+	 * - `init`: carries `model` and `session_id`
+	 * - `message`: user/assistant messages (content chunks when delta=true)
+	 * - `tool_use` / `tool_result`: tool call lifecycle
+	 * - `result`: final event with `stats.input_tokens` and `stats.output_tokens`
+	 *
+	 * Returns null if the file does not exist or cannot be parsed.
+	 *
+	 * @param path - Absolute path to the Gemini NDJSON transcript file
+	 * @returns Aggregated token usage, or null if unavailable
+	 */
+	async parseTranscript(path: string): Promise<TranscriptSummary | null> {
+		const file = Bun.file(path);
+		if (!(await file.exists())) {
+			return null;
+		}
+
+		try {
+			const text = await file.text();
+			const lines = text.split("\n").filter((l) => l.trim().length > 0);
+
+			let inputTokens = 0;
+			let outputTokens = 0;
+			let model = "";
+
+			for (const line of lines) {
+				let event: Record<string, unknown>;
+				try {
+					event = JSON.parse(line) as Record<string, unknown>;
+				} catch {
+					// Skip malformed lines — partial writes during capture.
+					continue;
+				}
+
+				// Model from init event.
+				if (event.type === "init" && typeof event.model === "string") {
+					model = event.model;
+				}
+
+				// Token usage from result event's stats field.
+				if (event.type === "result" && typeof event.stats === "object" && event.stats !== null) {
+					const stats = event.stats as Record<string, unknown>;
+					const inp = stats.input_tokens;
+					const out = stats.output_tokens;
+					if (typeof inp === "number") {
+						inputTokens += inp;
+					}
+					if (typeof out === "number") {
+						outputTokens += out;
+					}
+				}
+
+				// Fallback: capture model from any event that carries it.
+				if (typeof event.model === "string" && event.model && !model) {
+					model = event.model;
+				}
+			}
+
+			return { inputTokens, outputTokens, model };
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Build runtime-specific environment variables for model/provider routing.
+	 *
+	 * Returns the provider environment variables from the resolved model.
+	 * For Google native: may include GEMINI_API_KEY.
+	 * For gateway providers: may include gateway-specific auth and routing vars.
+	 *
+	 * @param model - Resolved model with optional provider env vars
+	 * @returns Environment variable map (may be empty)
+	 */
+	buildEnv(model: ResolvedModel): Record<string, string> {
+		return model.env ?? {};
+	}
+
+	/** Gemini does not produce transcript files. */
+	getTranscriptDir(_projectRoot: string): string | null {
+		return null;
+	}
+}

package/src/runtimes/goose.test.ts

@@ -0,0 +1,133 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { GooseRuntime } from "./goose.ts";
+
+describe("GooseRuntime", () => {
+	const runtime = new GooseRuntime();
+	let testDir: string;
+
+	beforeEach(async () => {
+		testDir = await mkdtemp(join(tmpdir(), "agentplate-goose-test-"));
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true });
+	});
+
+	it("has correct id and instruction path", () => {
+		expect(runtime.id).toBe("goose");
+		expect(runtime.instructionPath).toBe(".goosehints");
+	});
+
+	it("buildSpawnCommand includes model", () => {
+		const cmd = runtime.buildSpawnCommand({
+			model: "anthropic/claude-sonnet-4-6",
+			permissionMode: "bypass",
+			cwd: "/tmp/test",
+			env: {},
+		});
+		expect(cmd).toContain("goose --model anthropic/claude-sonnet-4-6");
+	});
+
+	it("buildSpawnCommand includes append system prompt with --with-prompt", () => {
+		const cmd = runtime.buildSpawnCommand({
+			model: "sonnet",
+			permissionMode: "bypass",
+			appendSystemPrompt: "You are a builder.",
+			cwd: "/tmp/test",
+			env: {},
+		});
+		expect(cmd).toContain("--with-prompt");
+		expect(cmd).toContain("You are a builder.");
+	});
+
+	it("buildSpawnCommand uses --instructions for appendSystemPromptFile", () => {
+		const cmd = runtime.buildSpawnCommand({
+			model: "sonnet",
+			permissionMode: "bypass",
+			appendSystemPromptFile: "/tmp/role.md",
+			cwd: "/tmp/test",
+			env: {},
+		});
+		expect(cmd).toContain("--instructions '/tmp/role.md'");
+	});
+
+	it("buildPrintCommand returns correct argv", () => {
+		const argv = runtime.buildPrintCommand("scan for bugs");
+		expect(argv[0]).toBe("goose");
+		expect(argv[1]).toBe("run");
+		expect(argv).toContain("--text");
+		expect(argv).toContain("scan for bugs");
+	});
+
+	it("buildPrintCommand includes model when provided", () => {
+		const argv = runtime.buildPrintCommand("scan for bugs", "gpt-4o");
+		expect(argv).toContain("--model");
+		expect(argv).toContain("gpt-4o");
+	});
+
+	it("deployConfig writes .goosehints", async () => {
+		await runtime.deployConfig(
+			testDir,
+			{ content: "# Builder instructions" },
+			{
+				agentName: "builder-1",
+				capability: "builder",
+				worktreePath: testDir,
+			},
+		);
+		const content = await readFile(join(testDir, ".goosehints"), "utf-8");
+		expect(content).toBe("# Builder instructions");
+	});
+
+	it("deployConfig is no-op when overlay is undefined", async () => {
+		await runtime.deployConfig(testDir, undefined, {
+			agentName: "builder-1",
+			capability: "builder",
+			worktreePath: testDir,
+		});
+		const file = Bun.file(join(testDir, ".goosehints"));
+		expect(await file.exists()).toBe(false);
+	});
+
+	it("detectReady requires both prompt AND branding (AND logic)", () => {
+		// Both prompt and branding → ready
+		expect(runtime.detectReady("Goose v1.2.3\n> ").phase).toBe("ready");
+		expect(runtime.detectReady("goose-agent\n❯ ").phase).toBe("ready");
+		expect(runtime.detectReady("( O) ready\n> ").phase).toBe("ready");
+
+		// Prompt only (no branding) → loading
+		expect(runtime.detectReady("thinking...\n> ").phase).toBe("loading");
+
+		// Branding only (no prompt) → loading
+		expect(runtime.detectReady("Goose v1.2.3").phase).toBe("loading");
+		expect(runtime.detectReady("Loading Goose...").phase).toBe("loading");
+
+		// Neither → loading
+		expect(runtime.detectReady("Loading models...").phase).toBe("loading");
+	});
+
+	it("does not require beacon verification", () => {
+		expect(runtime.requiresBeaconVerification()).toBe(false);
+	});
+
+	it("parseTranscript returns null", async () => {
+		expect(await runtime.parseTranscript("/nonexistent")).toBeNull();
+	});
+
+	it("buildEnv returns model env vars", () => {
+		expect(runtime.buildEnv({ model: "sonnet", env: { GOOSE_API_KEY: "key" } })).toEqual({
+			GOOSE_API_KEY: "key",
+		});
+	});
+
+	it("buildEnv returns empty object when no env", () => {
+		expect(runtime.buildEnv({ model: "sonnet" })).toEqual({});
+	});
+
+	it("getTranscriptDir returns null", () => {
+		expect(runtime.getTranscriptDir("/tmp/project")).toBeNull();
+	});
+});

package/src/runtimes/goose.ts

@@ -0,0 +1,157 @@
+// Goose runtime adapter for agentplate's AgentRuntime interface.
+// Implements the AgentRuntime contract for Block's `goose` CLI (AI developer agent).
+//
+// Key differences from Claude/Pi adapters:
+// - Interactive: `goose` runs as a REPL session in tmux
+// - Instruction file: .goosehints (Goose's native instruction file)
+// - No hooks: Goose uses profile-based permissions, not PreToolUse hooks
+// - One-shot calls use `goose run --text <prompt>`
+// - Model is passed via `--model <model>` (or GOOSE_MODEL env var)
+
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { ResolvedModel } from "../types.ts";
+import type {
+	AgentRuntime,
+	HooksDef,
+	OverlayContent,
+	ReadyState,
+	SpawnOpts,
+	TranscriptSummary,
+} from "./types.ts";
+
+/**
+ * Goose runtime adapter.
+ *
+ * Implements AgentRuntime for Block's `goose` CLI. Goose agents run
+ * as interactive REPL sessions with configurable toolkits (developer,
+ * screen, github, etc.).
+ *
+ * Security is managed via Goose profiles which control which toolkits
+ * and permissions are available. No OS-level sandbox.
+ */
+export class GooseRuntime implements AgentRuntime {
+	readonly id = "goose";
+
+	/** Experimental — community-contributed adapter, not yet battle-tested in production. */
+	readonly stability = "experimental" as const;
+
+	/**
+	 * Goose reads .goosehints from the repo root for project-level instructions.
+	 */
+	readonly instructionPath = ".goosehints";
+
+	/**
+	 * Build the shell command string to spawn a Goose agent in a tmux pane.
+	 *
+	 * Goose starts an interactive session with `goose`. The `--model` flag
+	 * sets the model. Instructions are provided via .goosehints.
+	 *
+	 * @param opts - Spawn options
+	 * @returns Shell command string suitable for tmux new-session
+	 */
+	buildSpawnCommand(opts: SpawnOpts): string {
+		let cmd = `goose --model ${opts.model}`;
+
+		if (opts.appendSystemPromptFile) {
+			const escaped = opts.appendSystemPromptFile.replace(/'/g, "'\\''");
+			cmd += ` --instructions '${escaped}'`;
+		} else if (opts.appendSystemPrompt) {
+			// Goose doesn't have an inline system prompt flag — write to temp
+			// and use --instructions. For tmux, we pipe it in via the initial prompt.
+			const escaped =
+				`${opts.appendSystemPrompt}\n\nRead .goosehints for your task assignment.`.replace(
+					/'/g,
+					"'\\''",
+				);
+			cmd += ` --with-prompt '${escaped}'`;
+		}
+
+		return cmd;
+	}
+
+	/**
+	 * Build argv for a headless one-shot Goose invocation.
+	 *
+	 * Uses `goose run --text <prompt>` for non-interactive execution.
+	 *
+	 * @param prompt - The prompt to pass
+	 * @param model - Optional model override
+	 * @returns Argv array for Bun.spawn
+	 */
+	buildPrintCommand(prompt: string, model?: string): string[] {
+		const cmd = ["goose", "run", "--text", prompt];
+		if (model !== undefined) {
+			cmd.push("--model", model);
+		}
+		return cmd;
+	}
+
+	/**
+	 * Deploy per-agent instructions to a worktree.
+	 *
+	 * Writes the overlay to .goosehints (Goose's native instruction file).
+	 * No hooks — Goose uses profile-based permissions.
+	 *
+	 * @param worktreePath - Absolute path to the agent's git worktree
+	 * @param overlay - Overlay content, or undefined for no-op
+	 * @param _hooks - Unused — Goose has no hook system
+	 */
+	async deployConfig(
+		worktreePath: string,
+		overlay: OverlayContent | undefined,
+		_hooks: HooksDef,
+	): Promise<void> {
+		if (!overlay) return;
+		await mkdir(worktreePath, { recursive: true });
+		await Bun.write(join(worktreePath, this.instructionPath), overlay.content);
+	}
+
+	/**
+	 * Detect Goose TUI readiness from tmux pane content.
+	 *
+	 * Goose shows a "( O)> " prompt (the goose emoji) when ready for input.
+	 *
+	 * @param paneContent - Captured tmux pane content
+	 * @returns Readiness phase
+	 */
+	detectReady(paneContent: string): ReadyState {
+		const lower = paneContent.toLowerCase();
+
+		// Prompt indicator: ">" or "❯" at end of a line
+		const hasPrompt = /[>❯]\s*$/.test(paneContent);
+
+		// Branding indicator: "goose" or the goose emoji "( O)" in pane content
+		const hasBranding = lower.includes("goose") || paneContent.includes("( O)");
+
+		// Both required (AND logic) to prevent premature ready detection
+		// during startup messages like "Loading Goose..."
+		if (hasPrompt && hasBranding) {
+			return { phase: "ready" };
+		}
+		return { phase: "loading" };
+	}
+
+	/** Goose does not require beacon verification. */
+	requiresBeaconVerification(): boolean {
+		return false;
+	}
+
+	/**
+	 * Goose does not produce machine-readable transcripts.
+	 * Session logs are stored in ~/.config/goose/sessions/ but not in
+	 * a format compatible with agentplate's TranscriptSummary.
+	 */
+	async parseTranscript(_path: string): Promise<TranscriptSummary | null> {
+		return null;
+	}
+
+	buildEnv(model: ResolvedModel): Record<string, string> {
+		return model.env ?? {};
+	}
+
+	/** Goose stores sessions in ~/.config/goose/sessions/ but not transcript-parseable. */
+	getTranscriptDir(_projectRoot: string): string | null {
+		return null;
+	}
+}