@markjaquith/agency 1.6.3 → 1.7.0

package/src/services/FormatterService.test.ts

@@ -0,0 +1,432 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { Effect } from "effect"
+import { FormatterService } from "../services/FormatterService"
+import { createTempDir, cleanupTempDir, runTestEffect } from "../test-utils"
+
+describe("FormatterService", () => {
+	let tempDir: string
+
+	beforeEach(async () => {
+		tempDir = await createTempDir()
+	})
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir)
+	})
+
+	describe("detectPackageManager", () => {
+		test("returns null when no package.json exists", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBeNull()
+		})
+
+		test("detects bun from bun.lockb", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "bun.lockb"), "")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("bun")
+		})
+
+		test("detects bun from bun.lock", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "bun.lock"), "")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("bun")
+		})
+
+		test("detects yarn from yarn.lock", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "yarn.lock"), "")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("yarn")
+		})
+
+		test("detects pnpm from pnpm-lock.yaml", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "pnpm-lock.yaml"), "")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("pnpm")
+		})
+
+		test("detects npm from package-lock.json", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "package-lock.json"), "{}")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("npm")
+		})
+
+		test("defaults to npm when package.json exists but no lock file", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("npm")
+		})
+
+		test("bun.lockb takes priority over yarn.lock", async () => {
+			await Bun.write(join(tempDir, "package.json"), "{}")
+			await Bun.write(join(tempDir, "bun.lockb"), "")
+			await Bun.write(join(tempDir, "yarn.lock"), "")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectPackageManager(tempDir)
+				}),
+			)
+			expect(result).toBe("bun")
+		})
+	})
+
+	describe("detectFormatter", () => {
+		test("returns null when no package.json exists", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBeNull()
+		})
+
+		test("detects prettier in devDependencies", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({
+					devDependencies: { prettier: "^3.0.0" },
+				}),
+			)
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBe("prettier")
+		})
+
+		test("detects prettier in dependencies", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({
+					dependencies: { prettier: "^3.0.0" },
+				}),
+			)
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBe("prettier")
+		})
+
+		test("detects oxfmt in devDependencies", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({
+					devDependencies: { oxfmt: "^0.1.0" },
+				}),
+			)
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBe("oxfmt")
+		})
+
+		test("oxfmt takes priority over prettier", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({
+					devDependencies: { prettier: "^3.0.0", oxfmt: "^0.1.0" },
+				}),
+			)
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBe("oxfmt")
+		})
+
+		test("returns null when no formatter is in dependencies", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({
+					devDependencies: { typescript: "^5.0.0" },
+				}),
+			)
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBeNull()
+		})
+
+		test("handles malformed package.json gracefully", async () => {
+			await Bun.write(join(tempDir, "package.json"), "not valid json")
+
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.detectFormatter(tempDir)
+				}),
+			)
+			expect(result).toBeNull()
+		})
+	})
+
+	describe("buildFormatterCommand", () => {
+		test("builds prettier command with bun", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "bun", [
+						"/path/to/file.md",
+					])
+				}),
+			)
+			expect(result).toEqual([
+				"bun",
+				"x",
+				"prettier",
+				"--write",
+				"/path/to/file.md",
+			])
+		})
+
+		test("builds prettier command with yarn", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "yarn", [
+						"/path/to/file.md",
+					])
+				}),
+			)
+			expect(result).toEqual([
+				"yarn",
+				"dlx",
+				"prettier",
+				"--write",
+				"/path/to/file.md",
+			])
+		})
+
+		test("builds prettier command with pnpm", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "pnpm", [
+						"/path/to/file.md",
+					])
+				}),
+			)
+			expect(result).toEqual([
+				"pnpm",
+				"exec",
+				"prettier",
+				"--write",
+				"/path/to/file.md",
+			])
+		})
+
+		test("builds prettier command with npm", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "npm", [
+						"/path/to/file.md",
+					])
+				}),
+			)
+			expect(result).toEqual(["npx", "prettier", "--write", "/path/to/file.md"])
+		})
+
+		test("builds oxfmt command with bun", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("oxfmt", "bun", [
+						"/path/to/file.json",
+					])
+				}),
+			)
+			expect(result).toEqual(["bun", "x", "oxfmt", "/path/to/file.json"])
+		})
+
+		test("handles multiple files", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "bun", [
+						"/path/to/file.md",
+						"/path/to/file.json",
+					])
+				}),
+			)
+			expect(result).toEqual([
+				"bun",
+				"x",
+				"prettier",
+				"--write",
+				"/path/to/file.md",
+				"/path/to/file.json",
+			])
+		})
+
+		test("returns null for empty file list", async () => {
+			const result = await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					return yield* service.buildFormatterCommand("prettier", "bun", [])
+				}),
+			)
+			expect(result).toBeNull()
+		})
+	})
+
+	describe("formatFiles", () => {
+		test("silently does nothing when no package.json exists", async () => {
+			const logs: string[] = []
+			const verboseLog = (msg: string) => logs.push(msg)
+
+			await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					yield* service.formatFiles(tempDir, ["AGENTS.md"], verboseLog)
+				}),
+			)
+
+			expect(logs.some((l) => l.includes("No formatter"))).toBe(true)
+		})
+
+		test("silently does nothing when no formatter in package.json", async () => {
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({ devDependencies: { typescript: "^5.0.0" } }),
+			)
+
+			const logs: string[] = []
+			const verboseLog = (msg: string) => logs.push(msg)
+
+			await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					yield* service.formatFiles(tempDir, ["AGENTS.md"], verboseLog)
+				}),
+			)
+
+			expect(logs.some((l) => l.includes("No formatter"))).toBe(true)
+		})
+
+		test("filters to only md/json/jsonc files", async () => {
+			const logs: string[] = []
+			const verboseLog = (msg: string) => logs.push(msg)
+
+			await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					yield* service.formatFiles(
+						tempDir,
+						["somefile.ts", "other.txt"],
+						verboseLog,
+					)
+				}),
+			)
+
+			expect(logs.some((l) => l.includes("No formattable files"))).toBe(true)
+		})
+
+		test("does nothing with empty file list", async () => {
+			const logs: string[] = []
+			const verboseLog = (msg: string) => logs.push(msg)
+
+			await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					yield* service.formatFiles(tempDir, [], verboseLog)
+				}),
+			)
+
+			expect(logs.some((l) => l.includes("No files to format"))).toBe(true)
+		})
+
+		test("silently handles formatter command failure", async () => {
+			// Set up a project with prettier but no actual prettier installed
+			await Bun.write(
+				join(tempDir, "package.json"),
+				JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }),
+			)
+			await Bun.write(join(tempDir, "bun.lockb"), "")
+			await Bun.write(join(tempDir, "AGENTS.md"), "# Test")
+
+			const logs: string[] = []
+			const verboseLog = (msg: string) => logs.push(msg)
+
+			// Should not throw even though prettier isn't actually installed
+			await runTestEffect(
+				Effect.gen(function* () {
+					const service = yield* FormatterService
+					yield* service.formatFiles(tempDir, ["AGENTS.md"], verboseLog)
+				}),
+			)
+
+			// Should have detected the formatter and attempted to run it
+			expect(logs.some((l) => l.includes("Detected formatter: prettier"))).toBe(
+				true,
+			)
+		})
+	})
+})

