@markjaquith/agency 0.5.0 → 0.6.0

package/src/commands/task.ts

@@ -1,4 +1,4 @@
-import { resolve, join } from "path"
+import { resolve, join, dirname } from "path"
 import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
 import { GitService } from "../services/GitService"
@@ -8,6 +8,10 @@ import { PromptService } from "../services/PromptService"
 import { TemplateService } from "../services/TemplateService"
 import { OpencodeService } from "../services/OpencodeService"
 import { ClaudeService } from "../services/ClaudeService"
+import {
+	AgencyMetadataService,
+	AgencyMetadataServiceLive,
+} from "../services/AgencyMetadataService"
 import { initializeManagedFiles, writeAgencyMetadata } from "../types"
 import { RepositoryNotInitializedError } from "../errors"
 import highlight, { done, info, plural } from "../utils/colors"
@@ -17,22 +21,291 @@ import {
 	extractCleanBranch,
 	makeSourceBranchName,
 } from "../utils/pr-branch"
+import { getTopLevelDir, dirToGlobPattern } from "../utils/glob"
 
 interface TaskOptions extends BaseCommandOptions {
 	path?: string
 	task?: string
-	branch?: string
+	emit?: string
+	branch?: string // Deprecated: use emit instead
 	from?: string
 	fromCurrent?: boolean
+	continue?: boolean
 }
 
 interface TaskEditOptions extends BaseCommandOptions {}
 
