@markjaquith/agency 1.11.0 → 2.0.0

package/src/commands/init.ts

@@ -1,140 +1,32 @@
-import { basename } from "path"
 import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { PromptService } from "../services/PromptService"
-import { TemplateService } from "../services/TemplateService"
-import highlight, { done } from "../utils/colors"
-import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { createLoggers } from "../utils/effect"
 
 interface InitOptions extends BaseCommandOptions {
-	template?: string
+	readonly path?: string
 }
 
 export const init = (options: InitOptions = {}) =>
 	Effect.gen(function* () {
-		const { silent = false, cwd } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const promptService = yield* PromptService
-		const templateService = yield* TemplateService
-
-		const gitRoot = yield* ensureGitRepo(cwd)
-
-		// Check if already initialized
-		const existingTemplate = yield* getTemplateName(gitRoot)
-		if (existingTemplate && !options.template) {
-			return yield* Effect.fail(
-				new Error(
-					`Already initialized with template ${highlight.template(existingTemplate)}.\n` +
-						`To change template, run: agency init --template <name>`,
-				),
-			)
-		}
-
-		let templateName = options.template
-
-		// If template name not provided, show interactive selection
-		if (!templateName) {
-			if (silent) {
-				return yield* Effect.fail(
-					new Error(
-						"Template name required. Use --template flag in silent mode.",
-					),
-				)
-			}
-
-			const existingTemplates = yield* templateService.listTemplates()
-			verboseLog(`Found ${existingTemplates.length} existing templates`)
-
-			// Get current directory name as default suggestion
-			let defaultTemplateName: string | undefined
-			const dirName = basename(gitRoot)
-			const sanitizedDirName =
-				yield* promptService.sanitizeTemplateName(dirName)
-
-			if (sanitizedDirName && !existingTemplates.includes(sanitizedDirName)) {
-				defaultTemplateName = sanitizedDirName
-				verboseLog(`Suggesting default template name: ${defaultTemplateName}`)
-			}
-
-			const selectedName = yield* promptService.promptForTemplate(
-				existingTemplates,
-				{
-					defaultValue: defaultTemplateName,
-					allowNew: true,
-				},
-			)
-
-			// If selected from list, use as-is; otherwise sanitize new name
-			if (existingTemplates.includes(selectedName)) {
-				templateName = selectedName
-			} else {
-				templateName = yield* promptService.sanitizeTemplateName(selectedName)
-			}
-
-			verboseLog(`Selected template: ${templateName}`)
-		}
-
-		if (!templateName) {
-			return yield* Effect.fail(new Error("Template name is required."))
-		}
-
-		// Resolve and save default remote (with smart precedence)
-		const remote = yield* git
-			.resolveRemote(gitRoot)
-			.pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-		if (remote) {
-			yield* git.setRemoteConfig(remote, gitRoot)
-			verboseLog(`Detected and saved remote: ${remote}`)
-		} else {
-			verboseLog("No remote detected - skip remote configuration")
-		}
-
-		// Save template name to git config
-		yield* git.setGitConfig("agency.template", templateName, gitRoot)
-		log(
-			done(
-				`Initialized with template ${highlight.template(templateName)}${existingTemplate && existingTemplate !== templateName ? ` (was ${highlight.template(existingTemplate)})` : ""}`,
-			),
+		const workbase = yield* WorkbaseService
+		const { log } = createLoggers(options)
+		const root = yield* workbase.initialize(
+			options.path ?? options.cwd ?? process.cwd(),
 		)
-
-		// Note: We do NOT create the template directory here
-		// It will be created when the user runs 'agency template save'
-		verboseLog(
-			`Template directory will be created when you save files with 'agency template save'`,
+		log(
+			options.json
+				? JSON.stringify({ root }, null, 2)
+				: `Initialized Agency workbase at ${root}`,
 		)
 	})
 
 export const help = `
-Usage: agency init [options]
+Usage: agency init [path]
 
-Initialize agency for this repository by selecting a template.
-
-This command must be run before using other agency commands like 'agency task'.
-It saves your template selection to .git/config (not committed to the repository).
-
-On first run, you'll be prompted to either:
-  - Select an existing template from your ~/.config/agency/templates/
-  - Create a new template by entering a new name
-
-If no templates exist, the default suggestion is the current directory name.
-
-The template directory itself is only created when you actually save files to it
-using 'agency template save'.
+Initialize an Agency workbase. The current directory is used when path is
+omitted.
 
 Options:
-  -t, --template    Specify template name (skips interactive prompt)
-
-Examples:
-  agency init                    # Interactive template selection
-  agency init --template work    # Set template to 'work'
-
-Notes:
-  - Template name is saved to .git/config (agency.template)
-  - Template directory is NOT created until 'agency template save' is used
-  - To change template later, run 'agency init --template <name>'
-  - Run 'agency task' after initialization to create template files
+  --json              Output the initialized workbase as JSON
 `

package/src/commands/phase.ts

@@ -0,0 +1,120 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { PhaseService } from "../services/PhaseService"
+import { createLoggers } from "../utils/effect"
+import { parseRepositoryReferences } from "../workbase/repository-reference"
+
+interface PhaseOptions extends BaseCommandOptions {
+	readonly subcommand?: string
+	readonly args: readonly string[]
+	readonly description?: string
+	readonly repo?: string
+	readonly references?: readonly string[]
+	readonly branch?: string
+	readonly base?: string
+	readonly dependsOn?: readonly string[]
+	readonly firstPhase?: string
+	readonly json?: boolean
+}
+
+export const phase = (options: PhaseOptions) =>
+	Effect.gen(function* () {
+		const phases = yield* PhaseService
+		const { log } = createLoggers(options)
+		const cwd = options.cwd ?? process.cwd()
+		const [taskId, phaseId] = options.args
+
+		switch (options.subcommand) {
+			case "create": {
+				if (
+					!taskId ||
+					!phaseId ||
+					!options.repo ||
+					!options.branch ||
+					!options.base
+				) {
+					return yield* Effect.fail(
+						new Error(
+							"Usage: agency phase create <task-id> <phase-id> --repo <alias> --branch <name> --base <name>",
+						),
+					)
+				}
+				const record = yield* phases.create(
+					{
+						taskId,
+						id: phaseId,
+						description: options.description,
+						repo: options.repo,
+						repos: parseRepositoryReferences(options.references),
+						branch: options.branch,
+						base: options.base,
+						dependsOn: options.dependsOn,
+						firstPhase: options.firstPhase,
+					},
+					cwd,
+				)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: `Created phase '${record.id}' on task '${record.taskId}'`,
+				)
+				return
+			}
+			case "list": {
+				if (!taskId) return yield* Effect.fail(new Error("Task ID is required"))
+				const records = yield* phases.list(taskId, cwd)
+				if (options.json) {
+					log(
+						JSON.stringify(
+							records.map(({ content: _, ...record }) => record),
+							null,
+							2,
+						),
+					)
+				} else for (const record of records) log(record.id)
+				return
+			}
+			case "show": {
+				if (!taskId || !phaseId) {
+					return yield* Effect.fail(
+						new Error("Task ID and phase ID are required"),
+					)
+				}
+				const record = yield* phases.show(taskId, phaseId, cwd)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: record.content.trimEnd(),
+				)
+				return
+			}
+			default:
+				return yield* Effect.fail(
+					new Error("Subcommand is required. Available: create, list, show"),
+				)
+		}
+	})
+
+export const help = `
+Usage: agency phase <subcommand> <task-id> [phase-id]
+
+Subcommands:
+  create <task> <phase> Create a phase
+  list <task>           List task phases
+  show <task> <phase>   Show a phase
+
+Create options:
+  --description <text>  Short description of the phase
+  --repo <alias>        Writable repository
+  --reference <alias>:<ref>
+                        Read-only repository reference; repeatable
+  --branch <name>       Working branch
+  --base <name>         Base branch
+  --depends-on <id>     Phase dependency; repeatable
+  --first-phase <id>    Existing execution phase ID when converting a task
+
+Options:
+  --json                Output results as JSON
+`

