@markjaquith/agency 1.7.0 → 1.8.1

package/cli.ts

@@ -30,6 +30,7 @@ import { TemplateService } from "./src/services/TemplateService"
 import { OpencodeService } from "./src/services/OpencodeService"
 import { ClaudeService } from "./src/services/ClaudeService"
 import { FilterRepoService } from "./src/services/FilterRepoService"
+import { FormatterService } from "./src/services/FormatterService"
 
 // Create CLI layer with all services
 const CliLayer = Layer.mergeAll(
@@ -41,6 +42,7 @@ const CliLayer = Layer.mergeAll(
 	OpencodeService.Default,
 	ClaudeService.Default,
 	FilterRepoService.Default,
+	FormatterService.Default,
 )
 
 /**
@@ -334,6 +336,7 @@ const commands: Record<string, Command> = {
 					from: options.from,
 					fromCurrent: options["from-current"],
 					continue: options.continue,
+					squash: options.squash,
 				}),
 			)
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Manages personal agents files",
   "keywords": [
     "agents",

package/src/commands/emit.ts

@@ -43,7 +43,7 @@ export const emit = (options: EmitOptions = {}) =>
 		yield* withBranchProtection(gitRoot, emitCore(gitRoot, options))
 	})
 
-const emitCore = (gitRoot: string, options: EmitOptions) =>
+export const emitCore = (gitRoot: string, options: EmitOptions) =>
 	Effect.gen(function* () {
 		const { force = false, verbose = false, skipFilter = false } = options
 		const { log, verboseLog } = createLoggers(options)

package/src/commands/task-squash.test.ts

@@ -0,0 +1,266 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { task } from "./task"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	initAgency,
+	fileExists,
+	readFile,
+	runTestEffect,
+	getCurrentBranch,
+	getGitOutput,
+} from "../test-utils"
+
+describe("task --continue --squash", () => {
+	let tempDir: string
+	let originalCwd: string
+	let originalConfigDir: string | undefined
+
+	beforeEach(async () => {
+		tempDir = await createTempDir()
+		originalCwd = process.cwd()
+		originalConfigDir = process.env.AGENCY_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("fails when --squash is used without --continue", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await initAgency(tempDir, "test")
+
+		await expect(
+			runTestEffect(task({ silent: true, squash: true, emit: "some-branch" })),
+		).rejects.toThrow("--squash flag can only be used with --continue")
+	})
+
+	test("squashes emitted commits into a single commit on new branch", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await initAgency(tempDir, "test")
+
+		// Create a task branch with agency files
+		await runTestEffect(
+			task({ silent: true, emit: "feature-v1", task: "Original task" }),
+		)
+
+		// Add two code commits to the branch
+		await Bun.write(join(tempDir, "feature-a.txt"), "feature A content")
+		await Bun.spawn(["git", "add", "feature-a.txt"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+		await Bun.spawn(["git", "commit", "--no-verify", "-m", "Add feature A"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+
+		await Bun.write(join(tempDir, "feature-b.txt"), "feature B content")
+		await Bun.spawn(["git", "add", "feature-b.txt"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+		await Bun.spawn(["git", "commit", "--no-verify", "-m", "Add feature B"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+
+		// Now continue with squash
+		await runTestEffect(
+			task({
+				silent: true,
+				continue: true,
+				squash: true,
+				emit: "feature-v2",
+				task: "New task for v2",
+			}),
+		)
+
+		// Verify we're on the new branch
+		const newBranch = await getCurrentBranch(tempDir)
+		expect(newBranch).toBe("agency--feature-v2")
+
+		// Verify both feature files exist (squash brought them in)
+		expect(await fileExists(join(tempDir, "feature-a.txt"))).toBe(true)
+		expect(await fileExists(join(tempDir, "feature-b.txt"))).toBe(true)
+
+		// Verify agency files exist
+		expect(await fileExists(join(tempDir, "agency.json"))).toBe(true)
+		expect(await fileExists(join(tempDir, "TASK.md"))).toBe(true)
+		expect(await fileExists(join(tempDir, "AGENCY.md"))).toBe(true)
+
+		// Verify TASK.md has FRESH content (not the old "Original task")
+		const taskContent = await readFile(join(tempDir, "TASK.md"))
+		expect(taskContent).toContain("New task for v2")
+		expect(taskContent).not.toContain("Original task")
+
+		// Verify agency.json has updated emitBranch
+		const agencyJson = JSON.parse(await readFile(join(tempDir, "agency.json")))
+		expect(agencyJson.emitBranch).toBe("feature-v2")
+
+		// Verify commit history: should be initial commit + squash commit + agency files commit
+		// (not the individual "Add feature A" and "Add feature B" commits)
+		const logOutput = await getGitOutput(tempDir, [
+			"log",
+			"--oneline",
+			"--format=%s",
+		])
+		const commits = logOutput.trim().split("\n")
+
+		// Should NOT contain individual feature commits
+		expect(logOutput).not.toContain("Add feature A")
+		expect(logOutput).not.toContain("Add feature B")
+
+		// Should contain a squash commit
+		expect(logOutput).toContain("squash: prior work from feature-v1")
+	})
+
+	test("creates fresh TASK.md with default placeholder when no task provided in silent mode", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await initAgency(tempDir, "test")
+
+		// Create a task branch
+		await runTestEffect(
+			task({ silent: true, emit: "feature-v1", task: "Old task" }),
+		)
+
+		// Add a code commit
+		await Bun.write(join(tempDir, "code.txt"), "code content")
+		await Bun.spawn(["git", "add", "code.txt"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+		await Bun.spawn(["git", "commit", "--no-verify", "-m", "Add code"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+
+		// Continue with squash but no --task option (silent mode)
+		await runTestEffect(
+			task({
+				silent: true,
+				continue: true,
+				squash: true,
+				emit: "feature-v2",
+			}),
+		)
+
+		// TASK.md should have the default placeholder, not the old task
+		const taskContent = await readFile(join(tempDir, "TASK.md"))
+		expect(taskContent).toContain("{task}")
+		expect(taskContent).not.toContain("Old task")
+	})
+
+	test("handles empty squash when old branch has no code commits", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await initAgency(tempDir, "test")
+
+		// Create a task branch WITHOUT any code commits
+		await runTestEffect(
+			task({ silent: true, emit: "feature-v1", task: "Just agency files" }),
+		)
+
+		// Continue with squash - should succeed even with no code changes
+		await runTestEffect(
+			task({
+				silent: true,
+				continue: true,
+				squash: true,
+				emit: "feature-v2",
+				task: "New task",
+			}),
+		)
+
+		// Verify we're on the new branch
+		const newBranch = await getCurrentBranch(tempDir)
+		expect(newBranch).toBe("agency--feature-v2")
+
+		// Verify agency files exist
+		expect(await fileExists(join(tempDir, "agency.json"))).toBe(true)
+		expect(await fileExists(join(tempDir, "TASK.md"))).toBe(true)
+
+		// Verify fresh TASK.md
+		const taskContent = await readFile(join(tempDir, "TASK.md"))
+		expect(taskContent).toContain("New task")
+	})
+
+	test("preserves other agency files while creating fresh TASK.md", async () => {
+		await initGitRepo(tempDir)
+		process.chdir(tempDir)
+
+		await initAgency(tempDir, "test")
+
+		// Create a task branch
+		await runTestEffect(
+			task({ silent: true, emit: "feature-v1", task: "Old task" }),
+		)
+
+		// Read the original AGENCY.md content
+		const originalAgencyMd = await readFile(join(tempDir, "AGENCY.md"))
+
+		// Add a code commit
+		await Bun.write(join(tempDir, "code.txt"), "code")
+		await Bun.spawn(["git", "add", "code.txt"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+		await Bun.spawn(["git", "commit", "--no-verify", "-m", "Add code"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+
+		// Continue with squash
+		await runTestEffect(
+			task({
+				silent: true,
+				continue: true,
+				squash: true,
+				emit: "feature-v2",
+				task: "New task",
+			}),
+		)
+
+		// AGENCY.md should be carried forward (not fresh)
+		const newAgencyMd = await readFile(join(tempDir, "AGENCY.md"))
+		expect(newAgencyMd).toBe(originalAgencyMd)
+
+		// TASK.md should be fresh
+		const taskContent = await readFile(join(tempDir, "TASK.md"))
+		expect(taskContent).toContain("New task")
+		expect(taskContent).not.toContain("Old task")
+
+		// opencode.json should be carried forward
+		expect(await fileExists(join(tempDir, "opencode.json"))).toBe(true)
+	})
+})

package/src/commands/task.ts

@@ -21,6 +21,8 @@ import {
 } from "../utils/pr-branch"
 import { getTopLevelDir, dirToGlobPattern } from "../utils/glob"
 import { AGENCY_REMOVE_COMMIT } from "../constants"
+import { emitCore } from "./emit"
+import { withBranchProtection } from "../utils/effect"
 
 interface TaskOptions extends BaseCommandOptions {
 	path?: string
@@ -30,6 +32,7 @@ interface TaskOptions extends BaseCommandOptions {
 	from?: string
 	fromCurrent?: boolean
 	continue?: boolean
+	squash?: boolean
 }
 
 interface TaskEditOptions extends BaseCommandOptions {}
@@ -37,10 +40,13 @@ 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.
+ *
+ * With --squash: emits the old branch, squash-merges the emitted commits into the new
+ * branch as a single commit, and creates a fresh TASK.md with a new task description.
  */
 const taskContinue = (options: TaskOptions) =>
 	Effect.gen(function* () {
-		const { silent = false } = options
+		const { silent = false, squash = false } = options
 		const { log, verboseLog } = createLoggers(options)
 
 		const git = yield* GitService
@@ -128,6 +134,11 @@ const taskContinue = (options: TaskOptions) =>
 		// Read all the existing files content before switching branches
 		const fileContents = new Map<string, string>()
 		for (const file of filesToCopy) {
+			// When squashing, skip reading TASK.md — we'll generate a fresh one
+			if (squash && file === "TASK.md") {
+				verboseLog("Skipping TASK.md read (will create fresh for --squash)")
+				continue
+			}
 			const filePath = resolve(targetPath, file)
 			const exists = yield* fs.exists(filePath)
 			if (exists) {
@@ -139,6 +150,26 @@ const taskContinue = (options: TaskOptions) =>
 			}
 		}
 
+		// When squashing, prompt for fresh task description before switching branches
+		let freshTaskDescription: string | undefined
+		if (squash) {
+			if (options.task) {
+				freshTaskDescription = options.task
+				verboseLog(`Using task from option: ${freshTaskDescription}`)
+			} else if (!silent) {
+				freshTaskDescription = yield* promptService.prompt(
+					"New task description: ",
+				)
+				if (!freshTaskDescription) {
+					log(
+						info(
+							"Skipping task description (TASK.md will use default placeholder)",
+						),
+					)
+				}
+			}
+		}
+
 		// Prompt for new branch name if not provided
 		let branchName = options.emit || options.branch
 		if (!branchName) {
@@ -174,6 +205,43 @@ const taskContinue = (options: TaskOptions) =>
 			)
 		}
 
+		// When squashing, emit the old source branch first (before switching away)
+		// This creates a clean emit branch with backpack files stripped out
+		let oldEmitBranchName: string | undefined
+		if (squash) {
+			const cleanFromCurrent = extractCleanBranch(
+				currentBranch,
+				config.sourceBranchPattern,
+			)
+			oldEmitBranchName = cleanFromCurrent
+				? makeEmitBranchName(cleanFromCurrent, config.emitBranch)
+				: existingMetadata.emitBranch || undefined
+
+			if (!oldEmitBranchName) {
+				return yield* Effect.fail(
+					new Error(
+						`Could not determine emit branch name for ${highlight.branch(currentBranch)}.\n` +
+							`Ensure agency.json has an emitBranch field or the branch follows the source pattern.`,
+					),
+				)
+			}
+
+			verboseLog(
+				`Emitting ${highlight.branch(currentBranch)} → ${highlight.branch(oldEmitBranchName)}`,
+			)
+
+			yield* withBranchProtection(
+				targetPath,
+				emitCore(targetPath, {
+					silent: true,
+					verbose: options.verbose,
+					emit: oldEmitBranchName,
+				}),
+			)
+
+			log(done(`Emitted ${highlight.branch(oldEmitBranchName)} for squash`))
+		}
+
 		// Determine base branch to branch from
 		let baseBranchToBranchFrom: string | undefined
 
@@ -227,10 +295,70 @@ const taskContinue = (options: TaskOptions) =>
 		)
 		log(done(`Created and switched to ${highlight.branch(sourceBranchName)}`))
 
+		// When squashing, merge the emitted commits as a single squash commit
+		if (squash && oldEmitBranchName) {
+			verboseLog(
+				`Squash-merging ${highlight.branch(oldEmitBranchName)} into ${highlight.branch(sourceBranchName)}`,
+			)
+
+			// Squash merge the emitted (clean) branch
+			const mergeResult = yield* git
+				.merge(targetPath, oldEmitBranchName, { squash: true })
+				.pipe(
+					Effect.catchAll((err) => {
+						return Effect.fail(
+							new Error(
+								`Squash merge of ${oldEmitBranchName} failed.\n` +
+									`This typically means there are conflicts with the base branch.\n` +
+									`Try rebasing the old branch first with 'agency rebase', then retry.\n` +
+									`Details: ${err}`,
+							),
+						)
+					}),
+				)
+
+			// Check if the squash merge produced any staged changes
+			const statusResult = yield* git
+				.runGitCommand(["git", "diff", "--cached", "--quiet"], targetPath)
+				.pipe(
+					Effect.catchAll(() =>
+						Effect.succeed({ exitCode: 1, stdout: "", stderr: "" }),
+					),
+				)
+
+			if (statusResult.exitCode === 0) {
+				// No changes — the old branch had no code commits (only agency files)
+				verboseLog(
+					"Squash merge produced no changes (old branch had no code commits), skipping squash commit",
+				)
+			} else {
+				// There are staged changes — commit them
+				yield* git.gitCommit(
+					`squash: prior work from ${oldEmitBranchName}`,
+					targetPath,
+					{ noVerify: true },
+				)
+				log(
+					done(
+						`Squashed prior work from ${highlight.branch(oldEmitBranchName)}`,
+					),
+				)
+			}
+		}
+
 		// Calculate the new emit branch name
 		const newEmitBranchName = makeEmitBranchName(branchName, config.emitBranch)
 		verboseLog(`New emit branch name: ${newEmitBranchName}`)
 
+		// When squashing, generate fresh TASK.md content
+		if (squash) {
+			const taskTemplate = `{task}\n\n## Tasks\n\n- [ ] Populate this list with tasks\n`
+			const taskContent = freshTaskDescription
+				? taskTemplate.replace("{task}", freshTaskDescription)
+				: taskTemplate
+			fileContents.set("TASK.md", taskContent)
+		}
+
 		// Write all the files to the new branch
 		const createdFiles: string[] = []
 
@@ -287,7 +415,10 @@ const taskContinue = (options: TaskOptions) =>
 			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}`
+				const continueFlag = squash
+					? "agency task --continue --squash"
+					: "agency task --continue"
+				const commitMessage = `chore: ${continueFlag} (${baseBranchToBranchFrom}) ${currentBranch} → ${sourceBranchName} → ${newEmitBranchName}`
 				yield* git.gitCommit(commitMessage, targetPath, {
 					noVerify: true,
 				})
@@ -304,7 +435,9 @@ const taskContinue = (options: TaskOptions) =>
 
 		log(
 			info(
-				`Continued task with ${createdFiles.length} file${plural(createdFiles.length)} from ${highlight.branch(currentBranch)}`,
+				squash
+					? `Continued task with squash and ${createdFiles.length} file${plural(createdFiles.length)} from ${highlight.branch(currentBranch)}`
+					: `Continued task with ${createdFiles.length} file${plural(createdFiles.length)} from ${highlight.branch(currentBranch)}`,
 			),
 		)
 	})
@@ -314,6 +447,13 @@ export const task = (options: TaskOptions = {}) =>
 		const { silent = false, verbose = false } = options
 		const { log, verboseLog } = createLoggers(options)
 
+		// Validate --squash requires --continue
+		if (options.squash && !options.continue) {
+			return yield* Effect.fail(
+				new Error("The --squash flag can only be used with --continue."),
+			)
+		}
+
 		// Handle --continue flag
 		if (options.continue) {
 			return yield* taskContinue(options)
@@ -1104,6 +1244,8 @@ Options:
   --from <branch>   Branch to branch from instead of main upstream branch
   --from-current    Initialize on current branch instead of creating a new one
   --continue        Continue a task by copying agency files to a new branch
+  --squash          With --continue: squash the old branch's emitted commits into one
+  --task <desc>     Task description for TASK.md (avoids interactive prompt)
 
 Continue Mode (--continue):
   After a PR is merged, use '--continue' to create a new branch that preserves
@@ -1117,6 +1259,20 @@ Continue Mode (--continue):
   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
 
+Squash Mode (--continue --squash):
+  Combines --continue with squashing the old branch's emitted commits into a
+  single commit on the new branch. This is useful when you want to carry forward
+  code changes but collapse the commit history. A fresh TASK.md is created with
+  a new task description.
+  
+  The squash workflow:
+  1. Be on an agency source branch with agency files
+  2. Run 'agency task --continue --squash <new-branch-name>'
+  3. The old branch is emitted (backpack files stripped)
+  4. A new branch is created from main
+  5. The emitted commits are squash-merged as a single commit
+  6. Fresh agency files (including new TASK.md) are added
+
 Base Branch Selection:
   By default, 'agency task' fetches from the remote and branches from the latest
   main upstream branch (e.g., origin/main). You can override this behavior with:
@@ -1133,6 +1289,7 @@ Examples:
   agency task my-feature --from develop # Create 'my-feature' from 'develop'
   agency task --from-current           # Initialize on current branch (no new branch)
   agency task --continue my-feature-v2 # Continue task on new branch after PR merge
+  agency task --continue --squash v2   # Continue with squashed code from old branch
 
 Template Workflow:
   1. Run 'agency init' to select template (saved to .git/config)