@markjaquith/agency 0.5.0

package/src/commands/tasks.test.ts

@@ -0,0 +1,335 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { tasks } from "./tasks"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getCurrentBranch,
+	createCommit,
+	initAgency,
+	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
+}
+
+async function checkoutBranch(cwd: string, branchName: string): Promise<void> {
+	await Bun.spawn(["git", "checkout", branchName], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	}).exited
+}
+
+describe("tasks 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("shows no task branches when none exist", async () => {
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("No task branches found")
+			expect(output).toContain("agency task")
+		})
+
+		test("lists single task branch", async () => {
+			// Initialize agency
+			await initAgency(tempDir, "test-template")
+
+			// Create feature branch with agency.json
+			await createBranch(tempDir, "feature")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: ["AGENTS.md"],
+				template: "test-template",
+				baseBranch: "main",
+				createdAt: new Date().toISOString(),
+			} as any)
+
+			// Commit agency.json
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("feature")
+			expect(output.trim()).toBe("feature")
+		})
+
+		test("lists multiple task branches", async () => {
+			await initAgency(tempDir, "test-template")
+
+			// Create first feature branch
+			await createBranch(tempDir, "feature-1")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: ["AGENTS.md"],
+				template: "test-template",
+				baseBranch: "main",
+				createdAt: new Date().toISOString(),
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			// Go back to main and create second feature branch
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "feature-2")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: ["opencode.json"],
+				template: "another-template",
+				baseBranch: "main",
+				createdAt: new Date().toISOString(),
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("feature-1")
+			expect(output).toContain("feature-2")
+			const lines = output.trim().split("\n")
+			expect(lines.length).toBe(2)
+		})
+
+		test("ignores branches without agency.json", async () => {
+			await initAgency(tempDir, "test-template")
+
+			// Create a branch without agency.json
+			await createBranch(tempDir, "no-agency")
+			await createCommit(tempDir, "Some work")
+
+			// Go back to main and create a branch with agency.json
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "with-agency")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: [],
+				template: "test-template",
+				createdAt: new Date().toISOString(),
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("with-agency")
+			expect(output).not.toContain("no-agency")
+			expect(output.trim()).toBe("with-agency")
+		})
+	})
+
+	describe("JSON output", () => {
+		test("outputs JSON format when --json is provided", async () => {
+			await initAgency(tempDir, "test-template")
+
+			await createBranch(tempDir, "feature")
+			const createdAt = new Date().toISOString()
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: ["AGENTS.md"],
+				template: "test-template",
+				baseBranch: "main",
+				createdAt,
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({ json: true }))
+
+			console.log = originalLog
+
+			// Parse JSON output
+			const data = JSON.parse(output.trim())
+			expect(Array.isArray(data)).toBe(true)
+			expect(data.length).toBe(1)
+			expect(data[0].branch).toBe("feature")
+			expect(data[0].template).toBe("test-template")
+			expect(data[0].baseBranch).toBe("main")
+			expect(data[0].createdAt).toBeDefined()
+		})
+
+		test("outputs empty array in JSON format when no task branches exist", async () => {
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({ json: true }))
+
+			console.log = originalLog
+
+			const data = JSON.parse(output.trim())
+			expect(Array.isArray(data)).toBe(true)
+			expect(data.length).toBe(0)
+		})
+	})
+
+	describe("edge cases", () => {
+		test("handles branches with invalid agency.json gracefully", async () => {
+			await initAgency(tempDir, "test-template")
+
+			// Create branch with invalid agency.json
+			await createBranch(tempDir, "invalid")
+			await Bun.write(join(tempDir, "agency.json"), "{ invalid json }")
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add invalid agency.json")
+
+			// Create branch with valid agency.json
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "valid")
+			await writeAgencyMetadata(tempDir, {
+				version: 1,
+				injectedFiles: [],
+				template: "test-template",
+				createdAt: new Date().toISOString(),
+			} as any)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add valid agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("valid")
+			expect(output).not.toContain("invalid")
+			expect(output.trim()).toBe("valid")
+		})
+
+		test("handles branches with old version agency.json", async () => {
+			await initAgency(tempDir, "test-template")
+
+			// Create branch with version 0 agency.json (future or old version)
+			await createBranch(tempDir, "old-version")
+			await Bun.write(
+				join(tempDir, "agency.json"),
+				JSON.stringify({
+					version: 0,
+					template: "old-template",
+				}),
+			)
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add old version agency.json")
+
+			let output = ""
+			const originalLog = console.log
+			console.log = (msg: string) => {
+				output += msg + "\n"
+			}
+
+			await runTestEffect(tasks({}))
+
+			console.log = originalLog
+			expect(output).toContain("No task branches found")
+		})
+	})
+})