package/src/commands/pr.test.ts

@@ -1,177 +1,26 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { chmod, mkdir } from "node:fs/promises"
-import { join } from "node:path"
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { captureLogs } from "../test-utils"
+import { PullRequestService } from "../services/PullRequestService"
 import { pr } from "./pr"
-import {
-	cleanupTempDir,
-	createBranch,
-	createTempDir,
-	initGitRepo,
-	runTestEffect,
-} from "../test-utils"
-
-const restoreEnv = (key: string, value: string | undefined) => {
-	if (value === undefined) {
-		delete process.env[key]
-		return
-	}
-
-	process.env[key] = value
-}
-
-const readGhArgs = async (recordPath: string): Promise<string[]> => {
-	const file = Bun.file(recordPath)
-
-	if (!(await file.exists())) {
-		return []
-	}
-
-	const content = await file.text()
-	return content.trim().split("\n").filter(Boolean)
-}
 
 describe("pr command", () => {
-	let tempDir: string
-	let recordPath: string
-	let originalCwd: string
-	let originalPath: string | undefined
-	let originalAgencyConfigPath: string | undefined
-	let originalGhArgsFile: string | undefined
-
-	beforeEach(async () => {
-		tempDir = await createTempDir()
-		recordPath = join(tempDir, "gh-args.txt")
-		originalCwd = process.cwd()
-		originalPath = process.env.PATH
-		originalAgencyConfigPath = process.env.AGENCY_CONFIG_PATH
-		originalGhArgsFile = process.env.AGENCY_TEST_GH_ARGS_FILE
-
-		process.chdir(tempDir)
-		process.env.AGENCY_CONFIG_PATH = join(tempDir, "non-existent-config.json")
-		process.env.AGENCY_TEST_GH_ARGS_FILE = recordPath
-
-		const binDir = join(tempDir, "bin")
-		const ghPath = join(binDir, "gh")
-		await mkdir(binDir)
-		await Bun.write(
-			ghPath,
-			`#!/bin/sh
-: > "$AGENCY_TEST_GH_ARGS_FILE"
-for arg in "$@"; do
-	printf '%s\n' "$arg" >> "$AGENCY_TEST_GH_ARGS_FILE"
-done
-`,
-		)
-		await chmod(ghPath, 0o755)
-		process.env.PATH = `${binDir}:${originalPath ?? ""}`
-
-		await initGitRepo(tempDir)
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		restoreEnv("PATH", originalPath)
-		restoreEnv("AGENCY_CONFIG_PATH", originalAgencyConfigPath)
-		restoreEnv("AGENCY_TEST_GH_ARGS_FILE", originalGhArgsFile)
-		await cleanupTempDir(tempDir)
-	})
-
-	test("passes through to gh pr unchanged outside agency context", async () => {
-		await createBranch(tempDir, "feature")
-
-		await runTestEffect(pr({ args: ["status"], silent: false }))
-
-		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
-	})
-
-	test("passes through outside agency context with custom emit pattern", async () => {
-		const configPath = process.env.AGENCY_CONFIG_PATH
-
-		if (!configPath) {
-			throw new Error("AGENCY_CONFIG_PATH is not set")
-		}
-
-		await Bun.write(
-			configPath,
-			JSON.stringify({
-				sourceBranchPattern: "agency--%branch%",
-				emitBranch: "%branch%--PR",
-			}),
+	test("outputs the created pull request URL as JSON", async () => {
+		const url = "https://github.com/markjaquith/agency/pull/123"
+		const logs = await captureLogs(() =>
+			Effect.runPromise(
+				pr({
+					subcommand: "create",
+					taskId: "example",
+					json: true,
+				}).pipe(
+					Effect.provideService(PullRequestService, {
+						create: () => Effect.succeed(url),
+					} as never),
+				) as Effect.Effect<void, unknown, never>,
+			),
 		)
-		await createBranch(tempDir, "feature")
-
-		await runTestEffect(pr({ args: ["status"], silent: false }))
-
-		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
-	})
-
-	test("appends emitted branch in agency context", async () => {
-		await createBranch(tempDir, "agency--feature")
-
-		await runTestEffect(pr({ args: ["view", "--web"], silent: false }))
-
-		expect(await readGhArgs(recordPath)).toEqual([
-			"pr",
-			"view",
-			"--web",
-			"feature",
-		])
-	})
-
-	test("appends emitted branch with gh pr value flags when no selector is provided", async () => {
-		await createBranch(tempDir, "agency--feature")
-
-		await runTestEffect(
-			pr({
-				args: ["view", "--json", "number", "--jq", ".number"],
-				silent: false,
-			}),
-		)
-
-		expect(await readGhArgs(recordPath)).toEqual([
-			"pr",
-			"view",
-			"--json",
-			"number",
-			"--jq",
-			".number",
-			"feature",
-		])
-	})
-
-	test("does not append emitted branch when an explicit selector is provided", async () => {
-		await createBranch(tempDir, "agency--feature")
-
-		await runTestEffect(
-			pr({
-				args: [
-					"view",
-					"123",
-					"--json",
-					"statusCheckRollup",
-					"--jq",
-					".statusCheckRollup[]",
-				],
-				silent: false,
-			}),
-		)
-
-		expect(await readGhArgs(recordPath)).toEqual([
-			"pr",
-			"view",
-			"123",
-			"--json",
-			"statusCheckRollup",
-			"--jq",
-			".statusCheckRollup[]",
-		])
-	})
-
-	test("does not append emitted branch for subcommands without a selector", async () => {
-		await createBranch(tempDir, "agency--feature")
-
-		await runTestEffect(pr({ args: ["status"], silent: false }))
 
-		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
+		expect(JSON.parse(logs[0]!)).toEqual({ url })
 	})
 })

package/src/commands/pr.ts

@@ -1,196 +1,40 @@
 import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { ConfigService } from "../services/ConfigService"
-import { resolveAgencyBranchPairWithAgencyJson } from "../utils/pr-branch"
-import { ensureGitRepo } from "../utils/effect"
+import { PullRequestService } from "../services/PullRequestService"
+import { createLoggers } from "../utils/effect"
 
 interface PrOptions extends BaseCommandOptions {
-	/** Arguments to pass to gh pr (subcommand and flags) */
-	args: string[]
-}
-
-const PR_SUBCOMMANDS_WITH_OPTIONAL_SELECTOR = new Set([
-	"checkout",
-	"checks",
-	"close",
-	"comment",
-	"diff",
-	"edit",
-	"lock",
-	"merge",
-	"ready",
-	"reopen",
-	"review",
-	"unlock",
-	"update-branch",
-	"view",
-])
-
-const GH_PR_FLAGS_WITH_VALUE = new Set([
-	"--add-assignee",
-	"--add-label",
-	"--add-project",
-	"--add-reviewer",
-	"--app",
-	"--assignee",
-	"--author",
-	"--base",
-	"--body",
-	"--body-file",
-	"--head",
-	"--hostname",
-	"--json",
-	"--jq",
-	"--label",
-	"--limit",
-	"--match-head-commit",
-	"--milestone",
-	"--project",
-	"--remove-assignee",
-	"--remove-label",
-	"--remove-project",
-	"--remove-reviewer",
-	"--repo",
-	"--reviewer",
-	"--search",
-	"--state",
-	"--template",
-	"--title",
-])
-
-const GH_PR_SHORT_FLAGS_WITH_VALUE = new Set([
-	"-A",
-	"-B",
-	"-H",
-	"-L",
-	"-R",
-	"-a",
-	"-b",
-	"-l",
-	"-m",
-	"-p",
-	"-q",
-	"-r",
-	"-s",
-	"-t",
-])
-
-const hasExplicitPrSelector = (args: readonly string[]): boolean => {
-	const subcommandArgs = args.slice(1)
-
-	for (let i = 0; i < subcommandArgs.length; i++) {
-		const arg = subcommandArgs[i]
-
-		if (!arg) {
-			continue
-		}
-
-		if (arg === "--") {
-			return subcommandArgs.slice(i + 1).some(Boolean)
-		}
-
-		if (arg.startsWith("--")) {
-			const flagName = arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg
-
-			if (!arg.includes("=") && GH_PR_FLAGS_WITH_VALUE.has(flagName)) {
-				i++
-			}
-
-			continue
-		}
-
-		if (arg.startsWith("-") && arg.length > 1) {
-			if (GH_PR_SHORT_FLAGS_WITH_VALUE.has(arg)) {
-				i++
-			}
-
-			continue
-		}
-
-		return true
-	}
-
-	return false
-}
-
-const shouldAppendEmitBranch = (args: readonly string[]): boolean => {
-	const subcommand = args[0]
-
-	return (
-		typeof subcommand === "string" &&
-		PR_SUBCOMMANDS_WITH_OPTIONAL_SELECTOR.has(subcommand) &&
-		!hasExplicitPrSelector(args)
-	)
+	readonly subcommand?: string
+	readonly taskId?: string
+	readonly phaseId?: string
+	readonly draft?: boolean
 }
 
 export const pr = (options: PrOptions) =>
 	Effect.gen(function* () {
-		const git = yield* GitService
-		const configService = yield* ConfigService
-
-		const gitRoot = yield* ensureGitRepo()
-
-		// Load config
-		const config = yield* configService.loadConfig()
-
-		// Get current branch and resolve the branch pair when agency context exists
-		const currentBranch = yield* git.getCurrentBranch(gitRoot)
-		const branches = yield* resolveAgencyBranchPairWithAgencyJson(
-			gitRoot,
-			currentBranch,
-			config.sourceBranchPattern,
-			config.emitBranch,
-		)
-
-		// Build the gh pr command with the emit branch only when gh accepts a selector.
-		const ghArgs =
-			branches && shouldAppendEmitBranch(options.args)
-				? ["gh", "pr", ...options.args, branches.emitBranch]
-				: ["gh", "pr", ...options.args]
-
-		// Run gh pr with stdio inherited so output goes directly to terminal
-		const exitCode = yield* Effect.tryPromise({
-			try: async () => {
-				const proc = Bun.spawn(ghArgs, {
-					cwd: gitRoot,
-					env: process.env,
-					stdin: "inherit",
-					stdout: "inherit",
-					stderr: "inherit",
-				})
-				return proc.exited
-			},
-			catch: (error) =>
-				new Error(
-					`Failed to run gh pr: ${error instanceof Error ? error.message : String(error)}`,
-				),
-		})
-
-		if (exitCode !== 0) {
+		if (options.subcommand !== "create" || !options.taskId) {
 			return yield* Effect.fail(
-				new Error(`gh pr command exited with code ${exitCode}`),
+				new Error("Usage: agency pr create <task-id> [phase-id]"),
 			)
 		}
+		const pullRequests = yield* PullRequestService
+		const { log } = createLoggers(options)
+		const url = yield* pullRequests.create(
+			options.taskId,
+			options.phaseId,
+			options.draft,
+			options.cwd ?? process.cwd(),
+		)
+		log(options.json ? JSON.stringify({ url }, null, 2) : url)
 	})
 
 export const help = `
-Usage: agency pr <subcommand> [flags]
-
-Wrapper for 'gh pr' that automatically uses the emitted branch in agency context.
-
-For gh pr subcommands that accept a PR selector, this command appends the
-emitted branch name when you do not provide a selector. Outside agency context,
-or when you provide a selector, it passes arguments through to 'gh pr' unchanged.
+Usage: agency pr create <task-id> [phase-id]
 
-Examples:
-  agency pr view --web              # gh pr view --web <emit-branch>
-  agency pr checks                  # gh pr checks <emit-branch>
-  agency pr diff                    # gh pr diff <emit-branch>
+Push the execution branch, create a GitHub pull request, and update its
+task or phase document.
 
-Notes:
-  - Requires gh CLI to be installed and authenticated
-  - Uses source and emit patterns from ~/.config/agency/agency.json
-  - Respects emitBranch field in agency.json when present
-  - Falls through to gh pr unchanged outside agency context
+Options:
+  --draft             Create a draft pull request
+  --json              Output the pull request URL as JSON
 `