@markjaquith/agency 0.5.0

package/src/commands/status.ts

@@ -0,0 +1,258 @@
+import { Effect, DateTime } from "effect"
+import { join } from "node:path"
+import { Schema } from "@effect/schema"
+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 { AgencyMetadata } from "../schemas"
+import highlight, { plural } from "../utils/colors"
+import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
+
+interface StatusOptions extends BaseCommandOptions {
+	json?: boolean
+}
+
+/**
+ * Branch type for status output
+ */
+type BranchType = "source" | "emit" | "neither"
+
+/**
+ * Base files that are always in the backpack
+ */
+const BASE_BACKPACK_FILES = ["TASK.md", "AGENCY.md", "agency.json"]
+
+/**
+ * Status data structure returned by the status command
+ */
+interface StatusData {
+	initialized: boolean
+	branchType: BranchType
+	currentBranch: string
+	sourceBranch: string | null
+	emitBranch: string | null
+	correspondingBranchExists: boolean
+	template: string | null
+	managedFiles: string[]
+	baseBranch: string | null
+	createdAt: string | null
+}
+
+/**
+ * Read agency.json metadata from the current working directory.
+ */
+const readAgencyMetadataFromDisk = (gitRoot: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const metadataPath = join(gitRoot, "agency.json")
+
+		const exists = yield* fs.exists(metadataPath)
+		if (!exists) {
+			return null
+		}
+
+		const content = yield* fs.readFile(metadataPath)
+		return yield* parseAgencyMetadata(content)
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+/**
+ * Read agency.json metadata from a specific branch using git show.
+ */
+const readAgencyMetadataFromBranch = (gitRoot: string, branch: string) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+
+		// Try to read agency.json from the branch using git show
+		const result = yield* git.runGitCommand(
+			["git", "show", `${branch}:agency.json`],
+			gitRoot,
+			{ captureOutput: true },
+		)
+
+		if (result.exitCode !== 0 || !result.stdout) {
+			return null
+		}
+
+		return yield* parseAgencyMetadata(result.stdout)
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+/**
+ * Parse and validate agency.json content.
+ */
+const parseAgencyMetadata = (content: string) =>
+	Effect.gen(function* () {
+		const data = yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: () => new Error("Failed to parse agency.json"),
+		})
+
+		// Validate version
+		if (typeof data.version !== "number" || data.version !== 1) {
+			return null
+		}
+
+		// Parse and validate using Effect schema
+		const metadata = yield* Effect.try({
+			try: () => Schema.decodeUnknownSync(AgencyMetadata)(data),
+			catch: () => new Error("Invalid agency.json format"),
+		})
+
+		return metadata
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+export const status = (options: StatusOptions = {}) =>
+	Effect.gen(function* () {
+		const { json = false } = options
+		const { log } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		// Load config for emit branch pattern
+		const config = yield* configService.loadConfig()
+
+		// Get current branch
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+
+		// Resolve branch pair to determine if we're on source or emit branch
+		const branches = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+		const { sourceBranch, emitBranch, isOnEmitBranch } = branches
+
+		// Check if agency is initialized
+		// If on emit branch, read agency.json from source branch; otherwise read from disk
+		const metadata = isOnEmitBranch
+			? yield* readAgencyMetadataFromBranch(gitRoot, sourceBranch)
+			: yield* readAgencyMetadataFromDisk(gitRoot)
+		const initialized = metadata !== null
+
+		// Determine branch type
+		let branchType: BranchType = "neither"
+		if (initialized) {
+			branchType = isOnEmitBranch ? "emit" : "source"
+		}
+
+		// Check if the corresponding branch exists
+		const correspondingBranch = isOnEmitBranch ? sourceBranch : emitBranch
+		const correspondingBranchExists = yield* git.branchExists(
+			gitRoot,
+			correspondingBranch,
+		)
+
+		// Get template name from git config
+		const template = yield* getTemplateName(gitRoot)
+
+		// Build the complete backpack (all files carried in/out)
+		const backpackFiles = metadata
+			? [...BASE_BACKPACK_FILES, ...metadata.injectedFiles]
+			: []
+
+		// Build status data
+		const statusData: StatusData = {
+			initialized,
+			branchType,
+			currentBranch,
+			sourceBranch: isOnEmitBranch ? sourceBranch : currentBranch,
+			emitBranch: isOnEmitBranch ? currentBranch : emitBranch,
+			correspondingBranchExists,
+			template,
+			managedFiles: backpackFiles,
+			baseBranch: metadata?.baseBranch ?? null,
+			createdAt: metadata?.createdAt
+				? DateTime.toDateUtc(metadata.createdAt).toISOString()
+				: null,
+		}
+
+		if (json) {
+			// Output JSON format
+			log(JSON.stringify(statusData, null, 2))
+		} else {
+			// Output human-readable format with highlighting
+			log("")
+
+			if (!initialized) {
+				// Not initialized - show minimal info
+				log(
+					`Not initialized (run ${highlight.value("agency task")} to initialize)`,
+				)
+				log(`Current branch: ${highlight.branch(currentBranch)}`)
+				if (template) {
+					log(`Template: ${highlight.template(template)}`)
+				}
+			} else {
+				// Initialized - show full status
+				log(`Current branch: ${highlight.branch(currentBranch)}`)
+
+				// Branch type
+				const branchTypeDisplay = isOnEmitBranch
+					? "Emit branch"
+					: "Source branch"
+				log(`Branch type: ${branchTypeDisplay}`)
+
+				// Show corresponding branch only if it exists
+				if (correspondingBranchExists) {
+					if (isOnEmitBranch) {
+						log(`Source branch: ${highlight.branch(statusData.sourceBranch!)}`)
+					} else {
+						log(`Emit branch: ${highlight.branch(statusData.emitBranch!)}`)
+					}
+				}
+
+				// Template
+				if (template) {
+					log(`Template: ${highlight.template(template)}`)
+				}
+
+				// Base branch
+				if (metadata?.baseBranch) {
+					log(`Base branch: ${highlight.branch(metadata.baseBranch)}`)
+				}
+
+				// Backpack (files carried into the job and will leave with)
+				if (backpackFiles.length > 0) {
+					log(`Backpack:`)
+					for (const file of backpackFiles) {
+						log(`  ${highlight.file(file)}`)
+					}
+				}
+
+				// Created at
+				if (metadata?.createdAt) {
+					const date = DateTime.toDateUtc(metadata.createdAt)
+					log(`Created: ${date.toLocaleString()}`)
+				}
+			}
+
+			log("")
+		}
+	})
+
+export const help = `
+Usage: agency status [options]
+
+Display the current status of the agency setup in this repository.
+
+Information shown:
+  - Whether agency is initialized (agency.json exists)
+  - Current branch and branch type (source, emit, or neither)
+  - Source and emit branch names
+  - Whether the corresponding branch exists
+  - Configured template name
+  - Backpack (files carried in and filtered during emit)
+  - Base branch and creation timestamp
+
+Options:
+  --json              Output status as JSON for scripting
+
+Example:
+  agency status                  # Show human-readable status
+  agency status --json           # Output as JSON
+`

package/src/commands/switch.test.ts

@@ -0,0 +1,194 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { switchBranch } from "./switch"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getGitOutput,
+	getCurrentBranch,
+	createCommit,
+	checkoutBranch,
+	runTestEffect,
+} from "../test-utils"
+
+async function createBranch(cwd: string, branchName: string): Promise<void> {
+	await Bun.spawn(["git", "checkout", "-b", branchName], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	}).exited
+}
+
+describe("switch 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 and emit branches (source=agency/main, emit=main)
+			await createBranch(tempDir, "agency/main")
+			await createCommit(tempDir, "Work on source")
+			// Emit branch is just "main" (already exists from setup)
+			await checkoutBranch(tempDir, "main")
+
+			// Run switch command
+			await runTestEffect(switchBranch({ silent: true }))
+
+			// Should be on source branch now
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("agency/main")
+		})
+
+		test("switches from source branch to emit branch", async () => {
+			// Create source branch (main becomes the emit branch)
+			await createBranch(tempDir, "agency/main")
+			await createCommit(tempDir, "Work on source")
+
+			// We're on agency/main (source), switch to main (emit)
+			// Run switch command
+			await runTestEffect(switchBranch({ silent: true }))
+
+			// Should be on emit branch now
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("main")
+		})
+
+		test("toggles back and forth", async () => {
+			// Create source and emit branches
+			await createBranch(tempDir, "agency/main")
+			await createCommit(tempDir, "Work on source")
+			await checkoutBranch(tempDir, "main") // Go to emit
+
+			// Switch to source
+			await runTestEffect(switchBranch({ silent: true }))
+			expect(await getCurrentBranch(tempDir)).toBe("agency/main")
+
+			// Switch back to emit
+			await runTestEffect(switchBranch({ silent: true }))
+			expect(await getCurrentBranch(tempDir)).toBe("main")
+
+			// And back to source
+			await runTestEffect(switchBranch({ silent: true }))
+			expect(await getCurrentBranch(tempDir)).toBe("agency/main")
+		})
+
+		test("works with custom emit branch pattern", async () => {
+			// Create custom config
+			const configPath = join(tempDir, "custom-config.json")
+			await Bun.write(
+				configPath,
+				JSON.stringify({
+					sourceBranchPattern: "agency/%branch%",
+					emitBranch: "PR/%branch%",
+				}),
+			)
+			process.env.AGENCY_CONFIG_PATH = configPath
+
+			// Create source branch and its emit branch
+			await createBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "Feature work")
+			await createBranch(tempDir, "PR/feature")
+
+			// Switch to source
+			await runTestEffect(switchBranch({ silent: true }))
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Switch back to emit
+			await runTestEffect(switchBranch({ silent: true }))
+			expect(await getCurrentBranch(tempDir)).toBe("PR/feature")
+		})
+	})
+
+	describe("error handling", () => {
+		test("throws error when emit branch doesn't exist", async () => {
+			// Use custom emit pattern so emit branch differs from source
+			const configPath = join(tempDir, "custom-config.json")
+			await Bun.write(
+				configPath,
+				JSON.stringify({
+					sourceBranchPattern: "agency/%branch%",
+					emitBranch: "%branch%--PR",
+				}),
+			)
+			process.env.AGENCY_CONFIG_PATH = configPath
+
+			// Create source branch, but not the emit branch
+			await createBranch(tempDir, "agency/feature")
+			// feature--PR doesn't exist
+
+			await expect(
+				runTestEffect(switchBranch({ silent: true })),
+			).rejects.toThrow(/Emit branch .* does not exist/)
+		})
+
+		test("throws error when emit branch doesn't exist", async () => {
+			// Create source branch but no emit branch
+			await createBranch(tempDir, "agency/feature")
+			// We never created 'feature' (emit), so it doesn't exist
+
+			await expect(
+				runTestEffect(switchBranch({ silent: true })),
+			).rejects.toThrow(/Emit branch .* does not exist/)
+		})
+
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
+
+			await expect(
+				runTestEffect(switchBranch({ silent: true })),
+			).rejects.toThrow("Not in a git repository")
+
+			await cleanupTempDir(nonGitDir)
+		})
+	})
+
+	describe("silent mode", () => {
+		test("silent flag suppresses output", async () => {
+			await createBranch(tempDir, "agency/main")
+			await checkoutBranch(tempDir, "main")
+
+			// Capture output
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await runTestEffect(switchBranch({ silent: true }))
+
+			console.log = originalLog
+			expect(logCalled).toBe(false)
+		})
+	})
+})

