@markjaquith/agency 1.11.1 → 2.1.0

package/src/services/MockFilterRepoService.ts

@@ -1,140 +0,0 @@
-import { Effect, Layer } from "effect"
-import { FilterRepoService } from "./FilterRepoService"
-
-/**
- * Captured filter-repo call for verification in tests.
- */
-export interface CapturedFilterRepoCall {
-	gitRoot: string
-	args: readonly string[]
-	env?: Record<string, string>
-	streamOutput?: boolean
-	progressIntervalMs?: number
-}
-
-/**
- * Global state for captured filter-repo calls.
- * Tests can inspect this to verify correct commands were constructed.
- */
-let capturedCalls: CapturedFilterRepoCall[] = []
-
-/**
- * Clear all captured filter-repo calls.
- * Call this in beforeEach() to reset state between tests.
- */
-export function clearCapturedFilterRepoCalls(): void {
-	capturedCalls = []
-}
-
-/**
- * Get all captured filter-repo calls.
- * @returns Array of captured calls
- */
-export function getCapturedFilterRepoCalls(): readonly CapturedFilterRepoCall[] {
-	return capturedCalls
-}
-
-/**
- * Get the last captured filter-repo call.
- * @returns The last captured call, or undefined if none
- */
-export function getLastCapturedFilterRepoCall():
-	| CapturedFilterRepoCall
-	| undefined {
-	return capturedCalls[capturedCalls.length - 1]
-}
-
-/**
- * Mock implementation of FilterRepoService.
- *
- * This mock:
- * - Always returns true for isInstalled()
- * - Captures the arguments passed to run() without executing
- * - Returns a successful result with exit code 0
- *
- * Use getCapturedFilterRepoCalls() to verify the correct commands were constructed.
- */
-export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>()(
-	"FilterRepoService", // Same tag as the real service to replace it
-	{
-		sync: () => ({
-			isInstalled: () => Effect.succeed(true),
-
-			run: (
-				gitRoot: string,
-				args: readonly string[],
-				options?: {
-					readonly env?: Record<string, string>
-					readonly verboseLog?: (message: string) => void
-					readonly streamOutput?: boolean
-					readonly progressIntervalMs?: number
-				},
-			) => {
-				// Capture the call
-				capturedCalls.push({
-					gitRoot,
-					args,
-					env: options?.env,
-					streamOutput: options?.streamOutput,
-					progressIntervalMs: options?.progressIntervalMs,
-				})
-
-				// Return a successful result
-				return Effect.succeed({
-					exitCode: 0,
-					stdout: "",
-					stderr: "",
-				})
-			},
-
-			filterFiles: (
-				gitRoot: string,
-				options: {
-					readonly refs?: string
-					readonly pathsToRemove?: readonly string[]
-					readonly pathRenames?: readonly { from: string; to: string }[]
-					readonly force?: boolean
-				},
-			) => {
-				// Build the args like the real implementation would
-				const args: string[] = []
-
-				if (options.refs) {
-					args.push("--refs", options.refs)
-				}
-
-				if (options.pathsToRemove) {
-					for (const path of options.pathsToRemove) {
-						args.push("--invert-paths", "--path", path)
-					}
-				}
-
-				if (options.pathRenames) {
-					for (const rename of options.pathRenames) {
-						args.push("--path-rename", `${rename.from}:${rename.to}`)
-					}
-				}
-
-				if (options.force) {
-					args.push("--force")
-				}
-
-				args.push("--prune-empty=always")
-
-				// Capture the call
-				capturedCalls.push({
-					gitRoot,
-					args,
-					env: { GIT_CONFIG_GLOBAL: "" },
-				})
-
-				// Return a successful result
-				return Effect.succeed({
-					exitCode: 0,
-					stdout: "",
-					stderr: "",
-				})
-			},
-		}),
-	},
-) {}

package/src/services/OpencodeService.ts

