@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/rebase.ts

@@ -1,232 +0,0 @@
-import { Effect } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { FileSystemService } from "../services/FileSystemService"
-import { AgencyMetadataService } from "../services/AgencyMetadataService"
-import highlight, { done, info } from "../utils/colors"
-import {
-	createLoggers,
-	ensureGitRepo,
-	resolveBaseBranch,
-	withBranchProtection,
-} from "../utils/effect"
-import { withSpinner } from "../utils/spinner"
-
-interface RebaseOptions extends BaseCommandOptions {
-	baseBranch?: string // Internal option, populated from positional arg
-	emit?: string // Custom emit branch name to set after rebase
-	branch?: string // Deprecated: use emit instead
-}
-
-export const rebase = (options: RebaseOptions = {}) =>
-	Effect.gen(function* () {
-		const gitRoot = yield* ensureGitRepo()
-
-		// Wrap the entire rebase operation with branch protection
-		yield* withBranchProtection(gitRoot, rebaseCore(gitRoot, options))
-	})
-
-const rebaseCore = (gitRoot: string, options: RebaseOptions) =>
-	Effect.gen(function* () {
-		const { verbose = false } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-
-		// Get current branch
-		const currentBranch = yield* git.getCurrentBranch(gitRoot)
-		verboseLog(`Current branch: ${highlight.branch(currentBranch)}`)
-
-		// Check if current branch has agency.json (is a source branch)
-		const metadataService = yield* Effect.gen(function* () {
-			return yield* AgencyMetadataService
-		}).pipe(Effect.provide(AgencyMetadataService.Default))
-
-		const metadata = yield* metadataService.readFromDisk(gitRoot)
-
-		if (!metadata) {
-			return yield* Effect.fail(
-				new Error(
-					`Current branch ${highlight.branch(currentBranch)} does not have agency.json.\n` +
-						`The rebase command can only be used on agency source branches.\n` +
-						`Run 'agency task' first to initialize this branch, or switch to an existing agency branch.`,
-				),
-			)
-		}
-
-		verboseLog(`Branch is an agency source branch`)
-
-		// Check for uncommitted changes
-		const statusOutput = yield* git.getStatus(gitRoot)
-
-		if (statusOutput && statusOutput.trim().length > 0) {
-			return yield* Effect.fail(
-				new Error(
-					`You have uncommitted changes. Please commit or stash them before rebasing.\n` +
-						`Run 'git status' to see the changes.`,
-				),
-			)
-		}
-
-		verboseLog(`Working directory is clean`)
-
-		// Resolve base branch (what we're rebasing onto)
-		const baseBranch = yield* resolveBaseBranch(gitRoot, options.baseBranch)
-		verboseLog(`Base branch: ${highlight.branch(baseBranch)}`)
-
-		// Check if base branch is a remote branch
-		const hasRemotePrefix = yield* git.hasRemotePrefix(baseBranch, gitRoot)
-
-		if (hasRemotePrefix) {
-			// Extract remote name from branch (e.g., "origin/main" -> "origin")
-			const remote = yield* git.getRemoteFromBranch(baseBranch, gitRoot)
-
-			if (remote) {
-				// Fetch the remote to ensure we have the latest commits
-				const fetchOperation = Effect.gen(function* () {
-					verboseLog(`Fetching ${highlight.branch(remote)}`)
-					yield* git.fetch(gitRoot, remote)
-					verboseLog(`Fetched ${highlight.branch(remote)}`)
-				})
-
-				yield* withSpinner(fetchOperation, {
-					text: `Fetching ${highlight.branch(remote)}`,
-					successText: `Fetched ${highlight.branch(remote)}`,
-					enabled: !options.silent && !verbose,
-				})
-			}
-		}
-
-		// Perform the rebase
-		log(
-			info(
-				`Rebasing ${highlight.branch(currentBranch)} onto ${highlight.branch(baseBranch)}`,
-			),
-		)
-
-		const rebaseOperation = Effect.gen(function* () {
-			verboseLog(`Running: git rebase ${baseBranch}`)
-
-			const result = yield* git.rebase(gitRoot, baseBranch)
-
-			if (result.exitCode !== 0) {
-				return yield* Effect.fail(
-					new Error(
-						`Rebase failed with conflicts.\n\n` +
-							`${result.stderr}\n\n` +
-							`To resolve:\n` +
-							`  1. Fix the conflicts in your files\n` +
-							`  2. Run: git add <resolved-files>\n` +
-							`  3. Run: git rebase --continue\n\n` +
-							`To abort the rebase:\n` +
-							`  Run: git rebase --abort`,
-					),
-				)
-			}
-
-			verboseLog(`Rebase completed successfully`)
-		})
-
-		yield* withSpinner(rebaseOperation, {
-			text: "Rebasing branch",
-			successText: "Rebased branch successfully",
-			enabled: !options.silent && !verbose,
-		})
-
-		log(
-			done(
-				`Rebased ${highlight.branch(currentBranch)} onto ${highlight.branch(baseBranch)}`,
-			),
-		)
-
-		// Update emit branch in agency.json if --emit/--branch flag was provided
-		const newEmitBranch = options.emit || options.branch
-		if (newEmitBranch && metadata) {
-			verboseLog(`Updating emit branch to: ${highlight.branch(newEmitBranch)}`)
-
-			// Update metadata with new emit branch
-			const updatedMetadata = {
-				...metadata,
-				emitBranch: newEmitBranch,
-			}
-
-			yield* Effect.tryPromise({
-				try: async () => {
-					const { writeAgencyMetadata } = await import("../types")
-					await writeAgencyMetadata(gitRoot, updatedMetadata)
-				},
-				catch: (error) => new Error(`Failed to update agency.json: ${error}`),
-			})
-
-			// Stage and commit the change
-			yield* git.gitAdd(["agency.json"], gitRoot)
-			// Format: chore: agency rebase (baseBranch) sourceBranch → emitBranch
-			const commitMessage = `chore: agency rebase (${baseBranch}) ${currentBranch} → ${newEmitBranch}`
-			yield* git.gitCommit(commitMessage, gitRoot, { noVerify: true })
-
-			log(info(`Updated emit branch to ${highlight.branch(newEmitBranch)}`))
-		}
-
-		// Inform user about next steps
-		log(
-			info(
-				`Your source branch has been rebased. You may want to:\n` +
-					`  - Run 'agency emit' to regenerate your emit branch\n` +
-					`  - Run 'agency push --force' to update the remote branch (use with caution)`,
-			),
-		)
-	})
-
-export const help = `
-Usage: agency rebase [options]
-
-Rebase the current agency source branch onto the latest base branch (typically origin/main).
-
-This command is useful when:
-  - Your work has been merged to the main branch via PR
-  - You want to continue working on the same branch with a clean history
-  - You want to incorporate the latest changes from main into your branch
-
-Behavior:
-  - Ensures you're on an agency source branch (has agency.json)
-  - Checks for uncommitted changes (rebase requires a clean working directory)
-  - Fetches the latest from the base branch if it's a remote branch
-  - Rebases your current branch onto the base branch
-  - All agency files (TASK.md, AGENTS.md, opencode.json, etc.) are preserved
-  - Your emit branch may need to be regenerated with 'agency emit'
-
-Base Branch Selection:
-  The command determines the base branch in this order:
-  1. Explicitly provided base-branch argument
-  2. Branch-specific base branch from agency.json (set by 'agency task')
-  3. Repository-level default base branch from .git/config
-  4. Auto-detected from origin/HEAD or common branches (origin/main, etc.)
-
-Arguments:
-  [base-branch]             Optional base branch to rebase onto
-                            (defaults to saved base branch or origin/main)
-
-Options:
-  --emit <name>             Set a new emit branch name in agency.json after rebasing
-  --branch <name>           (Deprecated: use --emit) Set a new emit branch name
-
-Examples:
-  agency rebase                    # Rebase onto saved base branch
-  agency rebase origin/main        # Rebase onto origin/main explicitly
-  agency rebase --emit new-branch  # Rebase and set new emit branch name
-
-Workflow:
-  1. User works on agency--feature-A branch
-  2. User runs 'agency emit' and 'agency push' to create a PR
-  3. PR gets merged into main
-  4. User runs 'agency rebase' to rebase agency--feature-A onto origin/main
-  5. User continues working on agency--feature-A with updated main branch
-  6. User runs 'agency emit' again to create a fresh emit branch
-
-Notes:
-  - This command only works on agency source branches (with agency.json)
-  - If conflicts occur during rebase, you must resolve them manually
-  - After rebasing, your emit branch will be outdated - run 'agency emit' to regenerate it
-  - Be careful when force-pushing after a rebase - coordinate with your team
-  - This command is different from 'agency task --continue' which creates a new branch
-`

