@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/clean.ts

@@ -1,274 +0,0 @@
-import { Effect } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { ConfigService } from "../services/ConfigService"
-import { parseAgencyMetadata } from "../services/AgencyMetadataService"
-import highlight, { done } from "../utils/colors"
-import { createLoggers, ensureGitRepo } from "../utils/effect"
-import { extractCleanBranch, makeSourceBranchName } from "../utils/pr-branch"
-
-interface CleanOptions extends BaseCommandOptions {
-	dryRun?: boolean
-	mergedInto?: string
-}
-
-/**
- * Read agency.json metadata from a specific branch without checking it out.
- * Uses `git show` to read the file contents directly.
- */
-const readAgencyMetadata = (gitRoot: string, branch: string) =>
-	Effect.gen(function* () {
-		const git = yield* GitService
-
-		// Use git show to read agency.json from the branch without checking out
-		const content = yield* git.getFileAtRef(gitRoot, branch, "agency.json")
-
-		if (!content) {
-			return null
-		}
-
-		return yield* parseAgencyMetadata(content)
-	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-/**
- * Get all local branches
- */
-const getAllLocalBranches = (gitRoot: string) =>
-	Effect.gen(function* () {
-		const git = yield* GitService
-		return yield* git.getAllLocalBranches(gitRoot)
-	}).pipe(Effect.catchAll(() => Effect.succeed([] as readonly string[])))
-
-/**
- * Get all branches that have been fully merged into the specified branch
- */
-const getBranchesMergedInto = (
-	gitRoot: string,
-	targetBranch: string,
-	options: BaseCommandOptions,
-) =>
-	Effect.gen(function* () {
-		const git = yield* GitService
-		const { verboseLog } = createLoggers(options)
-
-		verboseLog(
-			`Finding branches merged into ${highlight.branch(targetBranch)}...`,
-		)
-
-		const mergedBranches = yield* git.getMergedBranches(gitRoot, targetBranch)
-
-		verboseLog(`Found ${mergedBranches.length} merged branches`)
-		return mergedBranches
-	}).pipe(Effect.catchAll(() => Effect.succeed([] as readonly string[])))
-
-/**
- * Find source branches for the given branches (emit branches).
- * For each branch, check if there's a corresponding source branch by:
- * 1. Looking for branches with agency.json that has this branch as emitBranch
- * 2. Using the source branch pattern from config
- */
-const findSourceBranches = (
-	gitRoot: string,
-	branches: readonly string[],
-	sourcePattern: string,
-	emitPattern: string,
-	options: BaseCommandOptions,
-) =>
-	Effect.gen(function* () {
-		const git = yield* GitService
-		const { verboseLog } = createLoggers(options)
-
-		const allBranches = yield* getAllLocalBranches(gitRoot)
-		const sourceBranches: string[] = []
-
-		verboseLog(
-			`Looking for source branches for ${branches.length} emit branches...`,
-		)
-
-		// For each branch in our list, check if it's an emit branch and find its source
-		for (const branch of branches) {
-			// Strategy 1: Check all branches for agency.json with matching emitBranch
-			for (const candidateBranch of allBranches) {
-				if (candidateBranch === branch) continue
-
-				const metadata = yield* readAgencyMetadata(gitRoot, candidateBranch)
-
-				if (metadata?.emitBranch === branch) {
-					verboseLog(
-						`Found source branch ${highlight.branch(candidateBranch)} for emit branch ${highlight.branch(branch)}`,
-					)
-					if (!sourceBranches.includes(candidateBranch)) {
-						sourceBranches.push(candidateBranch)
-					}
-				}
-			}
-
-			// Strategy 2: Try using the source pattern
-			// If emitPattern is "%branch%", the branch name itself is the clean name
-			const cleanBranch =
-				emitPattern === "%branch%"
-					? branch
-					: extractCleanBranch(branch, emitPattern)
-
-			if (cleanBranch) {
-				const possibleSourceBranch = makeSourceBranchName(
-					cleanBranch,
-					sourcePattern,
-				)
-				const sourceExists = yield* git
-					.branchExists(gitRoot, possibleSourceBranch)
-					.pipe(Effect.catchAll(() => Effect.succeed(false)))
-
-				if (sourceExists && !sourceBranches.includes(possibleSourceBranch)) {
-					verboseLog(
-						`Found source branch ${highlight.branch(possibleSourceBranch)} via pattern matching`,
-					)
-					sourceBranches.push(possibleSourceBranch)
-				}
-			}
-		}
-
-		verboseLog(`Found ${sourceBranches.length} source branches`)
-		return sourceBranches
-	})
-
-export const clean = (options: CleanOptions = {}) =>
-	Effect.gen(function* () {
-		const { dryRun = false, mergedInto } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const configService = yield* ConfigService
-		const gitRoot = yield* ensureGitRepo()
-
-		// Require --merged-into flag
-		if (!mergedInto) {
-			return yield* Effect.fail(
-				new Error(
-					"The --merged-into flag is required. Specify which branch to check for merged branches (e.g., --merged-into main)",
-				),
-			)
-		}
-
-		// Verify the target branch exists
-		const targetExists = yield* git.branchExists(gitRoot, mergedInto)
-		if (!targetExists) {
-			return yield* Effect.fail(
-				new Error(
-					`Branch ${highlight.branch(mergedInto)} does not exist. Please specify a valid branch.`,
-				),
-			)
-		}
-
-		// Load config to get source and emit patterns
-		const config = yield* configService.loadConfig()
-		const sourcePattern = config.sourceBranchPattern || "agency--%branch%"
-		const emitPattern = config.emitBranch || "%branch%"
-
-		verboseLog(
-			`Using source pattern: ${sourcePattern}, emit pattern: ${emitPattern}`,
-		)
-
-		// Get all branches merged into target
-		const mergedBranches = yield* getBranchesMergedInto(
-			gitRoot,
-			mergedInto,
-			options,
-		)
-		verboseLog(
-			`Found ${mergedBranches.length} branches merged into ${highlight.branch(mergedInto)}`,
-		)
-
-		// Find source branches for the merged branches
-		const sourceBranches = yield* findSourceBranches(
-			gitRoot,
-			mergedBranches,
-			sourcePattern,
-			emitPattern,
-			options,
-		)
-
-		// Combine merged branches and their source branches
-		const branchesToDelete = [
-			...new Set([...mergedBranches, ...sourceBranches]),
-		]
-
-		// Filter out the target branch itself (we don't want to delete it)
-		const filteredBranches = branchesToDelete.filter(
-			(branch) => branch !== mergedInto,
-		)
-
-		if (filteredBranches.length === 0) {
-			log(
-				`No branches found that are merged into ${highlight.branch(mergedInto)}`,
-			)
-			return
-		}
-
-		// Show what will be deleted
-		const branchWord = filteredBranches.length === 1 ? "branch" : "branches"
-		log(
-			`Found ${filteredBranches.length} ${branchWord} to delete (merged into ${highlight.branch(mergedInto)}):`,
-		)
-		for (const branch of filteredBranches) {
-			log(`  ${highlight.branch(branch)}`)
-		}
-
-		if (dryRun) {
-			log("")
-			log("Dry-run mode: no branches were deleted")
-			return
-		}
-
-		// Get current branch to avoid deleting it
-		const currentBranch = yield* git.getCurrentBranch(gitRoot)
-
-		// Delete all branches
-		log("")
-		for (const branch of filteredBranches) {
-			// If we're currently on the branch, switch away first
-			if (currentBranch === branch) {
-				verboseLog(
-					`Currently on ${highlight.branch(branch)}, switching to ${highlight.branch(mergedInto)}`,
-				)
-				yield* git.checkoutBranch(gitRoot, mergedInto)
-			}
-
-			verboseLog(`Deleting ${highlight.branch(branch)}...`)
-			yield* git.deleteBranch(gitRoot, branch, true)
-		}
-
-		const deletedBranchWord =
-			filteredBranches.length === 1 ? "branch" : "branches"
-		log(done(`Deleted ${filteredBranches.length} ${deletedBranchWord}`))
-	})
-
-export const help = `
-Usage: agency clean --merged-into <branch> [options]
-
-Delete all branches that have been fully merged into a specified branch, 
-along with their corresponding source branches.
-
-This command is useful for cleaning up branches after they've been merged.
-It will:
-1. Find all branches fully merged into the specified branch
-2. Find the corresponding source branches (which won't show as merged due to emit filtering)
-3. Delete both the merged branches and their source branches
-
-The --merged-into flag is REQUIRED to prevent accidental deletion of branches.
-
-Options:
-  --merged-into <branch>  Branch to check against (e.g., main, origin/main) [REQUIRED]
-  --dry-run              Show what would be deleted without actually deleting
-
-Safety:
-  - By default, this command deletes branches
-  - Use --dry-run to preview what would be deleted without making changes
-  - If currently on a branch that will be deleted, switches to the target branch first
-  - Uses force delete (git branch -D) to ensure branches are deleted
-
-Examples:
-  agency clean --merged-into main           # Delete branches merged into main
-  agency clean --merged-into main --dry-run # Preview what would be deleted
-  agency clean --merged-into origin/main    # Delete branches merged into origin/main
-`

package/src/commands/completions.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { completions } from "./completions"
-
-const captureCompletions = async (shell: string) => {
-	const originalLog = console.log
-	let output = ""
-	console.log = (message: string) => {
-		output += message
-	}
-
-	try {
-		await Effect.runPromise(completions(shell))
-	} finally {
-		console.log = originalLog
-	}
-
-	return output
-}
-
-describe("completions command", () => {
-	test("generates bash completions", async () => {
-		const output = await captureCompletions("bash")
-
-		expect(output).toContain("_agency_completions()")
-		expect(output).toContain("complete -F _agency_completions agency")
-		expect(output).toContain("completions")
-		expect(output).toContain("bash zsh")
-	})
-
-	test("generates zsh completions", async () => {
-		const output = await captureCompletions("zsh")
-
-		expect(output).toContain("#compdef agency")
-		expect(output).toContain("_agency()")
-		expect(output).toContain("agency_commands=(")
-		expect(output).toContain("bash\\:Generate\\ bash\\ completions")
-	})
-
-	test("prints the requested completion script", async () => {
-		const output = await captureCompletions("zsh")
-
-		expect(output).toContain("#compdef agency")
-	})
-
-	test("rejects unsupported shells", async () => {
-		await expect(Effect.runPromise(completions("fish"))).rejects.toThrow(
-			"Usage: agency completions <bash|zsh>",
-		)
-	})
-})

package/src/commands/completions.ts

@@ -1,308 +0,0 @@
-import { Effect } from "effect"
-
-const shells = ["bash", "zsh"] as const
-type Shell = (typeof shells)[number]
-
-const commands = [
-	"init",
-	"task",
-	"tasks",
-	"edit",
-	"work",
-	"template",
-	"emit",
-	"emitted",
-	"pr",
-	"push",
-	"pull",
-	"rebase",
-	"base",
-	"switch",
-	"source",
-	"merge",
-	"status",
-	"clean",
-	"loop",
-	"completions",
-] as const
-
-const templateSubcommands = ["use", "save", "list", "view", "delete"] as const
-const baseSubcommands = ["get", "set"] as const
-const completionSubcommands = shells
-
-const globalOptions = [
-	"--help",
-	"-h",
-	"--version",
-	"-v",
-	"--no-color",
-	"--silent",
-	"-s",
-	"--verbose",
-] as const
-
-const commandOptions: Record<string, readonly string[]> = {
-	init: [
-		"--help",
-		"-h",
-		"--template",
-		"-t",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	emit: [
-		"--help",
-		"-h",
-		"--emit",
-		"--branch",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	push: [
-		"--help",
-		"-h",
-		"--emit",
-		"--branch",
-		"--force",
-		"-f",
-		"--no-verify",
-		"--pr",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	pull: ["--help", "-h", "--remote", "-r", "--silent", "-s", "--verbose", "-v"],
-	rebase: [
-		"--help",
-		"-h",
-		"--emit",
-		"--branch",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	task: [
-		"--help",
-		"-h",
-		"--emit",
-		"--branch",
-		"--task",
-		"--from",
-		"--from-current",
-		"--continue",
-		"--squash",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	tasks: ["--help", "-h", "--json", "--silent", "-s", "--verbose", "-v"],
-	base: ["--help", "-h", "--repo", "--silent", "-s", "--verbose", "-v"],
-	template: [
-		"--help",
-		"-h",
-		"--template",
-		"-t",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	work: [
-		"--help",
-		"-h",
-		"--opencode",
-		"--claude",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	loop: [
-		"--help",
-		"-h",
-		"--min-loops",
-		"--max-loops",
-		"--opencode",
-		"--claude",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	status: ["--help", "-h", "--json", "--silent", "-s", "--verbose", "-v"],
-	clean: [
-		"--help",
-		"-h",
-		"--dry-run",
-		"--merged-into",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	],
-	completions: ["--help", "-h"],
-}
-
-const words = (values: readonly string[]) => values.join(" ")
-
-const bashCase = (command: string, subcommands?: readonly string[]) => {
-	const options = commandOptions[command] ?? [
-		"--help",
-		"-h",
-		"--silent",
-		"-s",
-		"--verbose",
-		"-v",
-	]
-	const completions = subcommands ? [...subcommands, ...options] : options
-	return `\t\t${command})\n\t\t\tCOMPREPLY=( $(compgen -W "${words(completions)}" -- "$cur") )\n\t\t\treturn 0\n\t\t\t;;`
-}
-
-const zshCommandSpec = (command: string, description: string) =>
-	`    '${command}:${description}'`
-
-const generateBashCompletions = () => `# bash completion for agency
-_agency_completions() {
-	local cur prev command
-	COMPREPLY=()
-	cur="\${COMP_WORDS[COMP_CWORD]}"
-	prev="\${COMP_WORDS[COMP_CWORD-1]}"
-
-	if [[ $COMP_CWORD -eq 1 ]]; then
-		COMPREPLY=( $(compgen -W "${words([...commands, ...globalOptions])}" -- "$cur") )
-		return 0
-	fi
-
-	command="\${COMP_WORDS[1]}"
-	case "$command" in
-${bashCase("template", templateSubcommands)}
-${bashCase("base", baseSubcommands)}
-${bashCase("completions", completionSubcommands)}
-${commands
-	.filter((command) => !["template", "base", "completions"].includes(command))
-	.map((command) => bashCase(command))
-	.join("\n")}
-	esac
-
-	case "$prev" in
-		--template|-t|--emit|--branch|--task|--from|--remote|-r|--merged-into)
-			return 0
-			;;
-	esac
-}
-
-complete -F _agency_completions agency
-`
-
-const generateZshCompletions = () => `#compdef agency
-# zsh completion for agency
-
-_agency() {
-  local context state line
-  local -a agency_commands
-  typeset -A opt_args
-
-  agency_commands=(
-${zshCommandSpec("init", "Initialize agency with template selection")}
-${zshCommandSpec("task", "Initialize template files on a feature branch")}
-${zshCommandSpec("tasks", "List all task branches")}
-${zshCommandSpec("edit", "Open TASK.md in system editor")}
-${zshCommandSpec("work", "Start working on TASK.md with OpenCode")}
-${zshCommandSpec("template", "Template management commands")}
-${zshCommandSpec("emit", "Emit a branch with backpack files reverted")}
-${zshCommandSpec("emitted", "Get the name of the emitted branch")}
-${zshCommandSpec("pr", "Run gh pr with the emitted branch name")}
-${zshCommandSpec("push", "Emit, push to remote, return to source")}
-${zshCommandSpec("pull", "Pull commits from remote emit branch to source")}
-${zshCommandSpec("rebase", "Rebase source branch onto base branch")}
-${zshCommandSpec("base", "Get or set the base branch")}
-${zshCommandSpec("switch", "Toggle between source and emitted branch")}
-${zshCommandSpec("source", "Switch to source branch from emitted branch")}
-${zshCommandSpec("merge", "Merge emitted branch into base branch")}
-${zshCommandSpec("status", "Show agency status for this repository")}
-${zshCommandSpec("clean", "Delete branches merged into a specified branch")}
-${zshCommandSpec("loop", "Run a Ralph Wiggum loop to complete all tasks")}
-${zshCommandSpec("completions", "Generate shell completion scripts")}
-  )
-
-  _arguments -C \\
-    '(-h --help)'{-h,--help}'[show help]' \\
-    '(-v --version)'{-v,--version}'[show version]' \\
-    '--no-color[disable color output]' \\
-    '(-s --silent)'{-s,--silent}'[suppress output messages]' \\
-    '--verbose[show verbose output]' \\
-    '1:command:->command' \\
-    '*::arg:->args'
-
-  case $state in
-    command)
-      _describe 'agency command' agency_commands
-      ;;
-    args)
-      case $line[1] in
-        template)
-          _arguments \\
-            '(-h --help)'{-h,--help}'[show help]' \\
-            '(-t --template)'{-t,--template}'[template name]:template:' \\
-            '(-s --silent)'{-s,--silent}'[suppress output messages]' \\
-            '--verbose[show verbose output]' \\
-            '1:subcommand:((use\\:Set\\ template save\\:Save\\ files list\\:List\\ files view\\:View\\ file delete\\:Delete\\ files))' \\
-            '*:file:_files'
-          ;;
-        base)
-          _arguments \\
-            '(-h --help)'{-h,--help}'[show help]' \\
-            '--repo[use repository-local configuration]' \\
-            '(-s --silent)'{-s,--silent}'[suppress output messages]' \\
-            '--verbose[show verbose output]' \\
-            '1:subcommand:((get\\:Get\\ base\\ branch set\\:Set\\ base\\ branch))' \\
-            '*:branch:'
-          ;;
-        completions)
-          _arguments \\
-            '(-h --help)'{-h,--help}'[show help]' \\
-            '1:shell:((bash\\:Generate\\ bash\\ completions zsh\\:Generate\\ zsh\\ completions))'
-          ;;
-        *)
-          _arguments \\
-            '(-h --help)'{-h,--help}'[show help]' \\
-            '(-s --silent)'{-s,--silent}'[suppress output messages]' \\
-            '--verbose[show verbose output]'
-          ;;
-      esac
-      ;;
-  esac
-}
-
-_agency "$@"
-`
-
-export const completions = (shell: string | undefined) =>
-	Effect.gen(function* () {
-		if (!shell || !shells.includes(shell as Shell)) {
-			return yield* Effect.fail(
-				new Error("Usage: agency completions <bash|zsh>"),
-			)
-		}
-
-		console.log(
-			shell === "bash" ? generateBashCompletions() : generateZshCompletions(),
-		)
-	})
-
-export const help = `
-Usage: agency completions <bash|zsh>
-
-Generate shell completion scripts.
-
-Examples:
-  agency completions zsh > ~/.zsh/completions/_agency
-  agency completions bash > ~/.local/share/bash-completion/completions/agency
-`