@markjaquith/agency 2.74.0 → 3.0.0

package/src/services/push-validation.ts

@@ -1,12 +1,8 @@
 export interface PushCommitMetadata {
 	readonly commitId: string
-	readonly changeId?: string
 	readonly description: string
-	readonly empty: boolean
 	readonly authorName: string
 	readonly authorEmail: string
-	readonly conflict: boolean
-	readonly parents: readonly string[]
 }
 
 export const parseGitCommits = (
@@ -26,10 +22,7 @@ export const parseGitCommits = (
 			return {
 				commitId,
 				description,
-				empty: false,
 				authorName,
 				authorEmail,
-				conflict: false,
-				parents: [],
 			}
 		})

package/src/test-utils.ts

@@ -24,10 +24,8 @@ import { DoctorService } from "./services/DoctorService"
 import { ReviewService } from "./services/ReviewService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
 } from "./services/VersionControlService"
-import { VcsMigrationService } from "./services/VcsMigrationService"
 
 export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 
@@ -38,9 +36,7 @@ const TestLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
-	VcsMigrationService.Default,
 	RepositoryService.Default,
 	EpicService.Default,
 	TaskService.Default,

package/src/workbase/AGENTS.md

@@ -1,8 +1,8 @@
 # Agency Workbase
 
 This directory is an Agency workbase. Epics, tasks, and phases are durable
-Markdown documents; repository aliases and generated Git worktrees or jj
-workspaces provide code access according to the workbase's `vcs` setting.
+Markdown documents; repository aliases and generated Git worktrees provide code
+access.
 
 ## Command Fast Paths
 
@@ -184,9 +184,8 @@ repository's formatting, type checks, build, dead-code checks, and focused tests
 Review and commit the diff according to the repository's instructions.
 
 Use `agency push` from an execution task or phase to validate and publish its
-declared delivery branch or bookmark without creating a pull request. The
-command never authors semantic commit descriptions; resolve its reported change
-IDs and remediation commands before retrying.
+declared delivery branch without creating a pull request. The command never authors semantic commit descriptions;
+resolve its reported commits and remediation commands before retrying.
 
 `agency work` is the human launch flow: it reconciles managed integration,
 selects work, checks readiness, prepares checkouts, marks execution work

package/src/workbase/checkout-command.test.ts

@@ -11,7 +11,7 @@ const variables = {
 	checkoutKind: "reference" as const,
 	requestedRef: "main",
 	base: "",
-	vcs: "jj" as const,
+	vcs: "git" as const,
 	workbaseRoot: "/work",
 	taskId: "example",
 	phaseId: "",

package/src/workbase/checkout-command.ts

@@ -5,7 +5,7 @@ export interface CheckoutCommandVariables {
 	readonly checkoutKind: "writable" | "reference"
 	readonly requestedRef: string
 	readonly base: string
-	readonly vcs: "git" | "jj"
+	readonly vcs: "git"
 	readonly workbaseRoot: string
 	readonly taskId: string
 	readonly phaseId: string

package/src/workbase/delivery-command.test.ts

@@ -32,45 +32,18 @@ describe("delivery commands", () => {
 		})
 	})
 
