@markjaquith/agency 0.5.0

package/src/commands/template-delete.ts

@@ -0,0 +1,98 @@
+import { resolve } from "path"
+import { rm } from "node:fs/promises"
+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 DeleteOptions extends BaseCommandOptions {
+	files?: string[]
+}
+
+export const templateDelete = (options: DeleteOptions = {}) =>
+	Effect.gen(function* () {
+		const { files: filesToDelete = [] } = 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())
+		}
+
+		if (filesToDelete.length === 0) {
+			return yield* Effect.fail(
+				new Error(
+					"No files specified. Usage: agency template delete <file> [file ...]",
+				),
+			)
+		}
+
+		verboseLog(`Deleting from template: ${highlight.template(templateName)}`)
+
+		// Get template directory
+		const templateDir = yield* templateService.getTemplateDir(templateName)
+
+		// Delete each file
+		for (const filePath of filesToDelete) {
+			const templateFilePath = resolve(templateDir, filePath)
+
+			// Check if file exists
+			const exists = yield* fs.exists(templateFilePath)
+			if (!exists) {
+				verboseLog(`Skipping ${filePath} (does not exist in template)`)
+				continue
+			}
+
+			// Delete the file/directory
+			yield* Effect.tryPromise({
+				try: () => rm(templateFilePath, { recursive: true, force: true }),
+				catch: (error) => new Error(`Failed to delete ${filePath}: ${error}`),
+			})
+
+			log(
+				done(
+					`Deleted ${highlight.file(filePath)} from ${highlight.template(templateName)} template`,
+				),
+			)
+		}
+	})
+
+// Help text for reference (not exported as it's handled by template command)
+const help = `
+Usage: agency template delete <file> [file ...] [options]
+
+Delete specified files from the configured template directory.
+
+This command removes files from the template directory configured in 
+.git/config (agency.template).
+
+Arguments:
+  <file>            File path to delete (relative to template root)
+  [file ...]        Additional files to delete
+
+Options:
+  -h, --help        Show this help message
+  -s, --silent      Suppress output messages
+  -v, --verbose     Show verbose output
+
+Examples:
+  agency template delete AGENTS.md           # Delete specific file
+  agency template delete docs/ src/          # Delete directories
+  agency template delete file1 file2 file3   # Delete multiple files
+
+Notes:
+  - Requires agency.template to be set (run 'agency init' first)
+  - At least one file must be specified
+  - Files are deleted from ~/.config/agency/templates/{template-name}/
+  - Non-existent files are skipped with a warning in verbose mode
+  - Directories are deleted recursively
+`

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

