@markjaquith/agency 0.5.0

package/src/commands/use.test.ts

@@ -0,0 +1,87 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { use } from "./use"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getGitConfig,
+	runTestEffect,
+} from "../test-utils"
+
+describe("use command", () => {
+	let tempDir: string
+	let originalCwd: string
+	let originalConfigDir: string | undefined
+
+	beforeEach(async () => {
+		tempDir = await createTempDir()
+		originalCwd = process.cwd()
+		originalConfigDir = process.env.AGENCY_CONFIG_DIR
+		// Use a temp config dir
+		process.env.AGENCY_CONFIG_DIR = await createTempDir()
+	})
+
+	afterEach(async () => {
+		process.chdir(originalCwd)
+		if (originalConfigDir !== undefined) {
+			process.env.AGENCY_CONFIG_DIR = originalConfigDir
+		} else {
+			delete process.env.AGENCY_CONFIG_DIR
+		}
+		if (
+			process.env.AGENCY_CONFIG_DIR &&
+			process.env.AGENCY_CONFIG_DIR !== originalConfigDir
+		) {
+			await cleanupTempDir(process.env.AGENCY_CONFIG_DIR)
+		}
+		await cleanupTempDir(tempDir)
+	})
+
+	test("sets template name in git config", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await runTestEffect(use({ template: "work", silent: true }))
+
+		const templateName = await getGitConfig("agency.template", tempDir)
+		expect(templateName).toBe("work")
+	})
+
+	test("updates existing template name", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await runTestEffect(use({ template: "work", silent: true }))
+		await runTestEffect(use({ template: "personal", silent: true }))
+
+		const templateName = await getGitConfig("agency.template", tempDir)
+		expect(templateName).toBe("personal")
+	})
+
+	test("throws error when not in git repo", async () => {
+		process.chdir(tempDir)
+
+		await expect(
+			runTestEffect(use({ template: "work", silent: true })),
+		).rejects.toThrow("Not in a git repository")
+	})
+
+	test("throws error when no template provided in silent mode", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await expect(runTestEffect(use({ silent: true }))).rejects.toThrow(
+			"Template name required",
+		)
+	})
+
+	test("works with --template flag", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await runTestEffect(use({ template: "client", silent: true }))
+
+		const templateName = await getGitConfig("agency.template", tempDir)
+		expect(templateName).toBe("client")
+	})
+})

package/src/commands/use.ts

@@ -0,0 +1,97 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { TemplateService } from "../services/TemplateService"
+import { PromptService } from "../services/PromptService"
+import highlight from "../utils/colors"
+import { createLoggers, ensureGitRepo } from "../utils/effect"
+
+interface UseOptions extends BaseCommandOptions {
+	template?: string
+}
+
+export const use = (options: UseOptions = {}) =>
+	Effect.gen(function* () {
+		const { silent = false } = options
+		const { log, verboseLog } = createLoggers(options)
+
+		const git = yield* GitService
+		const templateService = yield* TemplateService
+		const promptService = yield* PromptService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		let templateName = options.template
+
+		// If no template name provided, show interactive selection
+		if (!templateName) {
+			if (silent) {
+				return yield* Effect.fail(
+					new Error(
+						"Template name required. Use --template flag in silent mode.",
+					),
+				)
+			}
+
+			const templates = yield* templateService.listTemplates()
+
+			if (templates.length === 0) {
+				log("No templates found in ~/.config/agency/templates/")
+				log("Run 'agency task' to create a template.")
+				return
+			}
+
+			// Show current template if set
+			const currentTemplate = yield* git.getGitConfig(
+				"agency.template",
+				gitRoot,
+			)
+			if (currentTemplate) {
+				log(`Current template: ${highlight.template(currentTemplate)}`)
+			}
+
+			templateName = yield* promptService.promptForTemplate(templates, {
+				currentTemplate: currentTemplate ?? undefined,
+				allowNew: false,
+			})
+		}
+
+		verboseLog(`Setting template to: ${templateName}`)
+
+		// Set the template in git config
+		yield* git.setGitConfig("agency.template", templateName, gitRoot)
+	})
+
+// Help text for reference (not exported as it's handled by template command)
+const help = `
+Usage: agency template use [template] [options]
+
+Set the template to use for this repository.
+
+NOTE: This command is equivalent to 'agency init'. Use 'agency init' for
+      initial setup, and 'agency template use' to change templates later.
+
+When no template name is provided, shows an interactive list of available
+templates to choose from. The template name is saved to .git/config
+(agency.template) and will be used by subsequent 'agency task' commands.
+
+Arguments:
+  template          Template name to use (optional, prompts if not provided)
+
+Options:
+  -h, --help        Show this help message
+  -s, --silent      Suppress output messages
+  -v, --verbose     Show verbose output
+  -t, --template    Specify template name (same as positional argument)
+
+Examples:
+  agency template use                     # Interactive template selection
+  agency template use work                # Set template to 'work'
+  agency template use --template=client   # Set template to 'client'
+
+Notes:
+  - Template must exist in ~/.config/agency/templates/{name}/
+  - Template name is saved to .git/config (not committed)
+  - Use 'agency task' after changing template to create/update files
+  - Template directory is created when you save files to it
+`

