@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/status.ts

@@ -1,232 +1,43 @@
-import { Effect, DateTime } from "effect"
-import { join } from "node:path"
+import { Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
-import { ConfigService } from "../services/ConfigService"
-import { FileSystemService } from "../services/FileSystemService"
-import {
-	AgencyMetadataService,
-	parseAgencyMetadata,
-} from "../services/AgencyMetadataService"
-import { resolveBranchPairWithAgencyJson } from "../utils/pr-branch"
-import highlight, { plural } from "../utils/colors"
-import { createLoggers, ensureGitRepo, getTemplateName } from "../utils/effect"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { RepositoryService } from "../services/RepositoryService"
+import { createLoggers } from "../utils/effect"
 
 interface StatusOptions extends BaseCommandOptions {
-	json?: boolean
+	readonly json?: boolean
 }
 
-/**
- * Branch type for status output
- */
-type BranchType = "source" | "emit" | "neither"
-
-/**
- * Base files that are always in the backpack
- */
-const BASE_BACKPACK_FILES = ["TASK.md", "AGENCY.md", "agency.json"]
-
-/**
- * Status data structure returned by the status command
- */
-interface StatusData {
-	initialized: boolean
-	branchType: BranchType
-	currentBranch: string
-	sourceBranch: string | null
-	emitBranch: string | null
-	correspondingBranchExists: boolean
-	template: string | null
-	managedFiles: string[]
-	baseBranch: string | null
-	createdAt: string | null
-}
-
-/**
- * Read agency.json metadata from the current working directory.
- */
-const readAgencyMetadataFromDisk = (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 metadata from a specific branch using git show.
- */
-const readAgencyMetadataFromBranch = (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)))
-
 export const status = (options: StatusOptions = {}) =>
 	Effect.gen(function* () {
-		const { json = false } = options
+		const workbase = yield* WorkbaseService
+		const repositories = yield* RepositoryService
 		const { log } = createLoggers(options)
-
-		const git = yield* GitService
-		const configService = yield* ConfigService
-
-		const gitRoot = yield* ensureGitRepo()
-
-		// Load config for emit branch pattern
-		const config = yield* configService.loadConfig()
-
-		// Get current branch
-		const currentBranch = yield* git.getCurrentBranch(gitRoot)
-
-		// Resolve branch pair to determine if we're on source or emit branch
-		const branches = yield* resolveBranchPairWithAgencyJson(
-			gitRoot,
-			currentBranch,
-			config.sourceBranchPattern,
-			config.emitBranch,
-		)
-		const { sourceBranch, emitBranch, isOnEmitBranch } = branches
-
-		// Check if agency is initialized
-		// If on emit branch, read agency.json from source branch; otherwise read from disk
-		const metadata = isOnEmitBranch
-			? yield* readAgencyMetadataFromBranch(gitRoot, sourceBranch)
-			: yield* readAgencyMetadataFromDisk(gitRoot)
-		const initialized = metadata !== null
-
-		// Determine branch type
-		let branchType: BranchType = "neither"
-		if (initialized) {
-			branchType = isOnEmitBranch ? "emit" : "source"
+		const cwd = options.cwd ?? process.cwd()
+		const report = yield* workbase.validate(cwd)
+		const repos = yield* repositories.list(report.root)
+		const data = { ...report, repositories: repos }
+
+		if (options.json) {
+			log(JSON.stringify(data, null, 2))
+			return
 		}
 
-		// Check if the corresponding branch exists
-		const correspondingBranch = isOnEmitBranch ? sourceBranch : emitBranch
-		const correspondingBranchExists = yield* git.branchExists(
-			gitRoot,
-			correspondingBranch,
+		log(`Workbase: ${report.root}`)
+		log(`Repositories: ${repos.length}`)
+		log(`Epics: ${report.epicCount}`)
+		log(`Tasks: ${report.taskCount}`)
+		log(`Phases: ${report.phaseCount}`)
+		log(
+			`Validation: ${report.valid ? "valid" : `${report.issues.length} issues`}`,
 		)
-
-		// Get template name from git config
-		const template = yield* getTemplateName(gitRoot)
-
-		// Build the complete backpack (all files carried in/out)
-		const backpackFiles = metadata
-			? [...BASE_BACKPACK_FILES, ...metadata.injectedFiles]
-			: []
-
-		// Build status data
-		const statusData: StatusData = {
-			initialized,
-			branchType,
-			currentBranch,
-			sourceBranch: isOnEmitBranch ? sourceBranch : currentBranch,
-			emitBranch: isOnEmitBranch ? currentBranch : emitBranch,
-			correspondingBranchExists,
-			template,
-			managedFiles: backpackFiles,
-			baseBranch: metadata?.baseBranch ?? null,
-			createdAt: metadata?.createdAt
-				? DateTime.toDateUtc(metadata.createdAt).toISOString()
-				: null,
-		}
-
-		if (json) {
-			// Output JSON format
-			log(JSON.stringify(statusData, null, 2))
-		} else {
-			// Output human-readable format with highlighting
-			log("")
-
-			if (!initialized) {
-				// Not initialized - show minimal info
-				log(
-					`Not initialized (run ${highlight.value("agency task")} to initialize)`,
-				)
-				log(`Current branch: ${highlight.branch(currentBranch)}`)
-				if (template) {
-					log(`Template: ${highlight.template(template)}`)
-				}
-			} else {
-				// Initialized - show full status
-				log(`Current branch: ${highlight.branch(currentBranch)}`)
-
-				// Branch type
-				const branchTypeDisplay = isOnEmitBranch
-					? "Emit branch"
-					: "Source branch"
-				log(`Branch type: ${branchTypeDisplay}`)
-
-				// Show corresponding branch only if it exists
-				if (correspondingBranchExists) {
-					if (isOnEmitBranch) {
-						log(`Source branch: ${highlight.branch(statusData.sourceBranch!)}`)
-					} else {
-						log(`Emit branch: ${highlight.branch(statusData.emitBranch!)}`)
-					}
-				}
-
-				// Template
-				if (template) {
-					log(`Template: ${highlight.template(template)}`)
-				}
-
-				// Base branch
-				if (metadata?.baseBranch) {
-					log(`Base branch: ${highlight.branch(metadata.baseBranch)}`)
-				}
-
-				// Backpack (files carried into the job and will leave with)
-				if (backpackFiles.length > 0) {
-					log(`Backpack:`)
-					for (const file of backpackFiles) {
-						log(`  ${highlight.file(file)}`)
-					}
-				}
-
-				// Created at
-				if (metadata?.createdAt) {
-					const date = DateTime.toDateUtc(metadata.createdAt)
-					log(`Created: ${date.toLocaleString()}`)
-				}
-			}
-
-			log("")
-		}
 	})
 
 export const help = `
 Usage: agency status [options]
 
-Display the current status of the agency setup in this repository.
-
-Information shown:
-  - Whether agency is initialized (agency.json exists)
-  - Current branch and branch type (source, emit, or neither)
-  - Source and emit branch names
-  - Whether the corresponding branch exists
-  - Configured template name
-  - Backpack (files carried in and filtered during emit)
-  - Base branch and creation timestamp
+Show workbase repository, entity, and validation status.
 
 Options:
-  --json              Output status as JSON for scripting
-
-Example:
-  agency status                  # Show human-readable status
-  agency status --json           # Output as JSON
+  --json              Output status as JSON
 `

package/src/commands/task-phase.test.ts

@@ -0,0 +1,206 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import {
+	captureLogs,
+	cleanupTempDir,
+	createTempDir,
+	runTestEffect,
+} from "../test-utils"
+import { phase } from "./phase"
+import { task } from "./task"
+
+describe("task and phase command JSON output", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos/agency"), { recursive: true })
+		await runTestEffect(
+			task({
+				subcommand: "create",
+				args: ["multi"],
+				ticketUrl: "https://example.com/task",
+				multiPhase: true,
+				cwd: root,
+				silent: true,
+			}),
+		)
+		await runTestEffect(
+			phase({
+				subcommand: "create",
+				args: ["multi", "first"],
+				repo: "agency",
+				branch: "task/first",
+				base: "main",
+				cwd: root,
+				silent: true,
+			}),
+		)
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("lists and shows task metadata without Markdown content", async () => {
+		const listLogs = await captureLogs(() =>
+			runTestEffect(
+				task({ subcommand: "list", args: [], cwd: root, json: true }),
+			),
+		)
+		expect(JSON.parse(listLogs[0]!)).toEqual([
+			{
+				id: "multi",
+				path: join(root, "tasks/multi/TASK.md"),
+				data: {
+					ticketUrl: "https://example.com/task",
+					phases: [{ id: "first" }],
+				},
+			},
+		])
+
+		const showLogs = await captureLogs(() =>
+			runTestEffect(
+				task({
+					subcommand: "show",
+					args: ["multi"],
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(showLogs[0]!)).toEqual({
+			id: "multi",
+			path: join(root, "tasks/multi/TASK.md"),
+			data: {
+				ticketUrl: "https://example.com/task",
+				phases: [{ id: "first" }],
+			},
+		})
+	})
+
+	test("lists and shows phase metadata without Markdown content", async () => {
+		const listLogs = await captureLogs(() =>
+			runTestEffect(
+				phase({ subcommand: "list", args: ["multi"], cwd: root, json: true }),
+			),
+		)
+		expect(JSON.parse(listLogs[0]!)).toEqual([
+			{
+				taskId: "multi",
+				id: "first",
+				path: join(root, "tasks/multi/phases/first/PHASE.md"),
+				data: {
+					repo: "agency",
+					branch: "task/first",
+					base: "main",
+					pr: null,
+				},
+			},
+		])
+
+		const showLogs = await captureLogs(() =>
+			runTestEffect(
+				phase({
+					subcommand: "show",
+					args: ["multi", "first"],
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(showLogs[0]!)).toEqual({
+			taskId: "multi",
+			id: "first",
+			path: join(root, "tasks/multi/phases/first/PHASE.md"),
+			data: {
+				repo: "agency",
+				branch: "task/first",
+				base: "main",
+				pr: null,
+			},
+		})
+	})
+
+	test("outputs created task and phase records as JSON", async () => {
+		const taskLogs = await captureLogs(() =>
+			runTestEffect(
+				task({
+					subcommand: "create",
+					args: ["another"],
+					ticketUrl: "https://example.com/another",
+					multiPhase: true,
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(taskLogs[0]!)).toMatchObject({
+			id: "another",
+			data: { ticketUrl: "https://example.com/another", phases: [] },
+		})
+
+		const phaseLogs = await captureLogs(() =>
+			runTestEffect(
+				phase({
+					subcommand: "create",
+					args: ["another", "first"],
+					repo: "agency",
+					branch: "task/another-first",
+					base: "main",
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(phaseLogs[0]!)).toMatchObject({
+			taskId: "another",
+			id: "first",
+			data: { repo: "agency", branch: "task/another-first", base: "main" },
+		})
+	})
+
+	test("converts a single-phase task with an explicit first phase ID", async () => {
+		await runTestEffect(
+			task({
+				subcommand: "create",
+				args: ["single"],
+				ticketUrl: "https://example.com/single",
+				repo: "agency",
+				branch: "task/single",
+				base: "main",
+				cwd: root,
+				silent: true,
+			}),
+		)
+
+		await runTestEffect(
+			phase({
+				subcommand: "create",
+				args: ["single", "follow-up"],
+				firstPhase: "implementation",
+				repo: "agency",
+				branch: "task/follow-up",
+				base: "main",
+				dependsOn: ["implementation"],
+				cwd: root,
+				silent: true,
+			}),
+		)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(
+				task({
+					subcommand: "show",
+					args: ["single"],
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(logs[0]!).data.phases).toEqual([
+			{ id: "implementation" },
+			{ id: "follow-up", dependsOn: ["implementation"] },
+		])
+	})
+})