@@ -0,0 +1,135 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { templateList } from "./template-list"
+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 list command", () => {
+	let testDir: string
+	let gitRoot: string
+	let templateDir: string
+
+	beforeEach(async () => {
+		// Create temporary test directory
+		testDir = join(tmpdir(), `agency-test-list-${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("lists files in template directory", async () => {
+		// Create test files in template
+		await writeFile(join(templateDir, "AGENTS.md"), "# Agents")
+		await writeFile(join(templateDir, "opencode.json"), "{}")
+		await mkdir(join(templateDir, "docs"), { recursive: true })
+		await writeFile(join(templateDir, "docs", "README.md"), "# Docs")
+
+		// Capture output
+		const output: string[] = []
+		const originalLog = console.log
+		console.log = (...args: any[]) => {
+			output.push(args.join(" "))
+		}
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await runTestEffect(templateList({ silent: false }))
+		} finally {
+			process.chdir(originalCwd)
+			console.log = originalLog
+		}
+
+		expect(output.length).toBeGreaterThan(0)
+		expect(output.some((line) => line.includes("AGENTS.md"))).toBe(true)
+		expect(output.some((line) => line.includes("opencode.json"))).toBe(true)
+		expect(output.some((line) => line.includes("docs/README.md"))).toBe(true)
+	})
+
+	test("handles empty template directory", async () => {
+		// Capture output
+		const output: string[] = []
+		const originalLog = console.log
+		console.log = (...args: any[]) => {
+			output.push(args.join(" "))
+		}
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await runTestEffect(templateList({ silent: false }))
+		} finally {
+			process.chdir(originalCwd)
+			console.log = originalLog
+		}
+
+		expect(output.some((line) => line.includes("has no files"))).toBe(true)
+	})
+
+	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(templateList({ 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(templateList({ silent: true })),
+			).rejects.toThrow("Repository not initialized")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+})

package/src/commands/template-list.ts

@@ -0,0 +1,87 @@
+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 from "../utils/colors"
+import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
+
+interface ListOptions extends BaseCommandOptions {}
+
+export const templateList = (options: ListOptions = {}) =>
+	Effect.gen(function* () {
+		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(`Listing files in template: ${highlight.template(templateName)}`)
+
+		// Get template directory
+		const templateDir = yield* templateService.getTemplateDir(templateName)
+
+		// Check if template directory exists and is a directory
+		const isDirectory = yield* Effect.tryPromise({
+			try: async () => {
+				const file = Bun.file(templateDir)
+				const stat = await file.stat()
+				return stat?.isDirectory?.() ?? false
+			},
+			catch: (error) =>
+				new Error(`Failed to check template directory: ${error}`),
+		})
+		if (!isDirectory) {
+			return yield* Effect.fail(
+				new Error(
+					`Template directory does not exist: ${highlight.template(templateName)}`,
+				),
+			)
+		}
+
+		// Collect all files recursively
+		const files = yield* fs.collectFiles(templateDir, {
+			exclude: [".gitkeep"],
+			sort: true,
+		})
+
+		if (files.length === 0) {
+			log(`Template ${highlight.template(templateName)} has no files`)
+			return
+		}
+
+		for (const file of files) {
+			log(highlight.file(file))
+		}
+	})
+
+// Help text for reference (not exported as it's handled by template command)
+const help = `
+Usage: agency template list [options]
+
+List all files in the configured template directory.
+
+This command displays all files stored in the template configured for the
+current git repository.
+
+Options:
+  -h, --help        Show this help message
+  -s, --silent      Suppress output messages
+  -v, --verbose     Show verbose output
+
+Example:
+  agency template list                # List files in current template
+
+Notes:
+  - Requires agency.template to be set (run 'agency init' first)
+  - Shows files relative to template root directory
+  - Files are listed in alphabetical order
+  - Template directory must exist (created when you save files)
+`

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

@@ -0,0 +1,158 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { templateView } from "./template-view"
+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 view command", () => {
+	let testDir: string
+	let gitRoot: string
+	let templateDir: string
+
+	beforeEach(async () => {
+		// Create temporary test directory
+		testDir = join(tmpdir(), `agency-test-view-${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("views file from template directory", async () => {
+		// Create test file in template
+		const content = "# Test File\n\nThis is a test."
+		const testFile = join(templateDir, "test.md")
+		await writeFile(testFile, content)
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			// Just verify the command doesn't throw - output goes to stdout
+			await runTestEffect(templateView({ file: "test.md", silent: true }))
+
+			// Verify the file exists and has expected content
+			const fileContent = await Bun.file(testFile).text()
+			expect(fileContent).toContain("# Test File")
+			expect(fileContent).toContain("This is a test.")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("views file in subdirectory", async () => {
+		// Create test file in subdirectory
+		const docsDir = join(templateDir, "docs")
+		await mkdir(docsDir, { recursive: true })
+		const content = "# Documentation\n\nDocs content."
+		const testFile = join(docsDir, "README.md")
+		await writeFile(testFile, content)
+
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			// Just verify the command doesn't throw - output goes to stdout
+			await runTestEffect(
+				templateView({ file: "docs/README.md", silent: true }),
+			)
+
+			// Verify the file exists and has expected content
+			const fileContent = await Bun.file(testFile).text()
+			expect(fileContent).toContain("# Documentation")
+			expect(fileContent).toContain("Docs content.")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("throws error when file does not exist", async () => {
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await expect(
+				runTestEffect(templateView({ file: "nonexistent.md", silent: true })),
+			).rejects.toThrow("does not exist in template")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+
+	test("throws error when no file specified", async () => {
+		const originalCwd = process.cwd()
+		process.chdir(gitRoot)
+
+		try {
+			await expect(
+				runTestEffect(templateView({ silent: true })),
+			).rejects.toThrow("File path is required")
+		} 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(templateView({ file: "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(templateView({ file: "test.md", silent: true })),
+			).rejects.toThrow("Repository not initialized")
+		} finally {
+			process.chdir(originalCwd)
+		}
+	})
+})

package/src/commands/template-view.ts

@@ -0,0 +1,86 @@
+import { resolve } 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 from "../utils/colors"
+import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
+
+interface ViewOptions extends BaseCommandOptions {
+	file?: string
+}
+
+export const templateView = (options: ViewOptions = {}) =>
+	Effect.gen(function* () {
+		const { file: fileToView, silent = false } = options
+		const { 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())
+		}
+
+		if (!fileToView) {
+			return yield* Effect.fail(
+				new Error("File path is required. Usage: agency template view <file>"),
+			)
+		}
+
+		verboseLog(
+			`Viewing ${highlight.file(fileToView)} from ${highlight.template(templateName)} template`,
+		)
+
+		// Get template directory
+		const templateDir = yield* templateService.getTemplateDir(templateName)
+		const templateFilePath = resolve(templateDir, fileToView)
+
+		// Check if file exists
+		const exists = yield* fs.exists(templateFilePath)
+		if (!exists) {
+			return yield* Effect.fail(
+				new Error(
+					`File ${highlight.file(fileToView)} does not exist in template ${highlight.template(templateName)}`,
+				),
+			)
+		}
+
+		// Read and display the file
+		const content = yield* fs.readFile(templateFilePath)
+		if (!silent) {
+			console.log(content)
+		}
+	})
+
+// Help text for reference (not exported as it's handled by template command)
+const help = `
+Usage: agency template view <file> [options]
+
+View the contents of a file in the configured template directory.
+
+This command displays the contents of a file stored in the template 
+configured for the current git repository.
+
+Arguments:
+  <file>            File path to view (relative to template root)
+
+Options:
+  -h, --help        Show this help message
+  -s, --silent      Suppress verbose messages (file content still shown)
+  -v, --verbose     Show verbose output
+
+Examples:
+  agency template view AGENTS.md         # View AGENTS.md from template
+  agency template view docs/README.md    # View file in subdirectory
+
+Notes:
+  - Requires agency.template to be set (run 'agency init' first)
+  - File path is relative to template root directory
+  - File content is displayed directly to stdout
+`

package/src/commands/template.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test"
+import { template } from "./template"
+import { runTestEffect } from "../test-utils"
+
+describe("template command", () => {
+	test("throws error when no subcommand provided", async () => {
+		await expect(
+			runTestEffect(
+				template({
+					args: [],
+					silent: true,
+				}),
+			),
+		).rejects.toThrow(
+			"Subcommand is required. Available subcommands: use, save, list, view, delete",
+		)
+	})
+
+	test("throws error for unknown subcommand", async () => {
+		await expect(
+			runTestEffect(
+				template({
+					subcommand: "invalid",
+					args: [],
+					silent: true,
+				}),
+			),
+		).rejects.toThrow(
+			"Unknown template subcommand 'invalid'. Available: use, save, list, view, delete",
+		)
+	})
+})

package/src/commands/template.ts

@@ -0,0 +1,96 @@
+import { Effect } from "effect"
+import { use } from "./use"
+import { save } from "./save"
+import { templateList } from "./template-list"
+import { templateDelete } from "./template-delete"
+import { templateView } from "./template-view"
+
+export const help = `
+Usage: agency template <subcommand> [options]
+
+Subcommands:
+  use [template]         Set template for this repository
+  save <file|dir> ...    Save files/dirs to configured template
+  list                   List all files in configured template
+  view <file>            View contents of a file in template
+  delete <file> ...      Delete files from configured template
+
+Examples:
+  agency template use                    # Interactively select template
+  agency template use work               # Set template to 'work'
+  agency template save AGENTS.md         # Save specific file to template
+  agency template list                   # List files in current template
+  agency template view AGENTS.md         # View file from template
+  agency template delete AGENTS.md       # Delete file from template
+
+For more information about a subcommand, run:
+  agency template <subcommand> --help
+`
+
+export const template = (options: {
+	subcommand?: string
+	args: string[]
+	silent?: boolean
+	verbose?: boolean
+	template?: string
+}) =>
+	Effect.gen(function* () {
+		const {
+			subcommand,
+			args,
+			silent,
+			verbose,
+			template: templateName,
+		} = options
+
+		if (!subcommand) {
+			return yield* Effect.fail(
+				new Error(
+					"Subcommand is required. Available subcommands: use, save, list, view, delete\n\nRun 'agency template --help' for usage information.",
+				),
+			)
+		}
+
+		switch (subcommand) {
+			case "use":
+				return yield* use({
+					template: args[0] || templateName,
+					silent,
+					verbose,
+				})
+
+			case "save":
+				return yield* save({
+					files: args,
+					silent,
+					verbose,
+				})
+
+			case "list":
+				return yield* templateList({
+					silent,
+					verbose,
+				})
+
+			case "view":
+				return yield* templateView({
+					file: args[0],
+					silent,
+					verbose,
+				})
+
+			case "delete":
+				return yield* templateDelete({
+					files: args,
+					silent,
+					verbose,
+				})
+
+			default:
+				return yield* Effect.fail(
+					new Error(
+						`Unknown template subcommand '${subcommand}'. Available: use, save, list, view, delete`,
+					),
+				)
+		}
+	})