@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/loop.ts

@@ -1,406 +0,0 @@
-import { join } from "node:path"
-import { Effect } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { FileSystemService } from "../services/FileSystemService"
-import { GitService } from "../services/GitService"
-import { createLoggers, ensureGitRepo } from "../utils/effect"
-import { spawnProcess } from "../utils/process"
-import {
-	parseTaskItems,
-	countTasks,
-	areAllTasksComplete,
-	extractCompletionPromise,
-	validateCompletion,
-} from "../utils/task-parser"
-import highlight, { done, info } from "../utils/colors"
-
-interface LoopOptions extends BaseCommandOptions {
-	/**
-	 * Maximum number of iterations (undefined = unlimited)
-	 */
-	maxLoops?: number
-	/**
-	 * Minimum number of iterations to enforce
-	 */
-	minLoops?: number
-	/**
-	 * Force use of OpenCode CLI
-	 */
-	opencode?: boolean
-	/**
-	 * Force use of Claude Code CLI
-	 */
-	claude?: boolean
-	/**
-	 * Additional arguments to pass to the CLI tool
-	 */
-	extraArgs?: string[]
-}
-
-interface LoopState {
-	iteration: number
-	tasksCompleted: number
-	tasksIncomplete: number
-	tasksTotalAtStart: number
-	iterationStartTime: number
-	harnessFailed: boolean
-}
-
-export const loop = (options: LoopOptions = {}) =>
-	Effect.gen(function* () {
-		const { log, verboseLog } = createLoggers(options)
-		const fs = yield* FileSystemService
-
-		const gitRoot = yield* ensureGitRepo()
-
-		// Check if TASK.md exists
-		const taskPath = join(gitRoot, "TASK.md")
-		const taskExists = yield* fs.exists(taskPath)
-		if (!taskExists) {
-			return yield* Effect.fail(
-				new Error("TASK.md not found. Run 'agency task' first to create it."),
-			)
-		}
-
-		verboseLog(`Found TASK.md at: ${taskPath}`)
-
-		// Change to git root before executing and restore afterwards
-		// Do not change global cwd; pass gitRoot explicitly to subprocesses
-
-		// Check for conflicting flags
-		if (options.opencode && options.claude) {
-			return yield* Effect.fail(
-				new Error(
-					"Cannot use both --opencode and --claude flags together. Choose one.",
-				),
-			)
-		}
-
-		// Validate loop bounds
-		if (
-			typeof options.minLoops === "number" &&
-			typeof options.maxLoops === "number" &&
-			options.minLoops > options.maxLoops
-		) {
-			return yield* Effect.fail(
-				new Error("--min-loops cannot be greater than --max-loops."),
-			)
-		}
-
-		// Check which CLI tool is available
-		const hasOpencode = yield* Effect.tryPromise({
-			try: async () => {
-				const result = Bun.spawnSync(["which", "opencode"], {
-					stdout: "ignore",
-					stderr: "ignore",
-				})
-				return result.exitCode === 0
-			},
-			catch: () => false,
-		})
-
-		const hasClaude = yield* Effect.tryPromise({
-			try: async () => {
-				const result = Bun.spawnSync(["which", "claude"], {
-					stdout: "ignore",
-					stderr: "ignore",
-				})
-				return result.exitCode === 0
-			},
-			catch: () => false,
-		})
-
-		// Determine which CLI to use based on flags or auto-detection
-		let useOpencode: boolean
-		if (options.opencode) {
-			if (!hasOpencode) {
-				return yield* Effect.fail(
-					new Error(
-						"opencode CLI tool not found. Please install OpenCode or remove the --opencode flag.",
-					),
-				)
-			}
-			useOpencode = true
-			verboseLog("Using opencode (explicitly requested)")
-		} else if (options.claude) {
-			if (!hasClaude) {
-				return yield* Effect.fail(
-					new Error(
-						"claude CLI tool not found. Please install Claude Code or remove the --claude flag.",
-					),
-				)
-			}
-			useOpencode = false
-			verboseLog("Using claude (explicitly requested)")
-		} else {
-			// Auto-detect
-			if (!hasOpencode && !hasClaude) {
-				return yield* Effect.fail(
-					new Error(
-						"Neither opencode nor claude CLI tool found. Please install OpenCode or Claude Code.",
-					),
-				)
-			}
-			useOpencode = hasOpencode
-			verboseLog(`Using ${useOpencode ? "opencode" : "claude"} (auto-detected)`)
-		}
-
-		const cliName = useOpencode ? "opencode" : "claude"
-
-		// Parse initial task state
-		let taskContent = yield* fs.readFile(taskPath)
-		let taskItems = parseTaskItems(taskContent)
-		let taskCounts = countTasks(taskItems)
-		const tasksTotalAtStart = taskCounts.total
-
-		// If there are no tasks at all, treat as complete but still respect minLoops
-		const noTasks = tasksTotalAtStart === 0
-
-		verboseLog(
-			`Initial state: ${taskCounts.completed}/${taskCounts.total} tasks complete`,
-		)
-
-		const loopStartTime = Date.now()
-		let loopState: LoopState = {
-			iteration: 0,
-			tasksCompleted: taskCounts.completed,
-			tasksIncomplete: taskCounts.incomplete,
-			tasksTotalAtStart,
-			iterationStartTime: loopStartTime,
-			harnessFailed: false,
-		}
-
-		// Main loop
-		while (true) {
-			loopState.iteration++
-			loopState.iterationStartTime = Date.now()
-			loopState.harnessFailed = false
-
-			// Check if we've exceeded max loops
-			if (options.maxLoops && loopState.iteration > options.maxLoops) {
-				break
-			}
-
-			// Log iteration start
-			const maxStr = options.maxLoops ? `/${options.maxLoops}` : ""
-			const minStr = options.minLoops ? ` (min: ${options.minLoops})` : ""
-			log(
-				info(
-					`Loop ${loopState.iteration}${maxStr}${minStr} - ${loopState.tasksCompleted}/${loopState.tasksTotalAtStart} tasks complete`,
-				),
-			)
-
-			// Prepare harness command
-			const harnessPassed = yield* runHarness(
-				cliName,
-				useOpencode,
-				gitRoot,
-				options.verbose ?? false,
-				verboseLog,
-				options.extraArgs,
-			).pipe(
-				Effect.map(() => true),
-				Effect.catchAll(() => Effect.succeed(false)),
-			)
-
-			if (!harnessPassed) {
-				verboseLog(
-					`Harness failed on iteration ${loopState.iteration}, retrying...`,
-				)
-				loopState.harnessFailed = true
-				// Retry once
-				const harnessPassed2 = yield* runHarness(
-					cliName,
-					useOpencode,
-					gitRoot,
-					options.verbose ?? false,
-					verboseLog,
-					options.extraArgs,
-				).pipe(
-					Effect.map(() => true),
-					Effect.catchAll(() => Effect.succeed(false)),
-				)
-
-				if (!harnessPassed2) {
-					return yield* Effect.fail(
-						new Error(
-							`Harness failed twice on iteration ${loopState.iteration}. Stopping loop.`,
-						),
-					)
-				}
-			}
-
-			// Re-read TASK.md and check status
-			taskContent = yield* fs.readFile(taskPath)
-			taskItems = parseTaskItems(taskContent)
-			taskCounts = countTasks(taskItems)
-
-			loopState.tasksCompleted = taskCounts.completed
-			loopState.tasksIncomplete = taskCounts.incomplete
-
-			const allComplete = noTasks ? true : areAllTasksComplete(taskItems)
-			const completionPromise = extractCompletionPromise(taskContent)
-
-			// Validate completion claim if agent says it's done
-			if (completionPromise) {
-				try {
-					validateCompletion(completionPromise, allComplete)
-				} catch (error) {
-					return yield* Effect.fail(error)
-				}
-			}
-
-			// Log iteration summary
-			const iterationDuration = Date.now() - loopState.iterationStartTime
-			const durationSecs = (iterationDuration / 1000).toFixed(1)
-			log(
-				done(
-					`Loop ${loopState.iteration} complete (${durationSecs}s) - ${loopState.tasksCompleted}/${loopState.tasksTotalAtStart} tasks complete`,
-				),
-			)
-
-			// Check if we should exit
-			if (
-				allComplete &&
-				(!options.minLoops || loopState.iteration >= options.minLoops)
-			) {
-				// Ensure TASK.md does not contain the completion promise
-				const fs = yield* FileSystemService
-				const taskPath = `${gitRoot}/TASK.md`
-				if (yield* fs.exists(taskPath)) {
-					const contents = yield* fs.readFile(taskPath)
-					const cleaned =
-						contents.replace(/<promise>[^<]*<\/promise>/gi, "").trimEnd() + "\n"
-					if (cleaned !== contents) {
-						yield* fs.writeFile(taskPath, cleaned)
-						// Commit cleanup so final TASK.md is clean
-						const git = yield* GitService
-						yield* git.gitAdd(["TASK.md"], gitRoot)
-						yield* git.gitCommit(
-							"fix(loop): remove completion promise from TASK.md",
-							gitRoot,
-						)
-					}
-				}
-				log(done(`All tasks complete!`))
-				break
-			}
-
-			// Check if we've hit max loops
-			if (options.maxLoops && loopState.iteration >= options.maxLoops) {
-				if (!allComplete) {
-					log(
-						info(
-							`Max loops (${options.maxLoops}) reached but tasks remain. Stopping.`,
-						),
-					)
-				}
-				break
-			}
-		}
-
-		// Final summary
-		const totalDuration = Date.now() - loopStartTime
-		const totalDurationSecs = (totalDuration / 1000).toFixed(1)
-		log(
-			done(
-				`Loop completed in ${loopState.iteration} iteration${loopState.iteration === 1 ? "" : "s"} (${totalDurationSecs}s)`,
-			),
-		)
-		log(
-			done(
-				`Final state: ${loopState.tasksCompleted}/${loopState.tasksTotalAtStart} tasks complete`,
-			),
-		)
-	})
-
-/**
- * Run the harness (opencode or claude run) for a single iteration
- */
-function runHarness(
-	cliName: string,
-	useOpencode: boolean,
-	gitRoot: string,
-	verbose: boolean,
-	verboseLog: (msg: string) => void,
-	extraArgs?: string[],
-): Effect.Effect<void, Error> {
-	return Effect.gen(function* () {
-		const prompt =
-			"Find the next logical task from TASK.md and work on it until complete. Update TASK.md with progress, and commit your changes. Once all tasks are done, output <promise>COMPLETE</promise>"
-
-		// opencode: use `opencode run "prompt"` for non-interactive mode
-		// claude: use `claude "prompt"` (positional argument)
-		const baseArgs = useOpencode ? [cliName, "run", prompt] : [cliName, prompt]
-
-		// Append extra args if provided
-		const cliArgs =
-			extraArgs && extraArgs.length > 0 ? [...baseArgs, ...extraArgs] : baseArgs
-
-		// Log the command being run when verbose
-		// Quote arguments that contain spaces for proper display
-		const quotedArgs = cliArgs.map((arg) =>
-			arg.includes(" ") ? `"${arg}"` : arg,
-		)
-		verboseLog(`Running: ${quotedArgs.join(" ")}`)
-
-		// When verbose, stream output directly to the terminal
-		// When not verbose, capture output silently
-		// Always inherit stdin so the process doesn't hang waiting for input
-		const result = yield* spawnProcess(cliArgs, {
-			cwd: gitRoot,
-			stdin: "inherit",
-			stdout: verbose ? "inherit" : "pipe",
-			stderr: verbose ? "inherit" : "pipe",
-		}).pipe(
-			Effect.catchAll((error) =>
-				Effect.fail(new Error(`${cliName} exited with error: ${error.stderr}`)),
-			),
-		)
-
-		if (result.exitCode !== 0) {
-			return yield* Effect.fail(
-				new Error(`${cliName} exited with code ${result.exitCode}`),
-			)
-		}
-	})
-}
-
-export const help = `
-Usage: agency loop [options] [-- extra-args...]
-
-Run a Ralph Wiggum loop that repeatedly invokes the harness (opencode or claude)
-to work on tasks defined in TASK.md until all tasks are complete.
-
-Each iteration:
-1. Invokes the harness with a prompt to work on the next task
-2. Checks TASK.md for task completion status
-3. Validates completion claims against actual task status
-4. Commits changes if any were made
-5. Repeats until all tasks are done or max loops reached
-
-Options:
-  --max-loops <num>     Maximum number of iterations (default: unlimited)
-  --min-loops <num>     Minimum number of iterations (safety check)
-  --opencode            Force use of OpenCode CLI
-  --claude              Force use of Claude Code CLI
-  -h, --help            Show this help message
-  -s, --silent          Suppress output messages
-  -v, --verbose         Stream harness output to terminal
-
-Pass-through Arguments:
-  Use -- to pass additional arguments to the underlying CLI tool.
-  Everything after -- will be forwarded to opencode or claude.
-
-Examples:
-  agency loop                          # Run until all tasks are done
-  agency loop --max-loops 5            # Stop after 5 iterations
-  agency loop -- --agent deep          # Pass --agent deep to harness
-
-Notes:
-  - Requires TASK.md to exist (run 'agency task' first)
-  - Each iteration calls the harness which handles its own commit
-  - The loop validates that completion claims match actual task status
-  - Use --min-loops as a safeguard if you know the minimum work required
-  - Arguments after -- are passed directly to the underlying tool
-`

