@markjaquith/agency 0.5.0

package/src/services/OpencodeService.ts

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

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

@@ -0,0 +1,75 @@
+import { Effect, Data } from "effect"
+import { join } from "node:path"
+import {
+	getAgencyConfigDir,
+	getTemplateDir,
+	getTemplatesDir,
+} from "../utils/paths"
+
+// 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.sync(() => {
+					// Directory creation is handled by FileSystemService.createDirectory
+				}),
+
+			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",
+						}),
+				}),
+		}),
+	},
+) {}