@markjaquith/agency 0.5.0

package/src/services/ClaudeService.ts

@@ -0,0 +1,91 @@
+import { Effect } from "effect"
+import { FileSystemService } from "./FileSystemService"
+
+const AGENCY_SECTION = `
+## Agency
+
+@AGENCY.md
+@TASK.md`
+
+/**
+ * Service for handling CLAUDE.md files with @-reference injection.
+ */
+export class ClaudeService extends Effect.Service<ClaudeService>()(
+	"ClaudeService",
+	{
+		sync: () => ({
+			/**
+			 * Check if CLAUDE.md exists in the git root.
+			 */
+			claudeFileExists: (gitRoot: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const claudePath = `${gitRoot}/CLAUDE.md`
+					return yield* fs.exists(claudePath)
+				}),
+
+			/**
+			 * Check if the CLAUDE.md file already contains the agency section.
+			 */
+			hasAgencySection: (content: string) =>
+				Effect.sync(() => {
+					// Check if both @AGENCY.md and @TASK.md exist in the content
+					return content.includes("@AGENCY.md") && content.includes("@TASK.md")
+				}),
+
+			/**
+			 * Inject or ensure the agency section exists in CLAUDE.md.
+			 * If the file doesn't exist, create it with the basic template.
+			 * If it exists but doesn't have the references, append them.
+			 * Returns true if the file was modified, false if no changes needed.
+			 */
+			injectAgencySection: (gitRoot: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const claudePath = `${gitRoot}/CLAUDE.md`
+
+					// Check if file exists
+					const exists = yield* fs.exists(claudePath)
+
+					if (!exists) {
+						// Create new CLAUDE.md with basic template
+						const content = `# Claude Code Instructions
+
+This project uses the agency CLI for managing development tasks and templates.
+${AGENCY_SECTION}
+`
+						yield* fs.writeFile(claudePath, content)
+						return { modified: true, created: true }
+					}
+
+					// Read existing content
+					const content = yield* fs.readFile(claudePath)
+
+					// Check if agency section already exists
+					const hasSection = yield* Effect.sync(() => {
+						return (
+							content.includes("@AGENCY.md") && content.includes("@TASK.md")
+						)
+					})
+
+					if (hasSection) {
+						// Check if they're in the correct order
+						const agencyIndex = content.indexOf("@AGENCY.md")
+						const taskIndex = content.indexOf("@TASK.md")
+
+						if (agencyIndex < taskIndex) {
+							// Already has the section in correct order
+							return { modified: false, created: false }
+						}
+
+						// They exist but in wrong order - we'll re-add them
+					}
+
+					// Append the agency section
+					const newContent = content.trimEnd() + "\n" + AGENCY_SECTION + "\n"
+					yield* fs.writeFile(claudePath, newContent)
+					return { modified: true, created: false }
+				}),
+		}),
+	},
+) {}

package/src/services/ConfigService.ts

