@markjaquith/agency 1.11.0 → 2.0.0

package/src/services/AgencyMetadataService.ts

@@ -1,311 +0,0 @@
-import { join, dirname, resolve, relative } from "node:path"
-import { Data, Effect } from "effect"
-import { Schema } from "@effect/schema"
-import { AgencyMetadata } from "../schemas"
-import { FileSystemService } from "./FileSystemService"
-import { GitService } from "./GitService"
-import { expandGlobs } from "../utils/glob"
-
-/**
- * Error type for AgencyMetadata operations
- */
-class AgencyMetadataError extends Data.TaggedError("AgencyMetadataError")<{
-	message: string
-	cause?: unknown
-}> {}
-
-/**
- * Parse and validate agency.json content from a JSON string.
- * Returns null if the content is invalid.
- */
-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)))
-
-/**
- * Resolve symlink targets for a list of files.
- * For each file, if it's a symlink, also adds the target path to the result.
- * This ensures that when filtering files from git history, both the symlink
- * and its target are filtered (important when CLAUDE.md → AGENTS.md, for example).
- */
-const resolveSymlinkTargets = (
-	fs: FileSystemService,
-	gitRoot: string,
-	files: string[],
-) =>
-	Effect.gen(function* () {
-		const result = new Set<string>(files)
-
-		for (const file of files) {
-			const fullPath = join(gitRoot, file)
-			const target = yield* fs.readSymlinkTarget(fullPath)
-
-			if (target) {
-				// The target path could be relative or absolute
-				// If relative, it's relative to the symlink's location
-				// We need to normalize it to be relative to gitRoot
-				let targetPath: string
-				if (target.startsWith("/")) {
-					// Absolute path - make it relative to gitRoot
-					targetPath = relative(gitRoot, target)
-				} else {
-					// Relative path - resolve from the symlink's directory
-					const symlinkDir = dirname(fullPath)
-					const absoluteTarget = resolve(symlinkDir, target)
-					targetPath = relative(gitRoot, absoluteTarget)
-				}
-
-				// Only add if it's within the gitRoot (not escaping the repo)
-				if (!targetPath.startsWith("..")) {
-					result.add(targetPath)
-				}
-			}
-		}
-
-		return Array.from(result)
-	})
-
-/**
- * Service for managing agency.json metadata operations
- */
-export class AgencyMetadataService extends Effect.Service<AgencyMetadataService>()(
-	"AgencyMetadataService",
-	{
-		sync: () => ({
-			/**
-			 * Read agency.json from disk in the repository root.
-			 * Returns null if the file doesn't exist or is invalid.
-			 */
-			readFromDisk: (gitRoot: string) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const metadataPath = join(gitRoot, "agency.json")
-
-					const exists = yield* fs.exists(metadataPath)
-					if (!exists) {
-						return null
-					}
-
-					const content = yield* fs.readFile(metadataPath)
-					return yield* parseAgencyMetadata(content)
-				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
-
-			/**
-			 * Read agency.json from a specific git branch using git show.
-			 * Returns null if the file doesn't exist or is invalid.
-			 */
-			readFromBranch: (gitRoot: string, branch: string) =>
-				Effect.gen(function* () {
-					const git = yield* GitService
-
-					// Try to read agency.json from the branch using git show
-					const content = yield* git.getFileAtRef(
-						gitRoot,
-						branch,
-						"agency.json",
-					)
-
-					if (!content) {
-						return null
-					}
-
-					return yield* parseAgencyMetadata(content)
-				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
-
-			/**
-			 * Write agency.json to disk in the repository root.
-			 */
-			write: (gitRoot: string, metadata: AgencyMetadata) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const metadataPath = join(gitRoot, "agency.json")
-
-					const content = JSON.stringify(metadata, null, 2) + "\n"
-					yield* fs.writeFile(metadataPath, content).pipe(
-						Effect.mapError(
-							(error) =>
-								new AgencyMetadataError({
-									message: `Failed to write agency.json: ${error}`,
-									cause: error,
-								}),
-						),
-					)
-				}),
-
-			/**
-			 * Get list of files to filter during PR/merge operations.
-			 * Always includes TASK.md, AGENCY.md, and agency.json, plus any injectedFiles from metadata.
-			 */
-			getFilesToFilter: (gitRoot: string) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const metadataPath = join(gitRoot, "agency.json")
-
-					const exists = yield* fs.exists(metadataPath)
-					const baseFiles = ["TASK.md", "AGENCY.md", "agency.json"]
-
-					if (!exists) {
-						// Resolve symlinks even for base files
-						return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
-					}
-
-					const content = yield* fs
-						.readFile(metadataPath)
-						.pipe(Effect.catchAll(() => Effect.succeed("")))
-
-					if (!content) {
-						return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
-					}
-
-					const metadata = yield* parseAgencyMetadata(content)
-
-					if (!metadata) {
-						return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
-					}
-
-					// Expand any glob patterns in injectedFiles to actual file paths
-					const expandedFiles = yield* Effect.tryPromise({
-						try: () =>
-							expandGlobs([...baseFiles, ...metadata.injectedFiles], gitRoot),
-						catch: () => new Error("Failed to expand glob patterns"),
-					})
-
-					// Resolve symlinks and add their targets
-					return yield* resolveSymlinkTargets(fs, gitRoot, expandedFiles)
-				}).pipe(
-					Effect.catchAll(() =>
-						Effect.succeed(["TASK.md", "AGENCY.md", "agency.json"]),
-					),
-				),
-
-			/**
-			 * Get the configured base branch from agency.json metadata.
-			 * Returns null if no metadata exists or no base branch is configured.
-			 */
-			getBaseBranch: (gitRoot: string) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const metadataPath = join(gitRoot, "agency.json")
-
-					const exists = yield* fs.exists(metadataPath)
-					if (!exists) {
-						return null
-					}
-
-					const content = yield* fs
-						.readFile(metadataPath)
-						.pipe(Effect.catchAll(() => Effect.succeed("")))
-
-					if (!content) {
-						return null
-					}
-
-					const metadata = yield* parseAgencyMetadata(content)
-					return metadata?.baseBranch || null
-				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
-
-			/**
-			 * Set the base branch in agency.json metadata.
-			 */
-			setBaseBranch: (gitRoot: string, baseBranch: string) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const metadataPath = join(gitRoot, "agency.json")
-
-					const exists = yield* fs.exists(metadataPath).pipe(
-						Effect.mapError(
-							(error) =>
-								new AgencyMetadataError({
-									message: `Failed to check agency.json: ${error}`,
-									cause: error,
-								}),
-						),
-					)
-
-					if (!exists) {
-						return yield* Effect.fail(
-							new AgencyMetadataError({
-								message:
-									"agency.json not found. Please run 'agency task' first to initialize backpack files.",
-							}),
-						)
-					}
-
-					const content = yield* fs.readFile(metadataPath).pipe(
-						Effect.mapError(
-							(error) =>
-								new AgencyMetadataError({
-									message: `Failed to read agency.json: ${error}`,
-									cause: error,
-								}),
-						),
-					)
-
-					const metadata = yield* parseAgencyMetadata(content).pipe(
-						Effect.flatMap((m) =>
-							m
-								? Effect.succeed(m)
-								: Effect.fail(
-										new AgencyMetadataError({
-											message:
-												"agency.json is invalid. Please run 'agency task' first to initialize backpack files.",
-										}),
-									),
-						),
-					)
-
-					// Create a new metadata instance with the updated baseBranch
-					const updatedMetadata = new AgencyMetadata({
-						version: metadata.version,
-						injectedFiles: metadata.injectedFiles,
-						template: metadata.template,
-						createdAt: metadata.createdAt,
-						baseBranch,
-						emitBranch: metadata.emitBranch,
-					})
-
-					const outputContent = JSON.stringify(updatedMetadata, null, 2) + "\n"
-					yield* fs.writeFile(metadataPath, outputContent).pipe(
-						Effect.mapError(
-							(error) =>
-								new AgencyMetadataError({
-									message: `Failed to write agency.json: ${error}`,
-									cause: error,
-								}),
-						),
-					)
-					return void 0
-				}),
-
-			/**
-			 * Parse and validate agency.json content from a JSON string.
-			 * Returns null if the content is invalid.
-			 */
-			parse: parseAgencyMetadata,
-		}),
-	},
-) {}
-
-/**
- * Parse and validate agency.json content from a JSON string.
- * Returns null if the content is invalid.
- * This is exported as a standalone function for convenience since it has no dependencies.
- */
-export { parseAgencyMetadata }

