@ag-eco/agentplate-cli 0.13.0

package/src/commands/prime.test.ts

@@ -0,0 +1,612 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
+import type { AgentManifest, AgentSession, SessionMetrics } from "../types.ts";
+import { formatManifest, formatMetrics, primeCommand } from "./prime.ts";
+
+/**
+ * Tests for `agentplate prime` command.
+ *
+ * Uses real filesystem (temp directories) and process.stdout spy to test
+ * the prime command end-to-end.
+ */
+
+describe("primeCommand", () => {
+	let chunks: string[];
+	let originalWrite: typeof process.stdout.write;
+	let originalStderrWrite: typeof process.stderr.write;
+	let stderrChunks: string[];
+	let tempDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		// Spy on stdout
+		chunks = [];
+		originalWrite = process.stdout.write;
+		process.stdout.write = ((chunk: string) => {
+			chunks.push(chunk);
+			return true;
+		}) as typeof process.stdout.write;
+
+		// Spy on stderr
+		stderrChunks = [];
+		originalStderrWrite = process.stderr.write;
+		process.stderr.write = ((chunk: string) => {
+			stderrChunks.push(chunk);
+			return true;
+		}) as typeof process.stderr.write;
+
+		// Create temp dir with .agentplate/config.yaml structure
+		tempDir = await mkdtemp(join(tmpdir(), "prime-test-"));
+		const agentplateDir = join(tempDir, ".agentplate");
+		await Bun.write(
+			join(agentplateDir, "config.yaml"),
+			`project:\n  name: test-project\n  root: ${tempDir}\n  canonicalBranch: main\nloam:\n  enabled: false\n`,
+		);
+
+		// Change to temp dir so loadConfig() works
+		originalCwd = process.cwd();
+		process.chdir(tempDir);
+	});
+
+	afterEach(async () => {
+		process.stdout.write = originalWrite;
+		process.stderr.write = originalStderrWrite;
+		process.chdir(originalCwd);
+		await cleanupTempDir(tempDir);
+	});
+
+	function output(): string {
+		return chunks.join("");
+	}
+
+	describe("Orchestrator priming (no --agent flag)", () => {
+		test("default prime outputs project context", async () => {
+			await primeCommand({});
+			const out = output();
+
+			expect(out).toContain("# Agentplate Context");
+			expect(out).toContain("## Project: test-project");
+			expect(out).toContain("Canonical branch: main");
+			expect(out).toContain("Max concurrent agents:");
+			expect(out).toContain("Max depth:");
+		});
+
+		test("includes agent manifest section", async () => {
+			await primeCommand({});
+			const out = output();
+
+			expect(out).toContain("## Agent Manifest");
+			// Without manifest file, should show fallback message
+			expect(out).toContain("No agent manifest found.");
+		});
+
+		test("without metrics.db shows no recent sessions message", async () => {
+			await primeCommand({});
+			const out = output();
+
+			expect(out).toContain("## Recent Activity");
+			expect(out).toContain("No recent sessions.");
+		});
+
+		test("--compact skips Recent Activity and Expertise sections", async () => {
+			await primeCommand({ compact: true });
+			const out = output();
+
+			// Should still have project basics
+			expect(out).toContain("# Agentplate Context");
+			expect(out).toContain("## Project: test-project");
+
+			// Should NOT have these sections
+			expect(out).not.toContain("## Recent Activity");
+			expect(out).not.toContain("## Expertise");
+		});
+	});
+
+	describe("Agent priming (--agent <name>)", () => {
+		test("unknown agent outputs basic context and warns", async () => {
+			await primeCommand({ agent: "unknown-agent" });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: unknown-agent");
+			expect(out).toContain("## Identity");
+			expect(out).toContain("New agent - no prior sessions");
+			expect(out).toContain('agent "unknown-agent" not found');
+		});
+
+		test("agent with identity.yaml shows identity details", async () => {
+			// Write identity.yaml
+			const agentDir = join(tempDir, ".agentplate", "agents", "my-builder");
+			await Bun.write(
+				join(agentDir, "identity.yaml"),
+				`name: my-builder
+capability: builder
+created: "2026-01-01T00:00:00Z"
+sessionsCompleted: 3
+expertiseDomains:
+  - typescript
+  - testing
+recentTasks:
+  - taskId: task-001
+    summary: "Implemented feature X"
+    completedAt: "2026-01-10T12:00:00Z"
+`,
+			);
+
+			await primeCommand({ agent: "my-builder" });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: my-builder");
+			expect(out).toContain("Name: my-builder");
+			expect(out).toContain("Capability: builder");
+			expect(out).toContain("Sessions completed: 3");
+			expect(out).toContain("Expertise: typescript, testing");
+			expect(out).toContain("Recent tasks:");
+			expect(out).toContain("task-001: Implemented feature X");
+		});
+
+		test("agent with active session shows Activation section", async () => {
+			// Write sessions.json with active session
+			const sessions: AgentSession[] = [
+				{
+					id: "session-001",
+					agentName: "active-builder",
+					capability: "builder",
+					worktreePath: join(tempDir, ".agentplate", "worktrees", "active-builder"),
+					branchName: "agentplate/active-builder/task-001",
+					taskId: "task-001",
+					tmuxSession: "agentplate-active-builder",
+					state: "working",
+					pid: 12345,
+					parentAgent: null,
+					depth: 0,
+					runId: null,
+					startedAt: new Date().toISOString(),
+					lastActivity: new Date().toISOString(),
+					escalationLevel: 0,
+					stalledSince: null,
+					transcriptPath: null,
+				},
+			];
+
+			await Bun.write(
+				join(tempDir, ".agentplate", "sessions.json"),
+				`${JSON.stringify(sessions, null, 2)}\n`,
+			);
+
+			await primeCommand({ agent: "active-builder" });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: active-builder");
+			expect(out).toContain("## Activation");
+			expect(out).toContain("You have a bound task: **task-001**");
+			expect(out).toContain("begin working immediately");
+		});
+
+		test("agent with completed session does NOT show Activation", async () => {
+			// Write sessions.json with completed session
+			const sessions: AgentSession[] = [
+				{
+					id: "session-002",
+					agentName: "completed-builder",
+					capability: "builder",
+					worktreePath: join(tempDir, ".agentplate", "worktrees", "completed-builder"),
+					branchName: "agentplate/completed-builder/task-002",
+					taskId: "task-002",
+					tmuxSession: "agentplate-completed-builder",
+					state: "completed",
+					pid: null,
+					parentAgent: null,
+					depth: 0,
+					runId: null,
+					startedAt: new Date(Date.now() - 3600000).toISOString(),
+					lastActivity: new Date().toISOString(),
+					escalationLevel: 0,
+					stalledSince: null,
+					transcriptPath: null,
+				},
+			];
+
+			await Bun.write(
+				join(tempDir, ".agentplate", "sessions.json"),
+				`${JSON.stringify(sessions, null, 2)}\n`,
+			);
+
+			await primeCommand({ agent: "completed-builder" });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: completed-builder");
+			expect(out).not.toContain("## Activation");
+			expect(out).not.toContain("bound task");
+		});
+
+		test("--compact with checkpoint.json shows Session Recovery", async () => {
+			// Write checkpoint.json
+			const agentDir = join(tempDir, ".agentplate", "agents", "recovery-agent");
+			await Bun.write(
+				join(agentDir, "checkpoint.json"),
+				`${JSON.stringify(
+					{
+						agentName: "recovery-agent",
+						taskId: "task-003",
+						sessionId: "session-003",
+						timestamp: new Date().toISOString(),
+						progressSummary: "Implemented initial tests for prime command",
+						filesModified: ["src/commands/prime.test.ts"],
+						currentBranch: "agentplate/recovery-agent/task-003",
+						pendingWork: "Add tests for edge cases",
+						loamDomains: ["typescript", "testing"],
+					},
+					null,
+					2,
+				)}\n`,
+			);
+
+			// Also need identity to avoid warning
+			await Bun.write(
+				join(agentDir, "identity.yaml"),
+				`name: recovery-agent
+capability: builder
+created: "2026-01-01T00:00:00Z"
+sessionsCompleted: 0
+expertiseDomains: []
+recentTasks: []
+`,
+			);
+
+			await primeCommand({ agent: "recovery-agent", compact: true });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: recovery-agent");
+			expect(out).toContain("## Session Recovery");
+			expect(out).toContain("Progress so far:** Implemented initial tests for prime command");
+			expect(out).toContain("Files modified:** src/commands/prime.test.ts");
+			expect(out).toContain("Pending work:** Add tests for edge cases");
+			expect(out).toContain("Branch:** agentplate/recovery-agent/task-003");
+		});
+
+		test("--compact skips Expertise section", async () => {
+			// Write identity with expertise
+			const agentDir = join(tempDir, ".agentplate", "agents", "compact-agent");
+			await Bun.write(
+				join(agentDir, "identity.yaml"),
+				`name: compact-agent
+capability: builder
+created: "2026-01-01T00:00:00Z"
+sessionsCompleted: 1
+expertiseDomains:
+  - typescript
+recentTasks: []
+`,
+			);
+
+			await primeCommand({ agent: "compact-agent", compact: true });
+			const out = output();
+
+			expect(out).toContain("# Agent Context: compact-agent");
+			expect(out).not.toContain("## Expertise");
+		});
+	});
+
+	describe("Session branch capture", () => {
+		test("orchestrator prime writes session-branch.txt with current git branch", async () => {
+			// Need a real git repo for branch detection
+			const gitRepoDir = await createTempGitRepo();
+			try {
+				const agentplateDir = join(gitRepoDir, ".agentplate");
+				await mkdir(agentplateDir, { recursive: true });
+				await Bun.write(
+					join(agentplateDir, "config.yaml"),
+					`project:\n  name: branch-test\n  root: ${gitRepoDir}\n  canonicalBranch: main\nloam:\n  enabled: false\n`,
+				);
+
+				// Save and change cwd to the git repo
+				process.chdir(gitRepoDir);
+
+				await primeCommand({});
+				const out = output();
+
+				expect(out).toContain("# Agentplate Context");
+
+				// Verify session-branch.txt was written
+				const sessionBranchPath = join(agentplateDir, "session-branch.txt");
+				const content = await Bun.file(sessionBranchPath).text();
+				expect(content.trim()).toBe("main");
+			} finally {
+				process.chdir(originalCwd);
+				await cleanupTempDir(gitRepoDir);
+			}
+		});
+
+		test("shows session branch in context when different from canonical", async () => {
+			const gitRepoDir = await createTempGitRepo();
+			try {
+				// Create and switch to a feature branch
+				const proc = Bun.spawn(["git", "checkout", "-b", "feature/my-work"], {
+					cwd: gitRepoDir,
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				await proc.exited;
+
+				const agentplateDir = join(gitRepoDir, ".agentplate");
+				await mkdir(agentplateDir, { recursive: true });
+				await Bun.write(
+					join(agentplateDir, "config.yaml"),
+					`project:\n  name: branch-test\n  root: ${gitRepoDir}\n  canonicalBranch: main\nloam:\n  enabled: false\n`,
+				);
+
+				process.chdir(gitRepoDir);
+
+				await primeCommand({});
+				const out = output();
+
+				expect(out).toContain("Session branch: feature/my-work (merge target)");
+
+				// Verify session-branch.txt was written with the feature branch
+				const sessionBranchPath = join(agentplateDir, "session-branch.txt");
+				const content = await Bun.file(sessionBranchPath).text();
+				expect(content.trim()).toBe("feature/my-work");
+			} finally {
+				process.chdir(originalCwd);
+				await cleanupTempDir(gitRepoDir);
+			}
+		});
+	});
+
+	describe("Gitignore auto-heal", () => {
+		const expectedGitignore = `# Wildcard+whitelist: ignore everything, whitelist tracked files
+# Auto-healed by ap prime on each session start
+*
+!.gitignore
+!config.yaml
+!agent-manifest.json
+!hooks.json
+!groups.json
+!agent-defs/
+!agent-defs/**
+!README.md
+`;
+
+		test("creates .agentplate/.gitignore if missing", async () => {
+			// The beforeEach creates .agentplate/config.yaml but not .gitignore
+			const gitignorePath = join(tempDir, ".agentplate", ".gitignore");
+
+			// Verify it doesn't exist
+			const existsBefore = await Bun.file(gitignorePath).exists();
+			expect(existsBefore).toBe(false);
+
+			// Run primeCommand
+			await primeCommand({});
+
+			// Verify .gitignore was created with correct content
+			const content = await Bun.file(gitignorePath).text();
+			expect(content).toBe(expectedGitignore);
+		});
+
+		test("overwrites stale .agentplate/.gitignore with current template", async () => {
+			// Write an old-style deny-list gitignore
+			const gitignorePath = join(tempDir, ".agentplate", ".gitignore");
+			const staleContent = `# Old deny-list format
+worktrees/
+logs/
+mail.db
+sessions.db
+`;
+			await Bun.write(gitignorePath, staleContent);
+
+			// Verify stale content is present
+			const contentBefore = await Bun.file(gitignorePath).text();
+			expect(contentBefore).toBe(staleContent);
+
+			// Run primeCommand
+			await primeCommand({});
+
+			// Verify .gitignore now has the wildcard+whitelist content
+			const contentAfter = await Bun.file(gitignorePath).text();
+			expect(contentAfter).toBe(expectedGitignore);
+		});
+
+		test("does not overwrite .agentplate/.gitignore if already correct", async () => {
+			// Write the correct AGENTPLATE_GITIGNORE content
+			const gitignorePath = join(tempDir, ".agentplate", ".gitignore");
+			await Bun.write(gitignorePath, expectedGitignore);
+
+			// Get file stat before
+			const statBefore = await Bun.file(gitignorePath).stat();
+			const mtimeBefore = statBefore?.mtime;
+
+			// Wait a tiny bit to ensure mtime would change if file is rewritten
+			await new Promise((resolve) => setTimeout(resolve, 10));
+
+			// Run primeCommand
+			await primeCommand({});
+
+			// Verify content is still correct
+			const contentAfter = await Bun.file(gitignorePath).text();
+			expect(contentAfter).toBe(expectedGitignore);
+
+			// Verify mtime is unchanged (file was not rewritten)
+			const statAfter = await Bun.file(gitignorePath).stat();
+			const mtimeAfter = statAfter?.mtime;
+			expect(mtimeAfter).toEqual(mtimeBefore);
+		});
+	});
+});
+
+describe("formatManifest", () => {
+	test("returns 'No agents registered.' for empty agents record", () => {
+		const manifest: AgentManifest = {
+			version: "1",
+			agents: {},
+			capabilityIndex: {},
+		};
+		expect(formatManifest(manifest)).toBe("No agents registered.");
+	});
+
+	test("formats single agent with capabilities", () => {
+		const manifest: AgentManifest = {
+			version: "1",
+			agents: {
+				scout: {
+					file: "agents/scout.md",
+					model: "sonnet",
+					tools: ["Read", "Glob"],
+					capabilities: ["explore", "analyze"],
+					canSpawn: false,
+					constraints: [],
+				},
+			},
+			capabilityIndex: { explore: ["scout"], analyze: ["scout"] },
+		};
+		const result = formatManifest(manifest);
+		expect(result).toContain("**scout**");
+		expect(result).toContain("[sonnet]");
+		expect(result).toContain("explore, analyze");
+		expect(result).not.toContain("(can spawn)");
+	});
+
+	test("marks agents that can spawn", () => {
+		const manifest: AgentManifest = {
+			version: "1",
+			agents: {
+				lead: {
+					file: "agents/lead.md",
+					model: "opus",
+					tools: ["Read", "Bash"],
+					capabilities: ["coordinate"],
+					canSpawn: true,
+					constraints: [],
+				},
+			},
+			capabilityIndex: { coordinate: ["lead"] },
+		};
+		const result = formatManifest(manifest);
+		expect(result).toContain("(can spawn)");
+	});
+
+	test("formats multiple agents as separate lines", () => {
+		const manifest: AgentManifest = {
+			version: "1",
+			agents: {
+				scout: {
+					file: "agents/scout.md",
+					model: "sonnet",
+					tools: [],
+					capabilities: ["explore"],
+					canSpawn: false,
+					constraints: [],
+				},
+				builder: {
+					file: "agents/builder.md",
+					model: "opus",
+					tools: [],
+					capabilities: ["implement"],
+					canSpawn: false,
+					constraints: [],
+				},
+			},
+			capabilityIndex: {},
+		};
+		const result = formatManifest(manifest);
+		const lines = result.split("\n");
+		expect(lines).toHaveLength(2);
+		expect(lines[0]).toContain("scout");
+		expect(lines[1]).toContain("builder");
+	});
+});
+
+describe("formatMetrics", () => {
+	test("returns 'No recent sessions.' for empty array", () => {
+		expect(formatMetrics([])).toBe("No recent sessions.");
+	});
+
+	test("formats a completed session with duration and merge result", () => {
+		const sessions: SessionMetrics[] = [
+			{
+				agentName: "builder-1",
+				taskId: "task-001",
+				capability: "builder",
+				startedAt: "2026-01-01T00:00:00Z",
+				completedAt: "2026-01-01T00:05:00Z",
+				durationMs: 300_000,
+				exitCode: 0,
+				mergeResult: "clean-merge",
+				parentAgent: "coordinator",
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0,
+				estimatedCostUsd: null,
+				modelUsed: null,
+				runId: null,
+			},
+		];
+		const result = formatMetrics(sessions);
+		expect(result).toContain("builder-1");
+		expect(result).toContain("(builder)");
+		expect(result).toContain("task-001");
+		expect(result).toContain("completed");
+		expect(result).toContain("(300s)");
+		expect(result).toContain("[clean-merge]");
+	});
+
+	test("formats an in-progress session without duration or merge result", () => {
+		const sessions: SessionMetrics[] = [
+			{
+				agentName: "scout-1",
+				taskId: "task-002",
+				capability: "scout",
+				startedAt: "2026-01-01T00:00:00Z",
+				completedAt: null,
+				durationMs: 0,
+				exitCode: null,
+				mergeResult: null,
+				parentAgent: null,
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheCreationTokens: 0,
+				estimatedCostUsd: null,
+				modelUsed: null,
+				runId: null,
+			},
+		];
+		const result = formatMetrics(sessions);
+		expect(result).toContain("scout-1");
+		expect(result).toContain("in-progress");
+		expect(result).not.toContain("[");
+	});
+
+	test("formats multiple sessions as separate lines", () => {
+		const base: SessionMetrics = {
+			agentName: "builder-1",
+			taskId: "task-001",
+			capability: "builder",
+			startedAt: "2026-01-01T00:00:00Z",
+			completedAt: "2026-01-01T00:05:00Z",
+			durationMs: 300_000,
+			exitCode: 0,
+			mergeResult: null,
+			parentAgent: null,
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			estimatedCostUsd: null,
+			modelUsed: null,
+			runId: null,
+		};
+		const sessions: SessionMetrics[] = [
+			base,
+			{ ...base, agentName: "builder-2", taskId: "task-002" },
+		];
+		const result = formatMetrics(sessions);
+		const lines = result.split("\n");
+		expect(lines).toHaveLength(2);
+		expect(lines[0]).toContain("builder-1");
+		expect(lines[1]).toContain("builder-2");
+	});
+});