@@ -0,0 +1,115 @@
+import { Effect, Data } from "effect"
+import { Schema } from "@effect/schema"
+import { mkdir } from "node:fs/promises"
+import { AgencyConfig } from "../schemas"
+import { getAgencyConfigDir, getAgencyConfigPath } from "../utils/paths"
+
+// Error types for Config operations
+class ConfigError extends Data.TaggedError("ConfigError")<{
+	message: string
+	cause?: unknown
+}> {}
+
+class ConfigWriteError extends Data.TaggedError("ConfigWriteError")<{
+	path: string
+	cause?: unknown
+}> {}
+
+const DEFAULT_CONFIG: AgencyConfig = new AgencyConfig({
+	sourceBranchPattern: "agency/%branch%",
+	emitBranch: "%branch%",
+})
+
+// Config Service using Effect.Service pattern
+export class ConfigService extends Effect.Service<ConfigService>()(
+	"ConfigService",
+	{
+		sync: () => ({
+			getConfigDir: () => Effect.sync(() => getAgencyConfigDir()),
+
+			getConfigPath: () => Effect.sync(() => getAgencyConfigPath()),
+
+			loadConfig: (configPath?: string) =>
+				Effect.gen(function* () {
+					const path =
+						configPath || (yield* Effect.sync(() => getAgencyConfigPath()))
+
+					// Check if file exists
+					const file = Bun.file(path)
+					const exists = yield* Effect.tryPromise({
+						try: () => file.exists(),
+						catch: () =>
+							new ConfigError({
+								message: `Failed to check if config exists at ${path}`,
+							}),
+					})
+
+					if (!exists) {
+						return DEFAULT_CONFIG
+					}
+
+					// Try to read and parse the config
+					const data = yield* Effect.tryPromise({
+						try: () => file.json(),
+						catch: (error) =>
+							new ConfigError({
+								message: `Failed to read config file at ${path}`,
+								cause: error,
+							}),
+					})
+
+					// Parse with schema, but fall back to defaults on error
+					const parsed = yield* Effect.try({
+						try: () => Schema.decodeUnknownSync(AgencyConfig)(data),
+						catch: (error) =>
+							new ConfigError({
+								message: `Invalid config format at ${path}`,
+								cause: error,
+							}),
+					})
+
+					// If we get here, parsing succeeded
+					return parsed || DEFAULT_CONFIG
+				}),
+
+			saveConfig: (config: AgencyConfig, configPath?: string) =>
+				Effect.gen(function* () {
+					const path =
+						configPath || (yield* Effect.sync(() => getAgencyConfigPath()))
+
+					// Ensure the config directory exists
+					const configDir = yield* Effect.sync(() => getAgencyConfigDir())
+
+					yield* Effect.tryPromise({
+						try: () => mkdir(configDir, { recursive: true }),
+						catch: (error) =>
+							new ConfigWriteError({
+								path: configDir,
+								cause: error,
+							}),
+					})
+
+					// Encode and write the config
+					const encoded = yield* Effect.try({
+						try: () => Schema.encodeSync(AgencyConfig)(config),
+						catch: (error) =>
+							new ConfigWriteError({
+								path,
+								cause: error,
+							}),
+					})
+
+					yield* Effect.tryPromise({
+						try: () => Bun.write(path, JSON.stringify(encoded, null, 2) + "\n"),
+						catch: (error) =>
+							new ConfigWriteError({
+								path,
+								cause: error,
+							}),
+					})
+				}),
+
+			getDefaultConfig: () => Effect.succeed(DEFAULT_CONFIG),
+		}),
+	},
+) {}

package/src/services/FileSystemService.ts

