@markjaquith/agency 1.11.1 → 2.0.0

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

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

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

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

@@ -1,96 +0,0 @@
-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`,
-					),
-				)
-		}
-	})

package/src/commands/use.test.ts

@@ -1,87 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { use } from "./use"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	getGitConfig,
-	runTestEffect,
-} from "../test-utils"
-
-describe("use 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
-		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("sets template name in git config", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		await runTestEffect(use({ template: "work", silent: true }))
-
-		const templateName = await getGitConfig("agency.template", tempDir)
-		expect(templateName).toBe("work")
-	})
-
-	test("updates existing template name", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		await runTestEffect(use({ template: "work", silent: true }))
-		await runTestEffect(use({ template: "personal", silent: true }))
-
-		const templateName = await getGitConfig("agency.template", tempDir)
-		expect(templateName).toBe("personal")
-	})
-
-	test("throws error when not in git repo", async () => {
-		process.chdir(tempDir)
-
-		await expect(
-			runTestEffect(use({ template: "work", silent: true })),
-		).rejects.toThrow("Not in a git repository")
-	})
-
-	test("throws error when no template provided in silent mode", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		await expect(runTestEffect(use({ silent: true }))).rejects.toThrow(
-			"Template name required",
-		)
-	})
-
-	test("works with --template flag", async () => {
-		await initGitRepo(tempDir)
-		process.chdir(tempDir)
-
-		await runTestEffect(use({ template: "client", silent: true }))
-
-		const templateName = await getGitConfig("agency.template", tempDir)
-		expect(templateName).toBe("client")
-	})
-})

package/src/commands/use.ts

@@ -1,97 +0,0 @@
-import { Effect } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { TemplateService } from "../services/TemplateService"
-import { PromptService } from "../services/PromptService"
-import highlight from "../utils/colors"
-import { createLoggers, ensureGitRepo } from "../utils/effect"
-
-interface UseOptions extends BaseCommandOptions {
-	template?: string
-}
-
-export const use = (options: UseOptions = {}) =>
-	Effect.gen(function* () {
-		const { silent = false } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const templateService = yield* TemplateService
-		const promptService = yield* PromptService
-
-		const gitRoot = yield* ensureGitRepo()
-
-		let templateName = options.template
-
-		// If no template name provided, show interactive selection
-		if (!templateName) {
-			if (silent) {
-				return yield* Effect.fail(
-					new Error(
-						"Template name required. Use --template flag in silent mode.",
-					),
-				)
-			}
-
-			const templates = yield* templateService.listTemplates()
-
-			if (templates.length === 0) {
-				log("No templates found in ~/.config/agency/templates/")
-				log("Run 'agency task' to create a template.")
-				return
-			}
-
-			// Show current template if set
-			const currentTemplate = yield* git.getGitConfig(
-				"agency.template",
-				gitRoot,
-			)
-			if (currentTemplate) {
-				log(`Current template: ${highlight.template(currentTemplate)}`)
-			}
-
-			templateName = yield* promptService.promptForTemplate(templates, {
-				currentTemplate: currentTemplate ?? undefined,
-				allowNew: false,
-			})
-		}
-
-		verboseLog(`Setting template to: ${templateName}`)
-
-		// Set the template in git config
-		yield* git.setGitConfig("agency.template", templateName, gitRoot)
-	})
-
-// Help text for reference (not exported as it's handled by template command)
-const help = `
-Usage: agency template use [template] [options]
-
-Set the template to use for this repository.
-
-NOTE: This command is equivalent to 'agency init'. Use 'agency init' for
-      initial setup, and 'agency template use' to change templates later.
-
-When no template name is provided, shows an interactive list of available
-templates to choose from. The template name is saved to .git/config
-(agency.template) and will be used by subsequent 'agency task' commands.
-
-Arguments:
-  template          Template name to use (optional, prompts if not provided)
-
-Options:
-  -h, --help        Show this help message
-  -s, --silent      Suppress output messages
-  -v, --verbose     Show verbose output
-  -t, --template    Specify template name (same as positional argument)
-
-Examples:
-  agency template use                     # Interactive template selection
-  agency template use work                # Set template to 'work'
-  agency template use --template=client   # Set template to 'client'
-
-Notes:
-  - Template must exist in ~/.config/agency/templates/{name}/
-  - Template name is saved to .git/config (not committed)
-  - Use 'agency task' after changing template to create/update files
-  - Template directory is created when you save files to it
-`

package/src/constants.ts

@@ -1,10 +0,0 @@
-/**
- * Shared constants for the agency CLI tool.
- */
-
-/**
- * Marker used in commit messages to indicate commits that should be
- * dropped entirely during the emit process. When this marker is found
- * in a commit message, emit will remove that commit from history.
- */
-export const AGENCY_REMOVE_COMMIT = "AGENCY_REMOVE_COMMIT"

package/src/errors.ts

@@ -1,17 +0,0 @@
-import { Data } from "effect"
-
-/**
- * Error thrown when a command requires the repository to be initialized
- * but agency.template is not set in git config
- */
-export class RepositoryNotInitializedError extends Data.TaggedError(
-	"RepositoryNotInitializedError",
-)<{
-	readonly message: string
-}> {
-	constructor(
-		message: string = "Repository not initialized. Run 'agency init' first to select a template.",
-	) {
-		super({ message })
-	}
-}

package/src/schemas.ts

@@ -1,33 +0,0 @@
-import { Schema } from "@effect/schema"
-
-/**
- * Schema for managed files in the agency system
- */
-export class ManagedFile extends Schema.Class<ManagedFile>("ManagedFile")({
-	name: Schema.String,
-	defaultContent: Schema.optional(Schema.String),
-}) {}
-
-/**
- * Schema for agency metadata stored in agency.json
- */
-export class AgencyMetadata extends Schema.Class<AgencyMetadata>(
-	"AgencyMetadata",
-)({
-	version: Schema.Literal(1),
-	injectedFiles: Schema.Array(Schema.String),
-	baseBranch: Schema.optional(Schema.String),
-	template: Schema.String,
-	createdAt: Schema.DateTimeUtc,
-	emitBranch: Schema.optional(Schema.String),
-}) {}
-
-/**
- * Schema for agency configuration stored in ~/.config/agency/agency.json
- */
-export class AgencyConfig extends Schema.Class<AgencyConfig>("AgencyConfig")({
-	sourceBranchPattern: Schema.String.pipe(
-		Schema.annotations({ default: "agency--%branch%" }),
-	),
-	emitBranch: Schema.String.pipe(Schema.annotations({ default: "%branch%" })),
-}) {}