@@ -1,263 +0,0 @@
-import { Effect, Data } from "effect"
-import { parse as parseJsonc, type ParseError } from "jsonc-parser"
-import { FileSystemService } from "./FileSystemService"
-
-// Error types for Opencode operations
-class OpencodeError extends Data.TaggedError("OpencodeError")<{
-	message: string
-	cause?: unknown
-}> {}
-
-interface OpencodeConfig {
-	instructions?: string[]
-	[key: string]: unknown
-}
-
-interface OpencodeFileInfo {
-	extension: "json" | "jsonc"
-	relativePath: string
-}
-
-/**
- * Service for handling opencode.json/opencode.jsonc files
- * with merging capabilities to preserve existing configuration.
- */
-export class OpencodeService extends Effect.Service<OpencodeService>()(
-	"OpencodeService",
-	{
-		sync: () => ({
-			/**
-			 * Detect which opencode config file exists (json or jsonc).
-			 * Checks in order: .opencode/opencode.jsonc, .opencode/opencode.json,
-			 * opencode.jsonc, opencode.json
-			 * Returns the file info if found, null otherwise.
-			 */
-			detectOpencodeFile: (gitRoot: string) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-
-					// Check .opencode directory first
-					const dotOpencodeJsoncPath = `${gitRoot}/.opencode/opencode.jsonc`
-					const dotOpencodeJsoncExists = yield* fs.exists(dotOpencodeJsoncPath)
-					if (dotOpencodeJsoncExists) {
-						return {
-							extension: "jsonc" as const,
-							relativePath: ".opencode/opencode.jsonc",
-						}
-					}
-
-					const dotOpencodeJsonPath = `${gitRoot}/.opencode/opencode.json`
-					const dotOpencodeJsonExists = yield* fs.exists(dotOpencodeJsonPath)
-					if (dotOpencodeJsonExists) {
-						return {
-							extension: "json" as const,
-							relativePath: ".opencode/opencode.json",
-						}
-					}
-
-					// Check for opencode.jsonc in root (takes precedence over opencode.json)
-					const jsoncPath = `${gitRoot}/opencode.jsonc`
-					const jsoncExists = yield* fs.exists(jsoncPath)
-					if (jsoncExists) {
-						return {
-							extension: "jsonc" as const,
-							relativePath: "opencode.jsonc",
-						}
-					}
-
-					// Check for opencode.json in root
-					const jsonPath = `${gitRoot}/opencode.json`
-					const jsonExists = yield* fs.exists(jsonPath)
-					if (jsonExists) {
-						return { extension: "json" as const, relativePath: "opencode.json" }
-					}
-
-					return null
-				}),
-
-			/**
-			 * Parse JSON or JSONC content using jsonc-parser for robust comment handling.
-			 */
-			parseConfig: (content: string, extension: "json" | "jsonc") =>
-				Effect.try({
-					try: () => {
-						if (extension === "jsonc") {
-							// Use jsonc-parser for robust JSONC parsing with comments and trailing commas
-							const errors: ParseError[] = []
-							const result = parseJsonc(content, errors, {
-								allowTrailingComma: true,
-							}) as OpencodeConfig
-
-							// Check if there were any parse errors
-							if (errors.length > 0) {
-								throw new Error(
-									`JSON Parse error: ${errors.map((e) => `Error code ${e.error} at offset ${e.offset}`).join(", ")}`,
-								)
-							}
-
-							return result
-						}
-						return JSON.parse(content) as OpencodeConfig
-					},
-					catch: (error) =>
-						new OpencodeError({
-							message: `Failed to parse opencode.${extension}`,
-							cause: error,
-						}),
-				}),
-
-			/**
-			 * Merge our instructions into an existing opencode config.
-			 * Preserves all existing properties and adds our instructions to the array.
-			 */
-			mergeConfig: (
-				existingConfig: OpencodeConfig,
-				instructionsToAdd: string[],
-			) =>
-				Effect.sync(() => {
-					const merged = { ...existingConfig }
-
-					// Get existing instructions or initialize empty array
-					const existingInstructions = Array.isArray(merged.instructions)
-						? merged.instructions
-						: []
-
-					// Add our instructions, avoiding duplicates
-					const newInstructions = instructionsToAdd.filter(
-						(instruction) => !existingInstructions.includes(instruction),
-					)
-
-					// Update instructions array
-					merged.instructions = [...existingInstructions, ...newInstructions]
-
-					return merged
-				}),
-
-			/**
-			 * Format the config back to string, preserving formatting.
-			 * For JSONC, we use JSON formatting (comments are not preserved).
-			 */
-			formatConfig: (config: OpencodeConfig) =>
-				Effect.sync(() => JSON.stringify(config, null, "\t") + "\n"),
-
-			/**
-			 * Read, merge, and write the opencode config file.
-			 * Returns the relative path of the file that was written.
-			 */
-			mergeOpencodeFile: (gitRoot: string, instructionsToAdd: string[]) =>
-				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-
-					// Detect which file exists
-					const fileInfo = yield* Effect.gen(function* () {
-						const detected = yield* Effect.gen(function* () {
-							// Check .opencode directory first
-							const dotOpencodeJsoncPath = `${gitRoot}/.opencode/opencode.jsonc`
-							const dotOpencodeJsoncExists =
-								yield* fs.exists(dotOpencodeJsoncPath)
-							if (dotOpencodeJsoncExists) {
-								return {
-									extension: "jsonc" as const,
-									relativePath: ".opencode/opencode.jsonc",
-								}
-							}
-
-							const dotOpencodeJsonPath = `${gitRoot}/.opencode/opencode.json`
-							const dotOpencodeJsonExists =
-								yield* fs.exists(dotOpencodeJsonPath)
-							if (dotOpencodeJsonExists) {
-								return {
-									extension: "json" as const,
-									relativePath: ".opencode/opencode.json",
-								}
-							}
-
-							// Check root directory
-							const jsoncPath = `${gitRoot}/opencode.jsonc`
-							const jsoncExists = yield* fs.exists(jsoncPath)
-							if (jsoncExists) {
-								return {
-									extension: "jsonc" as const,
-									relativePath: "opencode.jsonc",
-								}
-							}
-
-							const jsonPath = `${gitRoot}/opencode.json`
-							const jsonExists = yield* fs.exists(jsonPath)
-							if (jsonExists) {
-								return {
-									extension: "json" as const,
-									relativePath: "opencode.json",
-								}
-							}
-
-							return null
-						})
-
-						if (!detected) {
-							return yield* Effect.fail(
-								new OpencodeError({
-									message: "No opencode.json or opencode.jsonc file found",
-								}),
-							)
-						}
-
-						return detected
-					})
-
-					const filepath = `${gitRoot}/${fileInfo.relativePath}`
-
-					// Read existing config
-					const content = yield* fs.readFile(filepath)
-
-					// Parse it
-					const existingConfig = yield* Effect.gen(function* () {
-						if (fileInfo.extension === "jsonc") {
-							const errors: ParseError[] = []
-							const result = parseJsonc(content, errors, {
-								allowTrailingComma: true,
-							}) as OpencodeConfig
-
-							// Check if there were any parse errors
-							if (errors.length > 0) {
-								throw new Error(
-									`JSON Parse error: ${errors.map((e) => `Error code ${e.error} at offset ${e.offset}`).join(", ")}`,
-								)
-							}
-
-							return result
-						}
-						return JSON.parse(content) as OpencodeConfig
-					}).pipe(
-						Effect.catchAll((error) =>
-							Effect.fail(
-								new OpencodeError({
-									message: `Failed to parse ${fileInfo.relativePath}`,
-									cause: error,
-								}),
-							),
-						),
-					)
-
-					// Merge with our instructions
-					const merged = yield* Effect.sync(() => {
-						const result = { ...existingConfig }
-						const existingInstructions = Array.isArray(result.instructions)
-							? result.instructions
-							: []
-						const newInstructions = instructionsToAdd.filter(
-							(instruction) => !existingInstructions.includes(instruction),
-						)
-						result.instructions = [...existingInstructions, ...newInstructions]
-						return result
-					})
-
-					// Format and write back
-					const formattedContent = JSON.stringify(merged, null, "\t") + "\n"
-					yield* fs.writeFile(filepath, formattedContent)
-
-					return fileInfo.relativePath
-				}),
-		}),
-	},
-) {}