package/src/commands/save.test.ts

@@ -1,247 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { join } from "path"
-import { save } from "./save"
-import { task } from "./task"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	initAgency,
-	readFile,
-	runTestEffect,
-} from "../test-utils"
-
-describe("save 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 to avoid interference from user's actual config
-		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("saves specified files to template directory", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-save")
-		await task({ silent: true, emit: "test-feature" })
-
-		// Modify the files
-		await Bun.write(join(tempDir, "AGENTS.md"), "# Modified content")
-
-		// Save specific files to template
-		await runTestEffect(save({ files: ["AGENTS.md"], silent: true }))
-
-		// Check template files were updated
-		const configDir = process.env.AGENCY_CONFIG_DIR!
-		const templateAgents = await readFile(
-			join(configDir, "templates", "test-save", "AGENTS.md"),
-		)
-
-		expect(templateAgents).toBe("# Modified content")
-	})
-
-	test("throws error when no files specified", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-no-files")
-		await task({
-			silent: true,
-			emit: "test-feature",
-		})
-
-		await expect(
-			runTestEffect(save({ files: [], silent: true })),
-		).rejects.toThrow("No files specified")
-	})
-
-	test("throws error when no template configured", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		await expect(
-			runTestEffect(save({ files: ["AGENTS.md"], silent: true })),
-		).rejects.toThrow("Repository not initialized")
-	})
-
-	test("throws error when not in git repo", async () => {
-		process.chdir(tempDir)
-
-		await expect(
-			runTestEffect(save({ files: ["AGENTS.md"], silent: true })),
-		).rejects.toThrow("Not in a git repository")
-	})
-
-	test("skips files that don't exist", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-partial")
-		await task({
-			silent: true,
-			emit: "test-feature",
-		})
-
-		// Remove AGENTS.md (just to test skipping behavior)
-		const rmProc = Bun.spawn(["rm", join(tempDir, "AGENTS.md")], {
-			cwd: tempDir,
-			stdout: "pipe",
-			stderr: "pipe",
-		})
-		await rmProc.exited
-
-		// Modify a different file that exists
-		await Bun.write(join(tempDir, "test.txt"), "# Test content")
-
-		// Save should succeed but skip the missing file
-		await runTestEffect(
-			save({ files: ["AGENTS.md", "test.txt"], silent: true }),
-		)
-
-		// Check test.txt was updated
-		const configDir = process.env.AGENCY_CONFIG_DIR!
-		const testContent = await readFile(
-			join(configDir, "templates", "test-partial", "test.txt"),
-		)
-		expect(testContent).toBe("# Test content")
-	})
-
-	test("saves directories recursively", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-dir")
-		await task({ silent: true, emit: "test-feature" })
-
-		// Create a directory with files
-		const docsDir = join(tempDir, "docs")
-		await Bun.write(join(docsDir, "README.md"), "# Documentation")
-		await Bun.write(join(docsDir, "guide.md"), "# Guide")
-
-		// Save the directory
-		await runTestEffect(save({ files: ["docs"], silent: true }))
-
-		// Check files were saved to template
-		const configDir = process.env.AGENCY_CONFIG_DIR!
-		const readmeContent = await readFile(
-			join(configDir, "templates", "test-dir", "docs", "README.md"),
-		)
-		const guideContent = await readFile(
-			join(configDir, "templates", "test-dir", "docs", "guide.md"),
-		)
-
-		expect(readmeContent).toBe("# Documentation")
-		expect(guideContent).toBe("# Guide")
-	})
-
-	test("refuses to save TASK.md", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-task")
-		await task({ silent: true, emit: "test-feature" })
-
-		// Create a TASK.md with the {task} placeholder
-		await Bun.write(join(tempDir, "TASK.md"), "{task}\n\n## Notes")
-
-		// Save should fail regardless of content
-		await expect(
-			runTestEffect(save({ files: ["TASK.md"], silent: true })),
-		).rejects.toThrow("TASK.md files cannot be saved to templates")
-	})
-
-	test("refuses to save TASK.md even without {task} placeholder", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-task-invalid")
-		await task({
-			silent: true,
-			emit: "test-feature",
-		})
-
-		// Create a TASK.md without the {task} placeholder
-		await Bun.write(
-			join(tempDir, "TASK.md"),
-			"# Specific Task\n\nThis is a specific task, not a template",
-		)
-
-		// Save should fail
-		await expect(
-			runTestEffect(save({ files: ["TASK.md"], silent: true })),
-		).rejects.toThrow("TASK.md files cannot be saved to templates")
-	})
-
-	test("refuses to save TASK.md in subdirectories", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-task-subdir")
-		await task({
-			silent: true,
-			emit: "test-feature",
-		})
-
-		// Create a TASK.md in a subdirectory with the {task} placeholder
-		const subdir = join(tempDir, "projects")
-		await Bun.write(join(subdir, "TASK.md"), "{task}\n\n## Details")
-
-		// Save should fail regardless of content
-		await expect(
-			runTestEffect(save({ files: ["projects/TASK.md"], silent: true })),
-		).rejects.toThrow("TASK.md files cannot be saved to templates")
-	})
-
-	test("refuses to save TASK.md in subdirectory even without {task} placeholder", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		// Initialize with template
-		await initAgency(tempDir, "test-task-subdir-invalid")
-		await task({
-			silent: true,
-			emit: "test-feature",
-		})
-
-		// Create a TASK.md in a subdirectory without the {task} placeholder
-		const subdir = join(tempDir, "projects")
-		await Bun.write(
-			join(subdir, "TASK.md"),
-			"# Specific Project Task\n\nThis is specific",
-		)
-
-		// Save should fail
-		await expect(
-			runTestEffect(save({ files: ["projects/TASK.md"], silent: true })),
-		).rejects.toThrow("TASK.md files cannot be saved to templates")
-	})
-})