package/src/commands/switch.ts

@@ -0,0 +1,84 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import {
+	resolveBranchPairWithAgencyJson,
+	type BranchPair,
+} from "../utils/pr-branch"
+import highlight, { done } from "../utils/colors"
+import {
+	createLoggers,
+	ensureGitRepo,
+	ensureBranchExists,
+} from "../utils/effect"
+
+interface SwitchOptions extends BaseCommandOptions {}
+
+export const switchBranch = (options: SwitchOptions = {}) =>
+	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 branches: BranchPair = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+		const { sourceBranch, emitBranch, isOnEmitBranch } = branches
+
+		if (isOnEmitBranch) {
+			// We're on an emit branch, switch to source
+			yield* ensureBranchExists(
+				gitRoot,
+				sourceBranch,
+				`Source branch ${highlight.branch(sourceBranch)} does not exist`,
+			)
+
+			yield* git.checkoutBranch(gitRoot, sourceBranch)
+			log(done(`Switched to source branch: ${highlight.branch(sourceBranch)}`))
+		} else {
+			// We're on a source branch, switch to emit branch
+			yield* ensureBranchExists(
+				gitRoot,
+				emitBranch,
+				`Emit branch ${highlight.branch(emitBranch)} does not exist. Run 'agency emit' to create it.`,
+			)
+
+			yield* git.checkoutBranch(gitRoot, emitBranch)
+			log(done(`Switched to ${highlight.branch(emitBranch)}`))
+		}
+	})
+
+export const help = `
+Usage: agency switch [options]
+
+Toggle between source branch and emit branch.
+
+Source and Emit Branches:
+  - Source branches: Your working branches with agency-specific files (e.g., agency/main)
+  - Emit branches: Clean branches suitable for PRs without agency files (e.g., main)
+
+This command intelligently switches between your source branch and its
+corresponding emit branch:
+  - If on an emit branch (e.g., main), switches to source (agency/main)
+  - If on a source branch (e.g., agency/main), switches to emit branch (main)
+
+Example:
+  agency switch                  # Toggle between branches
+
+Notes:
+  - Target branch must exist
+  - Uses source and emit patterns from ~/.config/agency/agency.json
+  - If emit branch doesn't exist, run 'agency emit' to create it
+`