package/src/commands/tasks.ts

@@ -0,0 +1,155 @@
+import { Effect, DateTime } from "effect"
+import { Schema } from "@effect/schema"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { AgencyMetadata } from "../schemas"
+import highlight from "../utils/colors"
+import { createLoggers, ensureGitRepo } from "../utils/effect"
+
+interface TasksOptions extends BaseCommandOptions {
+	json?: boolean
+}
+
+/**
+ * Task branch info for output
+ */
+interface TaskBranchInfo {
+	branch: string
+	template: string | null
+	baseBranch: string | null
+	createdAt: string | 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)))
+
+/**
+ * Find all branches that contain an agency.json file
+ */
+const findAllTaskBranches = (gitRoot: string) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+
+		// Get all local branches
+		const branchesResult = yield* git.runGitCommand(
+			["git", "branch", "--format=%(refname:short)"],
+			gitRoot,
+			{ captureOutput: true },
+		)
+
+		if (branchesResult.exitCode !== 0 || !branchesResult.stdout) {
+			return []
+		}
+
+		const branches = branchesResult.stdout
+			.split("\n")
+			.map((b) => b.trim())
+			.filter((b) => b.length > 0)
+
+		// For each branch, try to read agency.json
+		const taskBranches: TaskBranchInfo[] = []
+		for (const branch of branches) {
+			const metadata = yield* readAgencyMetadataFromBranch(gitRoot, branch)
+
+			if (metadata) {
+				taskBranches.push({
+					branch,
+					template: metadata.template ?? null,
+					baseBranch: metadata.baseBranch ?? null,
+					createdAt: metadata.createdAt
+						? DateTime.toDateUtc(metadata.createdAt).toISOString()
+						: null,
+				})
+			}
+		}
+
+		return taskBranches
+	})
+
+export const tasks = (options: TasksOptions = {}) =>
+	Effect.gen(function* () {
+		const { json = false } = options
+		const { log } = createLoggers(options)
+
+		const gitRoot = yield* ensureGitRepo()
+
+		// Find all branches with agency.json
+		const taskBranches = yield* findAllTaskBranches(gitRoot)
+
+		if (json) {
+			// Output JSON format
+			log(JSON.stringify(taskBranches, null, 2))
+		} else {
+			// Output human-readable format - just branch names
+			if (taskBranches.length === 0) {
+				log("")
+				log("No task branches found.")
+				log(
+					`Run ${highlight.value("agency task")} to create a task on a feature branch.`,
+				)
+				log("")
+			} else {
+				for (const task of taskBranches) {
+					log(task.branch)
+				}
+			}
+		}
+	})
+
+export const help = `
+Usage: agency tasks [options]
+
+List all source branches that have agency tasks (branches containing agency.json).
+
+This command searches through all local branches and displays those that have
+been initialized with 'agency task'.
+
+Options:
+  --json              Output as JSON (includes metadata: template, base branch, created date)
+
+Example:
+  agency tasks                   # List all task branches (names only)
+  agency tasks --json            # Output as JSON with full metadata
+`

