@markjaquith/agency 0.5.0

package/src/commands/save.ts

@@ -0,0 +1,162 @@
+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
+`

package/src/commands/source.test.ts

@@ -0,0 +1,195 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { source } from "./source"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getCurrentBranch,
+	createCommit,
+	runTestEffect,
+} from "../test-utils"
+import { writeAgencyMetadata } from "../types"
+
+async function createBranch(cwd: string, branchName: string): Promise<void> {
+	await Bun.spawn(["git", "checkout", "-b", branchName], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	}).exited
+}
+
+describe("source command", () => {
+	let tempDir: string
+	let originalCwd: string
+
+	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")
+
+		// Initialize git repo
+		await initGitRepo(tempDir)
+		await createCommit(tempDir, "Initial commit")
+
+		// Rename to main if needed
+		const currentBranch = await getCurrentBranch(tempDir)
+		if (currentBranch === "master") {
+			await Bun.spawn(["git", "branch", "-m", "main"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+		}
+	})
+
+	afterEach(async () => {
+		process.chdir(originalCwd)
+		delete process.env.AGENCY_CONFIG_PATH
+		await cleanupTempDir(tempDir)
+	})
+
+	describe("basic functionality", () => {
+		test("switches from emit branch to source branch", async () => {
+			// Create source branch with agency.json
+			await createBranch(tempDir, "agency/feature")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: [],
+				template: "test-template",
+				emitBranch: "feature",
+				createdAt: new Date().toISOString(),
+			} as any)
+			// Stage and commit agency.json
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Setup")
+
+			// Create emit branch and remove agency.json
+			await createBranch(tempDir, "feature")
+			await Bun.spawn(["rm", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Run source command (should switch from feature emit branch to agency/feature source)
+			await runTestEffect(source({ silent: true }))
+
+			// Should be on agency/feature now
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("agency/feature")
+		})
+
+		test("works with custom emit branch pattern", async () => {
+			// Create custom config with custom patterns
+			const configPath = join(tempDir, "custom-config.json")
+			await Bun.write(
+				configPath,
+				JSON.stringify({
+					sourceBranchPattern: "WIP/%branch%",
+					emitBranch: "PR/%branch%",
+				}),
+			)
+			process.env.AGENCY_CONFIG_PATH = configPath
+
+			// Create source branch with agency.json
+			await createBranch(tempDir, "WIP/feature")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: [],
+				template: "test-template",
+				emitBranch: "PR/feature",
+				createdAt: new Date().toISOString(),
+			} as any)
+			// Stage and commit
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Feature work")
+
+			// Create emit branch
+			await createBranch(tempDir, "PR/feature")
+			await Bun.spawn(["rm", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Run source command (from PR/feature to WIP/feature)
+			await runTestEffect(source({ silent: true }))
+
+			// Should be on WIP/feature now
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("WIP/feature")
+		})
+	})
+
+	describe("error handling", () => {
+		test("throws error when not on an emit branch", async () => {
+			// We're on main, which is not an emit branch
+			await expect(runTestEffect(source({ silent: true }))).rejects.toThrow(
+				"Not on an emit branch",
+			)
+		})
+
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
+
+			await expect(runTestEffect(source({ silent: true }))).rejects.toThrow(
+				"Not in a git repository",
+			)
+
+			await cleanupTempDir(nonGitDir)
+		})
+	})
+
+	describe("silent mode", () => {
+		test("silent flag suppresses output", async () => {
+			// Create source branch with agency.json
+			await createBranch(tempDir, "agency/feature")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: [],
+				template: "test-template",
+				emitBranch: "feature",
+				createdAt: new Date().toISOString(),
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Setup")
+
+			// Create emit branch
+			await createBranch(tempDir, "feature")
+			await Bun.spawn(["rm", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Capture output
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await runTestEffect(source({ silent: true }))
+
+			console.log = originalLog
+			expect(logCalled).toBe(false)
+		})
+	})
+})

package/src/commands/source.ts

@@ -0,0 +1,72 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import { FileSystemService } from "../services/FileSystemService"
+import { resolveBranchPairWithAgencyJson } from "../utils/pr-branch"
+import highlight, { done } from "../utils/colors"
+import {
+	createLoggers,
+	ensureGitRepo,
+	ensureBranchExists,
+} from "../utils/effect"
+
+interface SourceOptions extends BaseCommandOptions {}
+
+export const source = (options: SourceOptions = {}) =>
+	Effect.gen(function* () {
+		const { log } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		// Load config
+		const config = yield* configService.loadConfig()
+
+		// Get current branch and resolve the branch pair
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+		const { sourceBranch, isOnEmitBranch } =
+			yield* resolveBranchPairWithAgencyJson(
+				gitRoot,
+				currentBranch,
+				config.sourceBranchPattern,
+				config.emitBranch,
+			)
+
+		if (!isOnEmitBranch) {
+			return yield* Effect.fail(
+				new Error(`Not on an emit branch. Current branch: ${currentBranch}`),
+			)
+		}
+
+		// Check if source branch exists
+		yield* ensureBranchExists(
+			gitRoot,
+			sourceBranch,
+			`Source branch ${highlight.branch(sourceBranch)} does not exist`,
+		)
+
+		// Checkout source branch
+		yield* git.checkoutBranch(gitRoot, sourceBranch)
+
+		log(done(`Switched to source branch: ${highlight.branch(sourceBranch)}`))
+	})
+
+export const help = `
+Usage: agency source [options]
+
+Switch back to the source branch from an emit branch.
+
+This command extracts the source branch name from your current emit branch name
+using the configured pattern, and switches back to it.
+
+Example:
+  agency source                  # From main--PR, switch to main
+
+Notes:
+  - Must be run from an emit branch
+  - Source branch must exist
+  - Uses emit branch pattern from ~/.config/agency/agency.json
+`