package/src/services/FormatterService.ts

@@ -0,0 +1,219 @@
+import { Effect } from "effect"
+import { resolve } from "path"
+import { FileSystemService } from "./FileSystemService"
+
+type PackageJson = {
+	dependencies?: Record<string, string>
+	devDependencies?: Record<string, string>
+}
+
+type PackageManager = "bun" | "yarn" | "pnpm" | "npm"
+
+type Formatter = "prettier" | "oxfmt"
+
+/**
+ * Service for detecting and running code formatters on agency-created files.
+ *
+ * When agency creates files (markdown, json), pre-commit or pre-push hooks
+ * in the target project may fail if those files aren't formatted according
+ * to the project's formatter settings. This service detects the project's
+ * formatter (prettier or oxfmt) and package manager, then runs the formatter
+ * on the specified files. Failures are silently ignored.
+ */
+export class FormatterService extends Effect.Service<FormatterService>()(
+	"FormatterService",
+	{
+		sync: () => ({
+			/**
+			 * Detect which package manager the project uses by checking for lock files.
+			 * Falls back to npm if no lock file is found but package.json exists.
+			 * Returns null if no package.json exists.
+			 */
+			detectPackageManager: (gitRoot: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+
+					// Check for package.json first - if it doesn't exist, no package manager
+					const hasPackageJson = yield* fs.exists(
+						resolve(gitRoot, "package.json"),
+					)
+					if (!hasPackageJson) {
+						return null
+					}
+
+					// Check lock files in priority order
+					if (yield* fs.exists(resolve(gitRoot, "bun.lockb")))
+						return "bun" as PackageManager
+					if (yield* fs.exists(resolve(gitRoot, "bun.lock")))
+						return "bun" as PackageManager
+					if (yield* fs.exists(resolve(gitRoot, "yarn.lock")))
+						return "yarn" as PackageManager
+					if (yield* fs.exists(resolve(gitRoot, "pnpm-lock.yaml")))
+						return "pnpm" as PackageManager
+					if (yield* fs.exists(resolve(gitRoot, "package-lock.json")))
+						return "npm" as PackageManager
+
+					// Default to npm if package.json exists but no lock file found
+					return "npm" as PackageManager
+				}),
+
+			/**
+			 * Detect which formatter is available in the project's package.json.
+			 * Checks both dependencies and devDependencies for prettier and oxfmt.
+			 * Returns null if neither is found.
+			 */
+			detectFormatter: (gitRoot: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+
+					const packageJsonPath = resolve(gitRoot, "package.json")
+					const exists = yield* fs.exists(packageJsonPath)
+					if (!exists) {
+						return null
+					}
+
+					const packageJson = yield* fs.readJSON<PackageJson>(packageJsonPath)
+
+					const allDeps = {
+						...packageJson.dependencies,
+						...packageJson.devDependencies,
+					}
+
+					// Check for oxfmt first (newer/faster), then prettier
+					if ("oxfmt" in allDeps) return "oxfmt" as Formatter
+					if ("prettier" in allDeps) return "prettier" as Formatter
+
+					return null
+				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
+
+			/**
+			 * Build the command to run a formatter via the detected package manager.
+			 * Returns the command args array, or null if the formatter/pm combo isn't supported.
+			 */
+			buildFormatterCommand: (
+				formatter: Formatter,
+				packageManager: PackageManager,
+				files: string[],
+			) =>
+				Effect.sync(() => {
+					if (files.length === 0) return null
+
+					// Build the runner prefix based on package manager
+					const runnerPrefix: string[] = (() => {
+						switch (packageManager) {
+							case "bun":
+								return ["bun", "x"]
+							case "yarn":
+								return ["yarn", "dlx"]
+							case "pnpm":
+								return ["pnpm", "exec"]
+							case "npm":
+								return ["npx"]
+						}
+					})()
+
+					// Build the formatter command
+					switch (formatter) {
+						case "prettier":
+							return [...runnerPrefix, "prettier", "--write", ...files]
+						case "oxfmt":
+							return [...runnerPrefix, "oxfmt", ...files]
+						default:
+							return null
+					}
+				}),
+
+			/**
+			 * Format the given files using the project's detected formatter.
+			 * Silently returns if no formatter is detected or if the command fails.
+			 * This is the main entry point for formatting agency-created files.
+			 */
+			formatFiles: (
+				gitRoot: string,
+				files: string[],
+				verboseLog: (msg: string) => void,
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+
+					if (files.length === 0) {
+						verboseLog("No files to format")
+						return
+					}
+
+					// Filter to only .md and .json/.jsonc files (the types agency creates)
+					const formattableFiles = files.filter(
+						(f) =>
+							f.endsWith(".md") || f.endsWith(".json") || f.endsWith(".jsonc"),
+					)
+
+					if (formattableFiles.length === 0) {
+						verboseLog("No formattable files (md/json/jsonc) found")
+						return
+					}
+
+					// Use yield* on the service methods via self-reference through the service tag
+					const formatterService = yield* FormatterService
+
+					const formatter = yield* formatterService.detectFormatter(gitRoot)
+					if (!formatter) {
+						verboseLog("No formatter (prettier/oxfmt) detected in package.json")
+						return
+					}
+
+					const packageManager =
+						yield* formatterService.detectPackageManager(gitRoot)
+					if (!packageManager) {
+						verboseLog("No package manager detected")
+						return
+					}
+
+					verboseLog(
+						`Detected formatter: ${formatter}, package manager: ${packageManager}`,
+					)
+
+					// Build absolute paths for the files
+					const absolutePaths = formattableFiles.map((f) => resolve(gitRoot, f))
+
+					const command = yield* formatterService.buildFormatterCommand(
+						formatter,
+						packageManager,
+						absolutePaths,
+					)
+					if (!command) {
+						verboseLog("Could not build formatter command")
+						return
+					}
+
+					verboseLog(`Running formatter: ${command.join(" ")}`)
+
+					// Run the formatter, silently ignoring failures
+					yield* fs
+						.runCommand(command, {
+							cwd: gitRoot,
+							captureOutput: true,
+						})
+						.pipe(
+							Effect.catchAll((err) => {
+								verboseLog(`Formatter failed (silently ignoring): ${err}`)
+								return Effect.void
+							}),
+						)
+
+					verboseLog(
+						`Formatted ${formattableFiles.length} file(s) with ${formatter}`,
+					)
+				}).pipe(
+					// Catch any unexpected errors silently
+					Effect.catchAll((err) => {
+						verboseLog(`Formatting failed (silently ignoring): ${err}`)
+						return Effect.void
+					}),
+					Effect.catchAllDefect((defect) => {
+						verboseLog(`Formatting defect (silently ignoring): ${defect}`)
+						return Effect.void
+					}),
+				),
+		}),
+	},
+) {}