package/src/commands/template-delete.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { templateDelete } from "./template-delete"
+import { mkdir, writeFile, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { runTestEffect } from "../test-utils"
+
+describe("template delete command", () => {
+	let testDir: string
+	let gitRoot: string
+	let templateDir: string
+
+	beforeEach(async () => {
+		// Create temporary test directory
+		testDir = join(tmpdir(), `agency-test-delete-${Date.now()}`)
+		await mkdir(testDir, { recursive: true })
+		gitRoot = join(testDir, "repo")
+		await mkdir(gitRoot, { recursive: true })
+
+		// Initialize git repo
+		await Bun.spawn(["git", "init"], {
+			cwd: gitRoot,
+			stdout: "ignore",
+			stderr: "ignore",
+		}).exited
+
+		// Set up config dir
+		const configDir = join(testDir, "config")
+		templateDir = join(configDir, "templates", "test-template")
+		await mkdir(templateDir, { recursive: true })
+
+		// Set environment variable for config
+		process.env.AGENCY_CONFIG_DIR = configDir
+
+		// Set git config
+		await Bun.spawn(["git", "config", "agency.template", "test-template"], {
+			cwd: gitRoot,
+			stdout: "ignore",
+			stderr: "ignore",
+		}).exited
+	})
+
+	afterEach(async () => {
+		// Clean up
+		await rm(testDir, { recursive: true, force: true })
+		delete process.env.AGENCY_CONFIG_DIR
+	})
+
+	test("deletes file from template directory", async () => {
+		// Create test file in template
+		const testFile = join(templateDir, "test.md")
+		await writeFile(testFile, "# Test")
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await runTestEffect(templateDelete({ files: ["test.md"], silent: true }))
+
+			// Verify file was deleted
+			const file = Bun.file(testFile)
+			expect(await file.exists()).toBe(false)
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("deletes multiple files", async () => {
+		// Create test files in template
+		await writeFile(join(templateDir, "file1.md"), "# File 1")
+		await writeFile(join(templateDir, "file2.md"), "# File 2")
+		await writeFile(join(templateDir, "file3.md"), "# File 3")
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await runTestEffect(
+				templateDelete({
+					files: ["file1.md", "file2.md"],
+					silent: true,
+				}),
+			)
+
+			// Verify files were deleted
+			expect(await Bun.file(join(templateDir, "file1.md")).exists()).toBe(false)
+			expect(await Bun.file(join(templateDir, "file2.md")).exists()).toBe(false)
+			// file3.md should still exist
+			expect(await Bun.file(join(templateDir, "file3.md")).exists()).toBe(true)
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("deletes directory recursively", async () => {
+		// Create test directory with files
+		const docsDir = join(templateDir, "docs")
+		await mkdir(docsDir, { recursive: true })
+		await writeFile(join(docsDir, "README.md"), "# Docs")
+		await writeFile(join(docsDir, "guide.md"), "# Guide")
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await runTestEffect(templateDelete({ files: ["docs"], silent: true }))
+
+			// Verify directory was deleted
+			const dir = Bun.file(docsDir)
+			expect(await dir.exists()).toBe(false)
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("handles non-existent files gracefully", async () => {
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			// Should not throw error for non-existent file
+			await runTestEffect(
+				templateDelete({ files: ["nonexistent.md"], silent: true }),
+			)
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("throws error when no files specified", async () => {
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await expect(
+				runTestEffect(templateDelete({ files: [], silent: true })),
+			).rejects.toThrow("No files specified")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("throws error when not in git repository", async () => {
+		const nonGitDir = join(testDir, "non-git")
+		await mkdir(nonGitDir, { recursive: true })
+
+		const originalCwd = process.cwd()
+		process.chdir(nonGitDir)
+
+		try {
+			await expect(
+				runTestEffect(templateDelete({ files: ["test.md"], silent: true })),
+			).rejects.toThrow("Not in a git repository")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("throws error when template not configured", async () => {
+		// Remove git config
+		await Bun.spawn(["git", "config", "--unset", "agency.template"], {
+			cwd: gitRoot,
+			stdout: "ignore",
+			stderr: "ignore",
+		}).exited
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await expect(
+				runTestEffect(templateDelete({ files: ["test.md"], silent: true })),
+			).rejects.toThrow("Repository not initialized")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+})