+/**
+ * Continue a task by creating a new branch with the same agency files.
+ * This is useful after a PR is merged and you want to continue working on the task.
+ */
+const taskContinue = (options: TaskOptions) =>
+	Effect.gen(function* () {
+		const { silent = false } = options
+		const { log, verboseLog } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+		const fs = yield* FileSystemService
+		const promptService = yield* PromptService
+
+		// Determine target path
+		let targetPath: string
+
+		if (options.path) {
+			targetPath = resolve(options.path)
+			const isRoot = yield* git.isGitRoot(targetPath)
+			if (!isRoot) {
+				return yield* Effect.fail(
+					new Error(
+						"The specified path is not the root of a git repository. Please provide a path to the top-level directory of a git checkout.",
+					),
+				)
+			}
+		} else {
+			const isRepo = yield* git.isInsideGitRepo(process.cwd())
+			if (!isRepo) {
+				return yield* Effect.fail(
+					new Error(
+						"Not in a git repository. Please run this command inside a git repo.",
+					),
+				)
+			}
+			targetPath = yield* git.getGitRoot(process.cwd())
+		}
+
+		// Check if initialized (has template in git config)
+		const templateName = yield* getTemplateName(targetPath)
+		if (!templateName) {
+			return yield* Effect.fail(new RepositoryNotInitializedError())
+		}
+
+		const currentBranch = yield* git.getCurrentBranch(targetPath)
+		verboseLog(`Current branch: ${highlight.branch(currentBranch)}`)
+
+		// Load agency config for branch patterns
+		const config = yield* configService.loadConfig()
+
+		// Verify we're on an agency source branch by checking if agency.json exists
+		const agencyJsonPath = resolve(targetPath, "agency.json")
+		const hasAgencyJson = yield* fs.exists(agencyJsonPath)
+
+		if (!hasAgencyJson) {
+			return yield* Effect.fail(
+				new Error(
+					`No agency.json found on current branch ${highlight.branch(currentBranch)}.\n` +
+						`The --continue flag requires you to be on an agency source branch with existing agency files.`,
+				),
+			)
+		}
+
+		// Read the existing agency.json to get metadata
+		const existingMetadata = yield* Effect.gen(function* () {
+			const service = yield* AgencyMetadataService
+			return yield* service.readFromDisk(targetPath)
+		}).pipe(Effect.provide(AgencyMetadataServiceLive))
+
+		if (!existingMetadata) {
+			return yield* Effect.fail(
+				new Error(
+					`Failed to read agency.json on branch ${highlight.branch(currentBranch)}.`,
+				),
+			)
+		}
+
+		verboseLog(
+			`Existing metadata: ${JSON.stringify(existingMetadata, null, 2)}`,
+		)
+
+		// Get the list of agency files to copy
+		const filesToCopy = [
+			"agency.json",
+			"TASK.md",
+			"AGENCY.md",
+			...existingMetadata.injectedFiles,
+		]
+		verboseLog(`Files to copy: ${filesToCopy.join(", ")}`)
+
+		// Read all the existing files content before switching branches
+		const fileContents = new Map<string, string>()
+		for (const file of filesToCopy) {
+			const filePath = resolve(targetPath, file)
+			const exists = yield* fs.exists(filePath)
+			if (exists) {
+				const content = yield* fs.readFile(filePath)
+				fileContents.set(file, content)
+				verboseLog(`Read ${file} (${content.length} bytes)`)
+			} else {
+				verboseLog(`File ${file} not found, skipping`)
+			}
+		}
+
+		// Prompt for new branch name if not provided
+		let branchName = options.emit || options.branch
+		if (!branchName) {
+			if (silent) {
+				return yield* Effect.fail(
+					new Error(
+						"Branch name is required with --continue in silent mode. Use --emit to specify one.",
+					),
+				)
+			}
+			branchName = yield* promptService.prompt("New branch name: ")
+			if (!branchName) {
+				return yield* Effect.fail(
+					new Error("Branch name is required to continue the task."),
+				)
+			}
+		}
+
+		// Apply source pattern to get the full source branch name
+		const sourceBranchName = makeSourceBranchName(
+			branchName,
+			config.sourceBranchPattern,
+		)
+
+		// Check if the new branch already exists
+		const branchExists = yield* git.branchExists(targetPath, sourceBranchName)
+		if (branchExists) {
+			return yield* Effect.fail(
+				new Error(
+					`Branch ${highlight.branch(sourceBranchName)} already exists.\n` +
+						`Choose a different branch name.`,
+				),
+			)
+		}
+
+		// Determine base branch to branch from
+		let baseBranchToBranchFrom: string | undefined
+
+		if (options.from) {
+			baseBranchToBranchFrom = options.from
+			const exists = yield* git.branchExists(targetPath, baseBranchToBranchFrom)
+			if (!exists) {
+				return yield* Effect.fail(
+					new Error(
+						`Branch ${highlight.branch(baseBranchToBranchFrom)} does not exist.`,
+					),
+				)
+			}
+		} else {
+			// Default: branch from main upstream branch (preferring remote)
+			baseBranchToBranchFrom =
+				(yield* git.resolveMainBranch(targetPath)) || undefined
+		}
+
+		if (!baseBranchToBranchFrom) {
+			return yield* Effect.fail(
+				new Error(
+					"Could not determine base branch. Use --from to specify one.",
+				),
+			)
+		}
+
+		verboseLog(
+			`Creating new branch ${highlight.branch(sourceBranchName)} from ${highlight.branch(baseBranchToBranchFrom)}`,
+		)
+
+		// Create the new branch from the base branch
+		yield* git.createBranch(
+			sourceBranchName,
+			targetPath,
+			baseBranchToBranchFrom,
+		)
+		log(
+			done(
+				`Created and switched to branch ${highlight.branch(sourceBranchName)} based on ${highlight.branch(baseBranchToBranchFrom)}`,
+			),
+		)
+
+		// Calculate the new emit branch name
+		const newEmitBranchName = makeEmitBranchName(branchName, config.emitBranch)
+		verboseLog(`New emit branch name: ${newEmitBranchName}`)
+
+		// Write all the files to the new branch
+		const createdFiles: string[] = []
+
+		for (const [file, content] of fileContents) {
+			const filePath = resolve(targetPath, file)
+
+			// Ensure parent directory exists
+			const parentDir = resolve(filePath, "..")
+			const parentExists = yield* fs.exists(parentDir)
+			if (!parentExists) {
+				yield* fs.runCommand(["mkdir", "-p", parentDir])
+			}
+
+			let fileContent = content
+
+			// Update emitBranch in agency.json
+			if (file === "agency.json") {
+				const metadata = JSON.parse(content)
+				metadata.emitBranch = newEmitBranchName
+				metadata.createdAt = new Date().toISOString()
+				fileContent = JSON.stringify(metadata, null, 2) + "\n"
+				verboseLog(
+					`Updated agency.json with new emitBranch: ${newEmitBranchName}`,
+				)
+			}
+
+			// Update emitBranch in opencode.json (if it has one)
+			if (file === "opencode.json" || file.endsWith("/opencode.json")) {
+				try {
+					const opencodeConfig = JSON.parse(content)
+					if (opencodeConfig.emitBranch) {
+						opencodeConfig.emitBranch = newEmitBranchName
+						fileContent = JSON.stringify(opencodeConfig, null, "\t") + "\n"
+						verboseLog(
+							`Updated ${file} with new emitBranch: ${newEmitBranchName}`,
+						)
+					}
+				} catch {
+					// If we can't parse it, just copy as-is
+				}
+			}
+
+			yield* fs.writeFile(filePath, fileContent)
+			createdFiles.push(file)
+			log(done(`Created ${highlight.file(file)}`))
+		}
+
+		// Git add and commit the created files
+		if (createdFiles.length > 0) {
+			yield* Effect.gen(function* () {
+				yield* git.gitAdd(createdFiles, targetPath)
+				// Format: chore: agency task --continue (baseBranch) originalSource => newSource => newEmit
+				const commitMessage = `chore: agency task --continue (${baseBranchToBranchFrom}) ${currentBranch} → ${sourceBranchName} → ${newEmitBranchName}`
+				yield* git.gitCommit(commitMessage, targetPath, {
+					noVerify: true,
+				})
+				verboseLog(
+					`Committed ${createdFiles.length} file${plural(createdFiles.length)}`,
+				)
+			}).pipe(
+				Effect.catchAll((err) => {
+					verboseLog(`Failed to commit: ${err}`)
+					return Effect.void
+				}),
+			)
+		}
+
+		log(
+			info(
+				`Continued task with ${createdFiles.length} file${plural(createdFiles.length)} from ${highlight.branch(currentBranch)}`,
+			),
+		)
+	})
+
 export const task = (options: TaskOptions = {}) =>
 	Effect.gen(function* () {
 		const { silent = false, verbose = false } = options
 		const { log, verboseLog } = createLoggers(options)
 
+		// Handle --continue flag
+		if (options.continue) {
+			return yield* taskContinue(options)
+		}
+
 		const git = yield* GitService
 		const configService = yield* ConfigService
 		const fs = yield* FileSystemService
@@ -72,6 +345,9 @@ export const task = (options: TaskOptions = {}) =>
 
 		const createdFiles: string[] = []
 		const injectedFiles: string[] = []
+		// Track directories that we create during this task
+		// These will be converted to glob patterns for filtering
+		const createdDirs = new Set<string>()
 
 		// Check if initialized (has template in git config)
 		const templateName = yield* getTemplateName(targetPath)
@@ -124,32 +400,9 @@ export const task = (options: TaskOptions = {}) =>
 				)
 			}
 		} else {
-			// Default: determine main upstream branch
+			// Default: determine main upstream branch (preferring remote)
 			baseBranchToBranchFrom =
-				(yield* git.getMainBranchConfig(targetPath)) ||
-				(yield* git.findMainBranch(targetPath)) ||
-				undefined
-
-			// If still no base branch, try to auto-detect from remote
-			if (!baseBranchToBranchFrom) {
-				const remote = yield* git
-					.resolveRemote(targetPath)
-					.pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-				const commonBases: string[] = []
-				if (remote) {
-					commonBases.push(`${remote}/main`, `${remote}/master`)
-				}
-				commonBases.push("main", "master")
-
-				for (const base of commonBases) {
-					const exists = yield* git.branchExists(targetPath, base)
-					if (exists) {
-						baseBranchToBranchFrom = base
-						break
-					}
-				}
-			}
+				(yield* git.resolveMainBranch(targetPath)) || undefined
 
 			if (baseBranchToBranchFrom) {
 				verboseLog(
@@ -158,10 +411,12 @@ export const task = (options: TaskOptions = {}) =>
 			}
 		}
 
+		// Load config early for branch pattern operations
+		const config = yield* configService.loadConfig()
+
 		// Check if the base branch is an agency source branch
 		// If so, we need to emit it first and use the emit branch instead
 		if (baseBranchToBranchFrom) {
-			const config = yield* configService.loadConfig()
 			const cleanFromBase = extractCleanBranch(
 				baseBranchToBranchFrom,
 				config.sourceBranchPattern,
@@ -200,10 +455,20 @@ export const task = (options: TaskOptions = {}) =>
 			}
 		}
 
-		// If on main branch without a branch name, prompt for it (unless in silent mode)
-		let branchName = options.branch
-		if (!isFeature && !branchName) {
+		// Determine branch name logic
+		let branchName = options.emit || options.branch
+
+		// If on main branch or using --from without a branch name, prompt for it (unless in silent mode)
+		if ((!isFeature || options.from) && !branchName) {
 			if (silent) {
+				if (options.from) {
+					return yield* Effect.fail(
+						new Error(
+							`Branch name is required when using --from flag.\n` +
+								`Use: 'agency task <branch-name> --from ${options.from}'`,
+						),
+					)
+				}
 				return yield* Effect.fail(
 					new Error(
 						`You're currently on ${highlight.branch(currentBranch)}, which appears to be your main branch.\n` +
@@ -215,9 +480,7 @@ export const task = (options: TaskOptions = {}) =>
 			}
 			branchName = yield* promptService.prompt("Branch name: ")
 			if (!branchName) {
-				return yield* Effect.fail(
-					new Error("Branch name is required when on main branch."),
-				)
+				return yield* Effect.fail(new Error("Branch name is required."))
 			}
 			verboseLog(`Branch name from prompt: ${branchName}`)
 		}
@@ -225,7 +488,6 @@ export const task = (options: TaskOptions = {}) =>
 		// If we have a branch name, apply source pattern and check if branch exists
 		let sourceBranchName: string | undefined
 		if (branchName) {
-			const config = yield* configService.loadConfig()
 			sourceBranchName = makeSourceBranchName(
 				branchName,
 				config.sourceBranchPattern,
@@ -377,6 +639,18 @@ export const task = (options: TaskOptions = {}) =>
 				continue
 			}
 
+			// Check if this file is in a subdirectory that doesn't exist yet
+			// If so, we'll track it for glob pattern creation
+			const topLevelDir = getTopLevelDir(fileName)
+			if (topLevelDir && source === "template") {
+				const dirPath = resolve(targetPath, topLevelDir)
+				const dirExists = yield* fs.exists(dirPath)
+				if (!dirExists) {
+					createdDirs.add(topLevelDir)
+					verboseLog(`Will create new directory: ${topLevelDir}`)
+				}
+			}
+
 			let content: string
 
 			// Try to read from template first, fall back to default content
@@ -395,12 +669,24 @@ export const task = (options: TaskOptions = {}) =>
 				verboseLog(`Replaced {task} placeholder with: ${taskDescription}`)
 			}
 
+			// Ensure parent directory exists before writing file
+			const parentDir = dirname(targetFilePath)
+			const parentExists = yield* fs.exists(parentDir)
+			if (!parentExists) {
+				yield* fs.createDirectory(parentDir)
+			}
+
 			yield* fs.writeFile(targetFilePath, content)
 			createdFiles.push(fileName)
 
 			// Track backpack files (excluding TASK.md and AGENCY.md which are always filtered)
+			// For files in new directories, the glob pattern will be added below
 			if (fileName !== "TASK.md" && fileName !== "AGENCY.md") {
-				injectedFiles.push(fileName)
+				// Only track individual files if they're NOT in a newly created directory
+				// (directories will be tracked as glob patterns)
+				if (!topLevelDir || !createdDirs.has(topLevelDir)) {
+					injectedFiles.push(fileName)
+				}
 			}
 
 			log(done(`Created ${highlight.file(fileName)}`))
@@ -423,34 +709,9 @@ export const task = (options: TaskOptions = {}) =>
 		baseBranch =
 			(yield* git.getDefaultBaseBranchConfig(targetPath)) || undefined
 
-		// If no repo-level default, try to auto-detect
+		// If no repo-level default, try to auto-detect (preferring remote)
 		if (!baseBranch) {
-			// Try main branch config
-			baseBranch =
-				(yield* git.getMainBranchConfig(targetPath)) ||
-				(yield* git.findMainBranch(targetPath)) ||
-				undefined
-
-			// Try common base branches with dynamic remote
-			if (!baseBranch) {
-				const remote = yield* git
-					.resolveRemote(targetPath)
-					.pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-				const commonBases: string[] = []
-				if (remote) {
-					commonBases.push(`${remote}/main`, `${remote}/master`)
-				}
-				commonBases.push("main", "master")
-
-				for (const base of commonBases) {
-					const exists = yield* git.branchExists(targetPath, base)
-					if (exists) {
-						baseBranch = base
-						break
-					}
-				}
-			}
+			baseBranch = (yield* git.resolveMainBranch(targetPath)) || undefined
 		}
 
 		if (baseBranch) {
@@ -459,12 +720,19 @@ export const task = (options: TaskOptions = {}) =>
 
 		// Calculate emitBranch name from current branch
 		const finalBranch = yield* git.getCurrentBranch(targetPath)
-		const config = yield* configService.loadConfig()
 		// Extract clean branch name from source pattern, or use branch as-is for legacy branches
 		const cleanBranch =
 			extractCleanBranch(finalBranch, config.sourceBranchPattern) || finalBranch
 		const emitBranchName = makeEmitBranchName(cleanBranch, config.emitBranch)
 
+		// Convert created directories to glob patterns and add to injectedFiles
+		// This allows filtering all files in new directories during emit
+		for (const dir of createdDirs) {
+			const globPattern = dirToGlobPattern(dir)
+			injectedFiles.push(globPattern)
+			verboseLog(`Tracking directory as glob pattern: ${globPattern}`)
+		}
+
 		// Create agency.json metadata file
 		const metadata = {
 			version: 1 as const,
@@ -489,7 +757,11 @@ export const task = (options: TaskOptions = {}) =>
 		if (createdFiles.length > 0) {
 			yield* Effect.gen(function* () {
 				yield* git.gitAdd(createdFiles, targetPath)
-				yield* git.gitCommit("chore: agency task", targetPath, {
+				// Format: chore: agency task (baseBranch) sourceBranch → emitBranch
+				const commitMessage = baseBranch
+					? `chore: agency task (${baseBranch}) ${finalBranch} → ${emitBranchName}`
+					: `chore: agency task ${finalBranch} → ${emitBranchName}`
+				yield* git.gitCommit(commitMessage, targetPath, {
 					noVerify: true,
 				})
 				verboseLog(
@@ -519,14 +791,11 @@ const createFeatureBranchEffect = (
 		const git = yield* GitService
 		const promptService = yield* PromptService
 
-		// Use provided base branch if available, otherwise get or prompt for one
+		// Use provided base branch if available, otherwise resolve (preferring remote)
 		let baseBranch: string | undefined = providedBaseBranch
 
 		if (!baseBranch) {
-			baseBranch =
-				(yield* git.getMainBranchConfig(targetPath)) ||
-				(yield* git.findMainBranch(targetPath)) ||
-				undefined
+			baseBranch = (yield* git.resolveMainBranch(targetPath)) || undefined
 		}
 
 		// If no base branch is configured and not in silent mode, prompt for it
@@ -538,13 +807,6 @@ const createFeatureBranchEffect = (
 					suggestions,
 				)
 				verboseLog(`Selected base branch: ${baseBranch}`)
-
-				// Save the main branch config if it's not already set
-				const mainBranchConfig = yield* git.getMainBranchConfig(targetPath)
-				if (!mainBranchConfig) {
-					yield* git.setMainBranchConfig(baseBranch, targetPath)
-					log(done(`Set main branch to ${highlight.branch(baseBranch)}`))
-				}
 			} else {
 				return yield* Effect.fail(
 					new Error(
@@ -607,7 +869,6 @@ const taskEditEffect = (options: TaskEditOptions = {}) =>
 	Effect.gen(function* () {
 		const { log, verboseLog } = createLoggers(options)
 
-		const git = yield* GitService
 		const fs = yield* FileSystemService
 
 		const gitRoot = yield* ensureGitRepo()
@@ -644,6 +905,22 @@ const taskEditEffect = (options: TaskEditOptions = {}) =>
 		log(done("TASK.md edited"))
 	})
 
+export const editHelp = `
+Usage: agency edit [options]
+
+Open TASK.md in the system editor for editing.
+
+Notes:
+  - Requires TASK.md to exist (run 'agency task' first)
+  - Respects VISUAL and EDITOR environment variables
+  - On macOS, defaults to 'open' which uses the default app for .md files
+  - On other platforms, defaults to 'vim'
+  - The command waits for the editor to close before returning
+
+Example:
+  agency edit                   # Open TASK.md in default editor
+`
+
 export const help = `
 Usage: agency task [branch-name] [options]
 
@@ -663,9 +940,23 @@ Arguments:
   branch-name       Create and switch to this branch before initializing
 
 Options:
-  -b, --branch      Branch name to create (alternative to positional arg)
+  --emit            Branch name to create (alternative to positional arg)
+  --branch          (Deprecated: use --emit) Branch name to create
   --from <branch>   Branch to branch from instead of main upstream branch
   --from-current    Branch from the current branch
+  --continue        Continue a task by copying agency files to a new branch
+
+Continue Mode (--continue):
+  After a PR is merged, use '--continue' to create a new branch that preserves
+  your agency files (TASK.md, AGENCY.md, opencode.json, agency.json, and all
+  backpacked files). This allows you to continue working on a task after its
+  PR has been merged to main.
+  
+  The continue workflow:
+  1. Be on an agency source branch with agency files
+  2. Run 'agency task --continue <new-branch-name>'
+  3. A new branch is created from main with all your agency files
+  4. The emitBranch in agency.json is updated for the new branch
 
 Base Branch Selection:
   By default, 'agency task' branches from the main upstream branch (e.g., origin/main).
@@ -683,6 +974,7 @@ Examples:
   agency task --from agency/branch-B   # Branch from agency/branch-B's emit branch
   agency task --from-current           # Branch from current branch's emit branch
   agency task my-feature --from develop # Create 'my-feature' from 'develop'
+  agency task --continue my-feature-v2 # Continue task on new branch after PR merge
 
 Template Workflow:
   1. Run 'agency init' to select template (saved to .git/config)

package/src/services/AgencyMetadataService.ts

@@ -4,6 +4,7 @@ import { Schema } from "@effect/schema"
 import { AgencyMetadata } from "../schemas"
 import { FileSystemService } from "./FileSystemService"
 import { GitService } from "./GitService"
+import { expandGlobs } from "../utils/glob"
 
 /**
  * Error type for AgencyMetadata operations
@@ -184,7 +185,14 @@ export const AgencyMetadataServiceLive = Layer.succeed(
 					return baseFiles
 				}
 
-				return [...baseFiles, ...metadata.injectedFiles]
+				// Expand any glob patterns in injectedFiles to actual file paths
+				const expandedFiles = yield* Effect.tryPromise({
+					try: () =>
+						expandGlobs([...baseFiles, ...metadata.injectedFiles], gitRoot),
+					catch: () => new Error("Failed to expand glob patterns"),
+				})
+
+				return expandedFiles
 			}).pipe(
 				Effect.catchAll(() =>
 					Effect.succeed(["TASK.md", "AGENCY.md", "agency.json"]),