package/src/services/ClaudeService.test.ts

@@ -1,184 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { Effect } from "effect"
-import { join } from "path"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	runTestEffect,
-	fileExists,
-	readFile,
-	createFile,
-} from "../test-utils"
-import { ClaudeService } from "./ClaudeService"
-
-describe("ClaudeService", () => {
-	let tempDir: string
-
-	beforeEach(async () => {
-		tempDir = await createTempDir()
-		await initGitRepo(tempDir)
-	})
-
-	afterEach(async () => {
-		await cleanupTempDir(tempDir)
-	})
-
-	describe("claudeFileExists", () => {
-		test("returns false when CLAUDE.md does not exist", async () => {
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.claudeFileExists(tempDir)
-				}),
-			)
-
-			expect(result).toBe(false)
-		})
-
-		test("returns true when CLAUDE.md exists", async () => {
-			await createFile(tempDir, "CLAUDE.md", "# Claude Code\n")
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.claudeFileExists(tempDir)
-				}),
-			)
-
-			expect(result).toBe(true)
-		})
-	})
-
-	describe("hasAgencySection", () => {
-		test("returns false when content does not have agency section", async () => {
-			const content = "# Claude Code\n\nSome instructions\n"
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.hasAgencySection(content)
-				}),
-			)
-
-			expect(result).toBe(false)
-		})
-
-		test("returns true when content has both @AGENCY.md and @TASK.md", async () => {
-			const content = `# Claude Code
-
-Some instructions
-
-## Agency
-
-@AGENCY.md
-@TASK.md
-`
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.hasAgencySection(content)
-				}),
-			)
-
-			expect(result).toBe(true)
-		})
-	})
-
-	describe("injectAgencySection", () => {
-		test("creates CLAUDE.md with agency section when file does not exist", async () => {
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.injectAgencySection(tempDir)
-				}),
-			)
-
-			expect(result.created).toBe(true)
-			expect(result.modified).toBe(true)
-
-			const claudePath = join(tempDir, "CLAUDE.md")
-			expect(await fileExists(claudePath)).toBe(true)
-
-			const content = await readFile(claudePath)
-			expect(content).toContain("@AGENCY.md")
-			expect(content).toContain("@TASK.md")
-			expect(content.indexOf("@AGENCY.md")).toBeLessThan(
-				content.indexOf("@TASK.md"),
-			)
-		})
-
-		test("appends agency section when file exists without references", async () => {
-			const initialContent = "# Claude Code\n\nSome existing instructions\n"
-			await createFile(tempDir, "CLAUDE.md", initialContent)
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.injectAgencySection(tempDir)
-				}),
-			)
-
-			expect(result.created).toBe(false)
-			expect(result.modified).toBe(true)
-
-			const content = await readFile(join(tempDir, "CLAUDE.md"))
-			expect(content).toContain("Some existing instructions")
-			expect(content).toContain("@AGENCY.md")
-			expect(content).toContain("@TASK.md")
-		})
-
-		test("does not modify file when agency section already exists in correct order", async () => {
-			const contentWithSection = `# Claude Code
-
-Some instructions
-
-## Agency
-
-@AGENCY.md
-@TASK.md
-`
-			await createFile(tempDir, "CLAUDE.md", contentWithSection)
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.injectAgencySection(tempDir)
-				}),
-			)
-
-			expect(result.created).toBe(false)
-			expect(result.modified).toBe(false)
-
-			const content = await readFile(join(tempDir, "CLAUDE.md"))
-			expect(content).toBe(contentWithSection)
-		})
-
-		test("re-adds references when they exist in wrong order", async () => {
-			const contentWithWrongOrder = `# Claude Code
-
-Some instructions
-
-@TASK.md
-@AGENCY.md
-`
-			await createFile(tempDir, "CLAUDE.md", contentWithWrongOrder)
-
-			const result = await runTestEffect(
-				Effect.gen(function* () {
-					const claudeService = yield* ClaudeService
-					return yield* claudeService.injectAgencySection(tempDir)
-				}),
-			)
-
-			expect(result.created).toBe(false)
-			expect(result.modified).toBe(true)
-
-			const content = await readFile(join(tempDir, "CLAUDE.md"))
-			// Should have the section appended with correct order
-			expect(content).toContain("@AGENCY.md")
-			expect(content).toContain("@TASK.md")
-		})
-	})
-})

package/src/services/ClaudeService.ts

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

@@ -1,115 +0,0 @@
-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),
-		}),
-	},
-) {}