@@ -0,0 +1,222 @@
+import { Effect, Data, pipe } from "effect"
+import { mkdir, copyFile as fsCopyFile, unlink } from "node:fs/promises"
+import { spawnProcess } from "../utils/process"
+
+// Error types for FileSystem operations
+class FileSystemError extends Data.TaggedError("FileSystemError")<{
+	message: string
+	cause?: unknown
+}> {}
+
+class FileNotFoundError extends Data.TaggedError("FileNotFoundError")<{
+	path: string
+}> {}
+
+// FileSystem Service using Effect.Service pattern
+export class FileSystemService extends Effect.Service<FileSystemService>()(
+	"FileSystemService",
+	{
+		sync: () => ({
+			exists: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						const file = Bun.file(path)
+						return await file.exists()
+					},
+					catch: () =>
+						new FileSystemError({
+							message: `Failed to check if file exists: ${path}`,
+						}),
+				}),
+
+			isDirectory: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						const file = Bun.file(path)
+						const exists = await file.exists()
+						if (!exists) {
+							return false
+						}
+						// Use stat to check if it's a directory
+						const stat = await import("node:fs/promises").then((fs) =>
+							fs.stat(path),
+						)
+						return stat.isDirectory()
+					},
+					catch: () =>
+						new FileSystemError({
+							message: `Failed to check if path is directory: ${path}`,
+						}),
+				}),
+
+			readFile: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						const file = Bun.file(path)
+						const exists = await file.exists()
+						if (!exists) {
+							throw new Error(`File not found: ${path}`)
+						}
+						return await file.text()
+					},
+					catch: () => new FileNotFoundError({ path }),
+				}),
+
+			writeFile: (path: string, content: string) =>
+				Effect.tryPromise({
+					try: () => Bun.write(path, content),
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to write file: ${path}`,
+							cause: error,
+						}),
+				}),
+
+			readJSON: <T = unknown>(path: string) =>
+				Effect.tryPromise({
+					try: async (): Promise<T> => {
+						const file = Bun.file(path)
+						const exists = await file.exists()
+						if (!exists) {
+							throw new Error(`File not found: ${path}`)
+						}
+						return await file.json()
+					},
+					catch: () => new FileNotFoundError({ path }),
+				}),
+
+			writeJSON: <T = unknown>(path: string, data: T) =>
+				Effect.tryPromise({
+					try: () => Bun.write(path, JSON.stringify(data, null, 2) + "\n"),
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to write JSON file: ${path}`,
+							cause: error,
+						}),
+				}),
+
+			createDirectory: (path: string) =>
+				Effect.tryPromise({
+					try: () => mkdir(path, { recursive: true }),
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to create directory: ${path}`,
+							cause: error,
+						}),
+				}),
+
+			deleteFile: (path: string) =>
+				Effect.tryPromise({
+					try: () => unlink(path),
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to delete file: ${path}`,
+							cause: error,
+						}),
+				}),
+
+			copyFile: (from: string, to: string) =>
+				Effect.tryPromise({
+					try: () => fsCopyFile(from, to),
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to copy file from ${from} to ${to}`,
+							cause: error,
+						}),
+				}),
+
+			deleteDirectory: (path: string) =>
+				pipe(
+					spawnProcess(["rm", "-rf", path]),
+					Effect.flatMap((result) =>
+						result.exitCode === 0
+							? Effect.void
+							: Effect.fail(
+									new FileSystemError({
+										message: `Failed to delete directory: ${path}`,
+										cause: result.stderr,
+									}),
+								),
+					),
+					Effect.mapError(
+						(error) =>
+							new FileSystemError({
+								message: `Failed to delete directory: ${path}`,
+								cause: error,
+							}),
+					),
+				),
+
+			runCommand: (
+				args: readonly string[],
+				options?: {
+					readonly cwd?: string
+					readonly captureOutput?: boolean
+				},
+			) =>
+				pipe(
+					spawnProcess(args, {
+						cwd: options?.cwd,
+						stdout: options?.captureOutput ? "pipe" : "inherit",
+						stderr: "pipe",
+					}),
+					Effect.mapError(
+						(processError) =>
+							new FileSystemError({
+								message: `Failed to run command: ${args.join(" ")}`,
+								cause: processError,
+							}),
+					),
+				),
+
+			/**
+			 * Recursively collect all files in a directory.
+			 * Returns paths relative to the directory (or relativeTo if specified).
+			 */
+			collectFiles: (
+				dirPath: string,
+				options?: {
+					readonly relativeTo?: string
+					readonly exclude?: readonly string[]
+					readonly sort?: boolean
+				},
+			) =>
+				Effect.tryPromise({
+					try: async () => {
+						const { relativeTo, exclude = [], sort = false } = options ?? {}
+						const basePath = relativeTo ?? dirPath
+
+						// Build find command with exclusions
+						const findArgs = ["find", dirPath, "-type", "f"]
+						for (const pattern of exclude) {
+							findArgs.push("!", "-name", pattern)
+						}
+
+						const result = Bun.spawnSync(findArgs, {
+							stdout: "pipe",
+							stderr: "ignore",
+						})
+
+						const output = new TextDecoder().decode(result.stdout)
+						if (!output) {
+							return []
+						}
+
+						const files = output
+							.trim()
+							.split("\n")
+							.filter((f: string) => f.length > 0)
+							.map((file) => file.replace(basePath + "/", ""))
+							.filter((f) => f.length > 0)
+
+						return sort ? files.sort() : files
+					},
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to collect files from ${dirPath}`,
+							cause: error,
+						}),
+				}),
+		}),
+	},
+) {}