package/src/commands/save.ts

@@ -1,162 +0,0 @@
-import { resolve, join, dirname, basename } from "path"
-import { Effect } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { TemplateService } from "../services/TemplateService"
-import { FileSystemService } from "../services/FileSystemService"
-import { RepositoryNotInitializedError } from "../errors"
-import highlight, { done } from "../utils/colors"
-import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
-
-interface SaveOptions extends BaseCommandOptions {
-	files?: string[]
-}
-
-function isDirectory(filePath: string): Effect.Effect<boolean, Error> {
-	return Effect.tryPromise({
-		try: async () => {
-			try {
-				const file = Bun.file(filePath)
-				const stat = await file.stat()
-				return stat?.isDirectory?.() ?? false
-			} catch {
-				return false
-			}
-		},
-		catch: (error) =>
-			new Error(`Failed to check if path is directory: ${error}`),
-	})
-}
-
-export const save = (options: SaveOptions = {}) =>
-	Effect.gen(function* () {
-		const { files: filesToSave = [] } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const templateService = yield* TemplateService
-		const fs = yield* FileSystemService
-
-		const gitRoot = yield* ensureGitRepo()
-
-		// Get template name from git config
-		const templateName = yield* getTemplateName(gitRoot)
-		if (!templateName) {
-			return yield* Effect.fail(new RepositoryNotInitializedError())
-		}
-
-		verboseLog(`Saving to template: ${highlight.template(templateName)}`)
-
-		// Get template directory
-		const templateDir = yield* templateService.getTemplateDir(templateName)
-
-		// Create template directory if it doesn't exist
-		yield* templateService.createTemplateDir(templateName)
-		verboseLog(`Ensured template directory exists: ${templateDir}`)
-
-		// Determine which files to save
-		let filesToProcess: string[] = []
-
-		if (filesToSave.length > 0) {
-			// Process provided file/dir names
-			for (const fileOrDir of filesToSave) {
-				const fullPath = resolve(gitRoot, fileOrDir)
-				const isDir = yield* isDirectory(fullPath)
-
-				if (isDir) {
-					// Recursively collect files from directory
-					const collected = yield* fs.collectFiles(fullPath, {
-						relativeTo: gitRoot,
-					})
-					filesToProcess.push(...collected)
-				} else {
-					// Add file path relative to git root
-					const relativePath = fileOrDir.startsWith(gitRoot)
-						? fileOrDir.replace(gitRoot + "/", "")
-						: fileOrDir
-					filesToProcess.push(relativePath)
-				}
-			}
-		} else {
-			return yield* Effect.fail(
-				new Error(
-					"No files specified. Usage: agency save <file|dir> [file|dir ...]",
-				),
-			)
-		}
-
-		// Save each file
-		for (const filePath of filesToProcess) {
-			const sourceFilePath = resolve(gitRoot, filePath)
-
-			// Check if file exists
-			const exists = yield* fs.exists(sourceFilePath)
-			if (!exists) {
-				verboseLog(`Skipping ${filePath} (does not exist)`)
-				continue
-			}
-
-			// Refuse to save TASK.md files - agency itself must control these
-			const fileName = basename(filePath)
-			if (fileName === "TASK.md") {
-				return yield* Effect.fail(
-					new Error(
-						`Cannot save ${filePath}: TASK.md files cannot be saved to templates. ` +
-							`Agency itself must control the creation of TASK.md files.`,
-					),
-				)
-			}
-
-			// Read content
-			const content = yield* fs.readFile(sourceFilePath)
-
-			const templateFilePath = join(templateDir, filePath)
-
-			// Ensure directory exists
-			const dir = dirname(templateFilePath)
-			yield* fs.createDirectory(dir)
-
-			// Write to template
-			yield* fs.writeFile(templateFilePath, content)
-			log(
-				done(
-					`Saved ${highlight.file(filePath)} to ${highlight.template(templateName)} template`,
-				),
-			)
-		}
-	})
-
-// Help text for reference (not exported as it's handled by template command)
-const help = `
-Usage: agency save <file|dir> [file|dir ...] [options]
-
-Save specified files or directories to the configured template.
-
-This command copies files and directories from the current git repository to 
-the template directory configured in .git/config (agency.template). Directories
-are saved recursively.
-
-Arguments:
-  <file|dir>        File or directory path to save (relative to git root)
-  [file|dir ...]    Additional files or directories to save
-
-Options:
-  -h, --help        Show this help message
-  -s, --silent      Suppress output messages
-  -v, --verbose     Show verbose output
-
-Examples:
-   agency save AGENTS.md              # Save specific file
-   agency save .config                # Save entire directory
-   agency save src/                   # Save src directory to template
-   agency save AGENTS.md docs/        # Save file and directory
-   agency save --verbose              # Save with verbose output
-   agency save --help                 # Show this help message
-
-Notes:
-  - Requires agency.template to be set (run 'agency init' first)
-  - At least one file or directory must be specified
-  - Files are saved to ~/.config/agency/templates/{template-name}/
-  - Template directory is created automatically if it doesn't exist
-  - Existing template files will be overwritten
-  - Directory structure is preserved in the template
-  - TASK.md files cannot be saved - agency controls their creation
-`