package/src/services/TemplateService.ts

@@ -5,6 +5,7 @@ import {
 	getTemplateDir,
 	getTemplatesDir,
 } from "../utils/paths"
+import { FileSystemService } from "./FileSystemService"
 
 // Error types for Template operations
 class TemplateError extends Data.TaggedError("TemplateError")<{
@@ -35,9 +36,14 @@ export class TemplateService extends Effect.Service<TemplateService>()(
 						}),
 				}),
 
-			createTemplateDir: (_templateName: string) =>
-				Effect.sync(() => {
-					// Directory creation is handled by FileSystemService.createDirectory
+			createTemplateDir: (templateName: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const templateDir = getTemplateDir(templateName)
+					const exists = yield* fs.exists(templateDir)
+					if (!exists) {
+						yield* fs.createDirectory(templateDir)
+					}
 				}),
 
 			listTemplates: () =>

package/src/test-utils.ts

@@ -383,6 +383,7 @@ import { OpencodeService } from "./services/OpencodeService"
 import { ClaudeService } from "./services/ClaudeService"
 import { FilterRepoService } from "./services/FilterRepoService"
 import { MockFilterRepoService } from "./services/MockFilterRepoService"
+import { FormatterService } from "./services/FormatterService"
 
 // Re-export mock utilities for tests
 export {
@@ -402,6 +403,7 @@ const TestLayer = Layer.mergeAll(
 	OpencodeService.Default,
 	ClaudeService.Default,
 	FilterRepoService.Default,
+	FormatterService.Default,
 )
 
 // Create test layer with mock filter-repo (for tests that don't need real filtering)
@@ -414,6 +416,7 @@ const TestLayerWithMockFilterRepo = Layer.mergeAll(
 	OpencodeService.Default,
 	ClaudeService.Default,
 	MockFilterRepoService.Default,
+	FormatterService.Default,
 )
 
 export async function runTestEffect<A, E>(