-	test("adds explicit jj context to the default GitHub create command", () => {
+	test("builds the default GitHub create command", () => {
 		const input = {
 			base: "main",
-			branch: "feat/example",
-			repository: "example/agency",
 			draft: false,
 		} as const
-		expect(
-			resolveGitHubCreateCommand({
-				...input,
-				vcs: "jj",
-				defaults: { title: "Add example", body: "Details" },
-			}),
-		).toEqual({
-			argv: [
-				"gh",
-				"pr",
-				"create",
-				"--title",
-				"Add example",
-				"--body",
-				"Details",
-				"--base",
-				"main",
-				"--head",
-				"feat/example",
-				"--repo",
-				"example/agency",
-			],
-			environment: {},
-		})
-		expect(resolveGitHubCreateCommand({ ...input, vcs: "git" })).toEqual({
+		expect(resolveGitHubCreateCommand(input)).toEqual({
 			argv: ["gh", "pr", "create", "--fill", "--base", "main"],
 			environment: {},
 		})
 		expect(
 			resolveGitHubCreateCommand({
 				...input,
-				vcs: "git",
 				head: "feat/example",
 			}),
 		).toEqual({
@@ -89,9 +62,8 @@ describe("delivery commands", () => {
 		expect(
 			resolveGitHubCreateCommand({
 				...input,
-				vcs: "jj",
-				defaults: { title: "Generated", body: "Details" },
 				title: "Requested",
+				head: "feat/example",
 				labels: ["ai-assisted", "platform"],
 			}),
 		).toEqual({
@@ -99,16 +71,13 @@ describe("delivery commands", () => {
 				"gh",
 				"pr",
 				"create",
+				"--fill",
 				"--title",
 				"Requested",
-				"--body",
-				"Details",
 				"--base",
 				"main",
 				"--head",
 				"feat/example",
-				"--repo",
-				"example/agency",
 				"--label",
 				"ai-assisted",
 				"--label",

package/src/workbase/delivery-command.ts

@@ -20,21 +20,13 @@ export const repositoryFromRemote = (remote: string) =>
 
 export const resolveGitHubCreateCommand = ({
 	base,
-	branch,
-	repository,
 	draft,
-	vcs,
-	defaults,
 	title,
 	head,
 	labels = [],
 }: {
 	readonly base: string
-	readonly branch: string
-	readonly repository: string
 	readonly draft: boolean
-	readonly vcs: "git" | "jj"
-	readonly defaults?: { readonly title: string; readonly body: string }
 	readonly title?: string
 	readonly head?: string
 	readonly labels?: readonly string[]
@@ -43,15 +35,10 @@ export const resolveGitHubCreateCommand = ({
 		"gh",
 		"pr",
 		"create",
-		...(defaults
-			? ["--title", title ?? defaults.title, "--body", defaults.body]
-			: title
-				? ["--fill", "--title", title]
-				: ["--fill"]),
+		...(title ? ["--fill", "--title", title] : ["--fill"]),
 		"--base",
 		base,
-		...(vcs === "jj" || head ? ["--head", head ?? branch] : []),
-		...(vcs === "jj" ? ["--repo", repository] : []),
+		...(head ? ["--head", head] : []),
 		...(draft ? ["--draft"] : []),
 		...labels.flatMap((label) => ["--label", label]),
 	],

package/src/workbase/schemas.test.ts

@@ -257,25 +257,6 @@ describe("repository post-checkout configuration", () => {
 	})
 })
 
-describe("workspace creation configuration", () => {
-	test("accepts a jj workspace argv command", () => {
-		const config = Schema.decodeUnknownSync(WorkbaseConfig)({
-			version: 2,
-			vcs: "jj",
-			workspaceCreateCommand: [
-				"prewarm",
-				"adopt",
-				"{repo}",
-				"{workspace}",
-				"{name}",
-				"{revision}",
-			],
-		})
-
-		expect(config.workspaceCreateCommand?.[0]).toBe("prewarm")
-	})
-})
-
 describe("agent configuration", () => {
 	test("accepts named argv commands with resume commands and environment", () => {
 		const config = Schema.decodeUnknownSync(WorkbaseConfig)({

package/src/workbase/schemas.ts

@@ -103,13 +103,12 @@ const DeliveryProvider = Schema.Struct({
 
 export const WorkbaseConfig = Schema.Struct({
 	version: Schema.Literal(2),
-	vcs: Schema.optional(Schema.Literal("git", "jj")),
+	vcs: Schema.optional(Schema.Literal("git")),
 	repositories: Schema.optional(
 		Schema.Record({ key: RepositoryAlias, value: RepositoryDeclaration }),
 	),
 	chooserCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 	worktreeCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
-	workspaceCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 	agents: Schema.optional(
 		Schema.Record({
 			key: EntityId,

package/src/commands/vcs.test.ts

@@ -1,75 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { vcs } from "./vcs"
-
-describe("vcs command", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(
-			`${root}/agency.json`,
-			JSON.stringify({ version: 2, vcs: "git" }),
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("reports structured backend status", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(vcs({ subcommand: "status", cwd: root, json: true })),
-		)
-		expect(JSON.parse(logs[0]!)).toMatchObject({
-			root,
-			configured: "git",
-			source: "git",
-			target: "git",
-			workspaceCount: 0,
-			blockers: [],
-		})
-	})
-
-	test("persists the inferred Git backend for a legacy workbase", async () => {
-		await Bun.write(`${root}/agency.json`, JSON.stringify({ version: 2 }))
-		await captureLogs(() =>
-			runTestEffect(
-				vcs({
-					subcommand: "migrate",
-					target: "git",
-					cwd: root,
-					apply: true,
-					json: true,
-				}),
-			),
-		)
-		expect(await Bun.file(`${root}/agency.json`).json()).toEqual({
-			version: 2,
-			vcs: "git",
-		})
-	})
-
-	test("treats migration to the configured backend as a no-op", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				vcs({
-					subcommand: "migrate",
-					target: "git",
-					cwd: root,
-					apply: true,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(logs[0]!)).toMatchObject({
-			source: "git",
-			target: "git",
-			mode: "apply",
-			actions: [],
-		})
-	})
-})

package/src/commands/vcs.ts

@@ -1,72 +0,0 @@
-import { Effect } from "effect"
-import { VcsMigrationService } from "../services/VcsMigrationService"
-import type { BaseCommandOptions } from "../utils/command"
-import { createLoggers } from "../utils/effect"
-
-interface VcsOptions extends BaseCommandOptions {
-	readonly subcommand?: string
-	readonly target?: string
-	readonly apply?: boolean
-}
-
-export const vcs = (options: VcsOptions = {}) =>
-	Effect.gen(function* () {
-		const migrations = yield* VcsMigrationService
-		const { log } = createLoggers(options)
-		const root = options.cwd ?? process.cwd()
-		if (options.subcommand === "status") {
-			const status = yield* migrations.status(root)
-			if (options.json) return log(JSON.stringify(status, null, 2))
-			log(
-				`Version control: ${status.source}${status.configured ? "" : " (inferred for legacy workbase)"}`,
-			)
-			log(
-				`Tools: git=${status.available.git ? "available" : "missing"} jj=${status.available.jj ? "available" : "missing"}`,
-			)
-			log(
-				`Repositories: ${status.repositories.length}; managed workspaces: ${status.workspaceCount}; blockers: ${status.blockers.length}`,
-			)
-			for (const blocker of status.blockers)
-				log(`blocker ${blocker.kind} ${blocker.target}: ${blocker.message}`)
-			return
-		}
-		if (options.subcommand === "migrate") {
-			if (options.target !== "git" && options.target !== "jj") {
-				return yield* Effect.fail(
-					new Error("VCS migration target must be 'git' or 'jj'"),
-				)
-			}
-			const result = yield* migrations.migrate(options.target, root, {
-				apply: options.apply,
-			})
-			if (options.json) return log(JSON.stringify(result, null, 2))
-			log(
-				result.mode === "apply"
-					? `Migrated workbase to ${options.target}`
-					: `Migration plan: ${result.source} -> ${options.target}`,
-			)
-			for (const action of result.actions) log(`- ${action}`)
-			if (result.mode === "dry-run" && result.actions.length > 0)
-				log("Run again with --apply to perform the migration.")
-			return
-		}
-		return yield* Effect.fail(
-			new Error(`Unknown vcs subcommand '${options.subcommand ?? ""}'`),
-		)
-	})
-
-export const help = `
-Usage: agency vcs <status|migrate>
-
-Inspect or migrate the workbase-wide version-control backend.
-
-Commands:
-  status                         Show the configured backend, tools, repositories, and blockers
-  migrate <git|jj> [--dry-run | --apply]
-                                 Preview or apply a clean, transactional backend migration
-
-Options:
-  --apply              Apply the migration; omission performs a dry run
-  --dry-run            Explicitly preview the migration without applying it
-  --json               Print structured output
-`