package/src/commands/merge.integration.test.ts

@@ -1,195 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { join } from "path"
-import { merge } from "./merge"
-import { emit } from "./emit"
-import { task } from "./task"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	initAgency,
-	getGitOutput,
-	getCurrentBranch,
-	createCommit,
-	branchExists,
-	checkoutBranch,
-	createBranch,
-	addAndCommit,
-	setupRemote,
-	deleteBranch,
-	runTestEffect,
-} from "../test-utils"
-
-// Cache the git-filter-repo availability check (it doesn't change during test run)
-let hasGitFilterRepoCache: boolean | null = null
-async function checkGitFilterRepo(): Promise<boolean> {
-	if (hasGitFilterRepoCache === null) {
-		const proc = Bun.spawn(["which", "git-filter-repo"], {
-			stdout: "pipe",
-			stderr: "pipe",
-		})
-		await proc.exited
-		hasGitFilterRepoCache = proc.exitCode === 0
-	}
-	return hasGitFilterRepoCache
-}
-
-describe("merge command - integration tests (requires git-filter-repo)", () => {
-	let tempDir: string
-	let originalCwd: string
-	let hasGitFilterRepo: boolean
-
-	beforeEach(async () => {
-		tempDir = await createTempDir()
-		originalCwd = process.cwd()
-		process.chdir(tempDir)
-
-		// Set config path to non-existent file to use defaults
-		process.env.AGENCY_CONFIG_PATH = join(tempDir, "non-existent-config.json")
-		// Set config dir to temp dir to avoid picking up user's config files
-		process.env.AGENCY_CONFIG_DIR = await createTempDir()
-
-		// Check if git-filter-repo is available (cached)
-		hasGitFilterRepo = await checkGitFilterRepo()
-
-		// Initialize git repo with main branch (already includes initial commit)
-		await initGitRepo(tempDir)
-
-		// Set up origin for git-filter-repo
-		await setupRemote(tempDir, "origin", tempDir)
-
-		// Create a source branch (with agency-- prefix per new default config)
-		await createBranch(tempDir, "agency--feature")
-
-		// Initialize AGENTS.md on feature branch
-		await initAgency(tempDir, "test")
-
-		await runTestEffect(task({ silent: true, fromCurrent: true }))
-
-		// Ensure agency.json has baseBranch set (task should auto-detect it, but ensure it's there)
-		const agencyJsonPath = join(tempDir, "agency.json")
-		const agencyJson = await Bun.file(agencyJsonPath).json()
-		if (!agencyJson.baseBranch) {
-			agencyJson.baseBranch = "origin/main"
-			await Bun.write(
-				agencyJsonPath,
-				JSON.stringify(agencyJson, null, 2) + "\n",
-			)
-		}
-
-		await addAndCommit(tempDir, "AGENTS.md agency.json", "Add AGENTS.md")
-
-		// Create another commit on feature branch
-		await createCommit(tempDir, "Feature work")
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		delete process.env.AGENCY_CONFIG_PATH
-		if (process.env.AGENCY_CONFIG_DIR) {
-			await cleanupTempDir(process.env.AGENCY_CONFIG_DIR)
-			delete process.env.AGENCY_CONFIG_DIR
-		}
-		await cleanupTempDir(tempDir)
-	})
-
-	describe("merge from source branch", () => {
-		test("creates emit branch and merges when run from source branch", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
-
-			// We're on feature branch (source)
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency--feature")
-
-			// Run merge - should create feature--PR and merge it to main
-			await runTestEffect(merge({ silent: true }))
-
-			// Should be on main branch after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// emit branch should exist
-			const prExists = await branchExists(tempDir, "feature")
-			expect(prExists).toBe(true)
-
-			// Main should have the feature work but not AGENTS.md
-			const files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).not.toContain("AGENTS.md")
-		})
-
-		test("recreates emit branch if it already exists", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
-
-			// Create emit branch first
-			await runTestEffect(emit({ silent: true }))
-
-			// Go back to feature branch
-			await checkoutBranch(tempDir, "agency--feature")
-
-			// Make additional changes
-			await createCommit(tempDir, "More feature work")
-
-			// Run merge - should recreate emit branch with new changes
-			await runTestEffect(merge({ silent: true }))
-
-			// Should be on main after merge
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("main")
-		})
-	})
-
-	describe("merge from emit branch", () => {
-		test("merges emit branch directly when run from emit branch", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
-
-			// Create emit branch
-			await runTestEffect(emit({ silent: true }))
-
-			// emit() now stays on source branch, so we need to checkout to emit branch
-			await checkoutBranch(tempDir, "feature")
-
-			// We're on feature--PR now
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("feature")
-
-			// Run merge - should merge feature--PR to main
-			await runTestEffect(merge({ silent: true }))
-
-			// Should be on main after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// Main should have the feature work but not AGENTS.md
-			const files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).not.toContain("AGENTS.md")
-		})
-
-		test("throws error if emit branch has no corresponding source branch", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
-
-			// Create emit branch
-			await runTestEffect(emit({ silent: true }))
-
-			// pr() now stays on source branch, so checkout to emit branch
-			await checkoutBranch(tempDir, "feature")
-
-			// Delete the source branch
-			await deleteBranch(tempDir, "agency--feature", true)
-
-			// Try to merge - should fail (error message may vary since source branch is deleted)
-			await expect(runTestEffect(merge({ silent: true }))).rejects.toThrow()
-		})
-	})
-})