package/src/services/PromptService.ts

@@ -1,183 +0,0 @@
-import { Effect, Data } from "effect"
-import { createInterface } from "node:readline"
-import highlight from "../utils/colors"
-
-// Error types for Prompt operations
-class PromptError extends Data.TaggedError("PromptError")<{
-	message: string
-	cause?: unknown
-}> {}
-
-// Prompt Service using Effect.Service pattern
-export class PromptService extends Effect.Service<PromptService>()(
-	"PromptService",
-	{
-		sync: () => ({
-			prompt: (question: string, defaultValue?: string) =>
-				Effect.tryPromise({
-					try: () =>
-						new Promise<string>((resolve) => {
-							const rl = createInterface({
-								input: process.stdin,
-								output: process.stdout,
-							})
-
-							rl.question(question, (answer) => {
-								rl.close()
-								resolve(answer.trim())
-							})
-
-							// If a default value is provided, pre-fill it in the prompt
-							// This allows the user to backspace and delete it
-							if (defaultValue) {
-								rl.write(defaultValue)
-							}
-						}),
-					catch: (error) =>
-						new PromptError({
-							message: "Failed to prompt user for input",
-							cause: error,
-						}),
-				}),
-
-			promptForSelection: (message: string, options: readonly string[]) =>
-				Effect.tryPromise({
-					try: () =>
-						new Promise<string>((resolve, reject) => {
-							console.log(message)
-							options.forEach((option, index) => {
-								console.log(`  ${index + 1}. ${option}`)
-							})
-
-							const rl = createInterface({
-								input: process.stdin,
-								output: process.stdout,
-							})
-
-							rl.question(
-								`\nSelect option (1-${options.length}) or enter custom value: `,
-								(answer) => {
-									rl.close()
-
-									// Check if it's a number selection
-									const selection = parseInt(answer, 10)
-									if (
-										!isNaN(selection) &&
-										selection >= 1 &&
-										selection <= options.length
-									) {
-										const selected = options[selection - 1]
-										if (selected === undefined) {
-											reject(new Error("Invalid selection"))
-											return
-										}
-										resolve(selected)
-										return
-									}
-
-									// Otherwise treat as custom value
-									resolve(answer.trim())
-								},
-							)
-						}),
-					catch: (error) =>
-						new PromptError({
-							message: "Failed to prompt user for selection",
-							cause: error,
-						}),
-				}),
-
-			sanitizeTemplateName: (name: string) =>
-				Effect.sync(() => {
-					// Replace problematic characters with hyphens
-					return name
-						.replace(/[^a-zA-Z0-9_-]/g, "-")
-						.replace(/-+/g, "-")
-						.replace(/^-|-$/g, "")
-						.toLowerCase()
-				}),
-
-			/**
-			 * Prompt user to select a template from a list.
-			 * Returns the selected template name or a new name entered by user.
-			 */
-			promptForTemplate: (
-				templates: readonly string[],
-				options?: {
-					readonly currentTemplate?: string
-					readonly defaultValue?: string
-					readonly allowNew?: boolean
-				},
-			) =>
-				Effect.tryPromise({
-					try: () =>
-						new Promise<string>((resolve, reject) => {
-							const {
-								currentTemplate,
-								defaultValue,
-								allowNew = true,
-							} = options ?? {}
-
-							// Display template list
-							if (templates.length > 0) {
-								console.log("\nAvailable templates:")
-								templates.forEach((t, i) => {
-									const current = t === currentTemplate ? " (current)" : ""
-									console.log(
-										`  ${highlight.value(i + 1)}. ${highlight.template(t)}${current}`,
-									)
-								})
-								console.log("")
-							}
-
-							const rl = createInterface({
-								input: process.stdin,
-								output: process.stdout,
-							})
-
-							const promptText =
-								templates.length > 0
-									? allowNew
-										? `Template name (1-${templates.length}) or enter new name: `
-										: `Template name (or number): `
-									: "Template name: "
-
-							rl.question(promptText, (answer) => {
-								rl.close()
-
-								const trimmed = answer.trim()
-								if (!trimmed) {
-									reject(new Error("Template name is required."))
-									return
-								}
-
-								// Check if answer is a number (template selection)
-								const num = parseInt(trimmed, 10)
-								if (!isNaN(num) && num >= 1 && num <= templates.length) {
-									const selected = templates[num - 1]
-									if (!selected) {
-										reject(new Error("Invalid selection"))
-										return
-									}
-									resolve(selected)
-									return
-								}
-
-								// Otherwise treat as template name
-								resolve(trimmed)
-							})
-
-							// Pre-fill default value if provided
-							if (defaultValue) {
-								rl.write(defaultValue)
-							}
-						}),
-					catch: (error) =>
-						new PromptError({
-							message: "Failed to prompt user for template selection",
-							cause: error,
-						}),
-				}),
-		}),
-	},
-) {}