package/src/commands/work.test.ts

@@ -0,0 +1,462 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { work } from "./work"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	initAgency,
+	runTestEffect,
+	createCommit,
+} from "../test-utils"
+import { writeFileSync } from "node:fs"
+
+/**
+ * Helper to mock CLI tool detection and execution for work command tests.
+ * Returns restore function to clean up mocks.
+ *
+ * @param options Configuration for the mock
+ * @param options.hasOpencode Whether 'which opencode' should succeed (default: true)
+ * @param options.hasClaude Whether 'which claude' should succeed (default: false)
+ * @param options.onSpawn Callback when Bun.spawn is called (non-git commands)
+ * @returns Restore function to clean up mocks
+ */
+function mockCliTools(
+	options: {
+		hasOpencode?: boolean
+		hasClaude?: boolean
+		onSpawn?: (args: string[], options: any) => any
+	} = {},
+) {
+	const { hasOpencode = true, hasClaude = false, onSpawn } = options
+
+	const originalSpawn = Bun.spawn
+	const originalSpawnSync = Bun.spawnSync
+
+	// @ts-ignore - mocking for test
+	Bun.spawnSync = (args: any, options: any) => {
+		// Mock which command to return success/failure based on config
+		if (Array.isArray(args) && args[0] === "which") {
+			if (args[1] === "opencode") {
+				return { exitCode: hasOpencode ? 0 : 1 }
+			}
+			if (args[1] === "claude") {
+				return { exitCode: hasClaude ? 0 : 1 }
+			}
+		}
+		return originalSpawnSync(args, options)
+	}
+
+	// @ts-ignore - mocking for test
+	Bun.spawn = (args: any, options: any) => {
+		// Allow git commands to pass through
+		if (Array.isArray(args) && args[0] === "git") {
+			return originalSpawn(args, options)
+		}
+
+		// Call custom handler if provided
+		if (onSpawn) {
+			return onSpawn(args, options)
+		}
+
+		// Default mock response
+		return {
+			exited: Promise.resolve(0),
+			exitCode: 0,
+			stdout: new ReadableStream(),
+			stderr: new ReadableStream(),
+		}
+	}
+
+	// Return restore function
+	return () => {
+		// @ts-ignore - restore
+		Bun.spawn = originalSpawn
+		// @ts-ignore - restore
+		Bun.spawnSync = originalSpawnSync
+	}
+}
+
+describe("work command", () => {
+	let tempDir: string
+	let originalCwd: string
+
+	beforeEach(async () => {
+		tempDir = await createTempDir()
+		originalCwd = process.cwd()
+		process.chdir(tempDir)
+
+		// Initialize git repo
+		await initGitRepo(tempDir)
+		await createCommit(tempDir, "Initial commit")
+	})
+
+	afterEach(async () => {
+		process.chdir(originalCwd)
+		await cleanupTempDir(tempDir)
+	})
+
+	describe("error handling", () => {
+		test("throws error when TASK.md doesn't exist", async () => {
+			expect(
+				runTestEffect(work({ silent: true, _noExec: true })),
+			).rejects.toThrow(
+				"TASK.md not found. Run 'agency task' first to create it.",
+			)
+		})
+
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
+
+			expect(
+				runTestEffect(work({ silent: true, _noExec: true })),
+			).rejects.toThrow("Not in a git repository")
+
+			await cleanupTempDir(nonGitDir)
+		})
+	})
+
+	describe("TASK.md validation", () => {
+		test("finds TASK.md in git root", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let spawnCalled = false
+			let spawnArgs: any[] = []
+
+			const restore = mockCliTools({
+				onSpawn: (args) => {
+					spawnCalled = true
+					spawnArgs = args
+					return {
+						exited: Promise.resolve(0),
+					}
+				},
+			})
+
+			await runTestEffect(work({ silent: true, _noExec: true }))
+
+			restore()
+
+			expect(spawnCalled).toBe(true)
+			expect(spawnArgs).toEqual(["opencode", "-p", "Start the task"])
+		})
+	})
+
+	describe("opencode execution", () => {
+		test("passes correct arguments to opencode", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+			let capturedOptions: any = null
+
+			const restore = mockCliTools({
+				onSpawn: (args, options) => {
+					capturedArgs = args
+					capturedOptions = options
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(work({ silent: true, _noExec: true }))
+
+			restore()
+
+			expect(capturedArgs).toEqual(["opencode", "-p", "Start the task"])
+			// On macOS, temp directories can have /private prefix
+			expect(
+				capturedOptions.cwd === tempDir ||
+					capturedOptions.cwd === `/private${tempDir}`,
+			).toBe(true)
+			expect(capturedOptions.stdout).toEqual("inherit")
+			expect(capturedOptions.stderr).toEqual("inherit")
+		})
+
+		test("throws error when opencode exits with non-zero code", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			const restore = mockCliTools({
+				onSpawn: () => ({
+					exited: Promise.resolve(1),
+					exitCode: 1,
+					stdout: new ReadableStream(),
+					stderr: new ReadableStream(),
+				}),
+			})
+
+			expect(
+				runTestEffect(work({ silent: true, _noExec: true })),
+			).rejects.toThrow("opencode exited with code 1")
+
+			restore()
+		})
+	})
+
+	describe("silent mode", () => {
+		test("verbose mode logs debug information", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			const restore = mockCliTools()
+
+			// Capture console.log
+			const originalLog = console.log
+			let logMessages: string[] = []
+			console.log = (msg: string) => {
+				logMessages.push(msg)
+			}
+
+			await runTestEffect(work({ silent: false, verbose: true, _noExec: true }))
+
+			console.log = originalLog
+			restore()
+
+			expect(logMessages.some((msg) => msg.includes("Found TASK.md"))).toBe(
+				true,
+			)
+			expect(logMessages.some((msg) => msg.includes("Running opencode"))).toBe(
+				true,
+			)
+		})
+
+		test("silent flag suppresses verbose output", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			const restore = mockCliTools()
+
+			// Capture console.log
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await work({ silent: true, verbose: true, _noExec: true })
+
+			console.log = originalLog
+			restore()
+
+			expect(logCalled).toBe(false)
+		})
+	})
+
+	describe("CLI selection flags", () => {
+		test("--opencode flag forces use of OpenCode", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+
+			const restore = mockCliTools({
+				onSpawn: (args) => {
+					capturedArgs = args
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(work({ silent: true, _noExec: true, opencode: true }))
+
+			restore()
+
+			expect(capturedArgs).toEqual(["opencode", "-p", "Start the task"])
+		})
+
+		test("--claude flag forces use of Claude Code", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+
+			const restore = mockCliTools({
+				hasClaude: true,
+				onSpawn: (args) => {
+					capturedArgs = args
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(work({ silent: true, _noExec: true, claude: true }))
+
+			restore()
+
+			expect(capturedArgs).toEqual(["claude", "Start the task"])
+		})
+
+		test("throws error when both --opencode and --claude flags are used", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			expect(
+				runTestEffect(
+					work({ silent: true, _noExec: true, opencode: true, claude: true }),
+				),
+			).rejects.toThrow(
+				"Cannot use both --opencode and --claude flags together. Choose one.",
+			)
+		})
+
+		test("throws error when --opencode is used but opencode is not installed", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			const restore = mockCliTools({ hasOpencode: false })
+
+			expect(
+				runTestEffect(work({ silent: true, _noExec: true, opencode: true })),
+			).rejects.toThrow(
+				"opencode CLI tool not found. Please install OpenCode or remove the --opencode flag.",
+			)
+
+			restore()
+		})
+
+		test("throws error when --claude is used but claude is not installed", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			const restore = mockCliTools({ hasClaude: false })
+
+			expect(
+				runTestEffect(work({ silent: true, _noExec: true, claude: true })),
+			).rejects.toThrow(
+				"claude CLI tool not found. Please install Claude Code or remove the --claude flag.",
+			)
+
+			restore()
+		})
+	})
+
+	describe("extra arguments", () => {
+		test("passes extra args to opencode", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+
+			const restore = mockCliTools({
+				onSpawn: (args) => {
+					capturedArgs = args
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(
+				work({
+					silent: true,
+					_noExec: true,
+					extraArgs: ["--model", "claude-sonnet-4-20250514"],
+				}),
+			)
+
+			restore()
+
+			expect(capturedArgs).toEqual([
+				"opencode",
+				"-p",
+				"Start the task",
+				"--model",
+				"claude-sonnet-4-20250514",
+			])
+		})
+
+		test("passes extra args to claude", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+
+			const restore = mockCliTools({
+				hasClaude: true,
+				onSpawn: (args) => {
+					capturedArgs = args
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(
+				work({
+					silent: true,
+					_noExec: true,
+					claude: true,
+					extraArgs: ["--arbitrary", "switches"],
+				}),
+			)
+
+			restore()
+
+			expect(capturedArgs).toEqual([
+				"claude",
+				"Start the task",
+				"--arbitrary",
+				"switches",
+			])
+		})
+
+		test("works without extra args", async () => {
+			// Create TASK.md
+			const taskPath = join(tempDir, "TASK.md")
+			writeFileSync(taskPath, "# Test Task\n\nSome task content")
+
+			let capturedArgs: string[] = []
+
+			const restore = mockCliTools({
+				onSpawn: (args) => {
+					capturedArgs = args
+					return {
+						exited: Promise.resolve(0),
+						exitCode: 0,
+						stdout: new ReadableStream(),
+						stderr: new ReadableStream(),
+					}
+				},
+			})
+
+			await runTestEffect(work({ silent: true, _noExec: true }))
+
+			restore()
+
+			expect(capturedArgs).toEqual(["opencode", "-p", "Start the task"])
+		})
+	})
+})