package/src/services/TemplateService.ts

@@ -1,81 +0,0 @@
-import { Effect, Data } from "effect"
-import { join } from "node:path"
-import {
-	getAgencyConfigDir,
-	getTemplateDir,
-	getTemplatesDir,
-} from "../utils/paths"
-import { FileSystemService } from "./FileSystemService"
-
-// Error types for Template operations
-class TemplateError extends Data.TaggedError("TemplateError")<{
-	message: string
-	cause?: unknown
-}> {}
-
-// Template Service using Effect.Service pattern
-export class TemplateService extends Effect.Service<TemplateService>()(
-	"TemplateService",
-	{
-		sync: () => ({
-			getConfigDir: () => Effect.sync(() => getAgencyConfigDir()),
-
-			getTemplateDir: (templateName: string) =>
-				Effect.sync(() => getTemplateDir(templateName)),
-
-			templateExists: (templateName: string) =>
-				Effect.tryPromise({
-					try: async () => {
-						const templateDir = getTemplateDir(templateName)
-						const file = Bun.file(join(templateDir, "AGENTS.md"))
-						return await file.exists()
-					},
-					catch: () =>
-						new TemplateError({
-							message: `Failed to check if template exists: ${templateName}`,
-						}),
-				}),
-
-			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: () =>
-				Effect.tryPromise({
-					try: async () => {
-						const templatesDir = getTemplatesDir()
-
-						// Check if templates directory exists first
-						const templatesFile = Bun.file(templatesDir)
-						const exists = await templatesFile.exists()
-
-						if (!exists) {
-							// Return empty array if templates directory doesn't exist
-							return [] as readonly string[]
-						}
-
-						const entries = await Array.fromAsync(
-							new Bun.Glob("*/AGENTS.md").scan({ cwd: templatesDir }),
-						)
-
-						// Extract template names from paths like "work/AGENTS.md"
-						const templates = entries
-							.map((entry) => entry.split("/")[0] || "")
-							.filter(Boolean)
-
-						return templates as readonly string[]
-					},
-					catch: () =>
-						new TemplateError({
-							message: "Failed to list templates",
-						}),
-				}),
-		}),
-	},
-) {}

package/src/types/native-exec.d.ts

@@ -1,8 +0,0 @@
-declare module "@triggi/native-exec" {
-	function exec(
-		command: string,
-		env?: NodeJS.ProcessEnv,
-		...args: string[]
-	): void
-	export default exec
-}