@markjaquith/agency 2.73.2 → 3.0.0

package/src/services/VersionControlService.ts

@@ -1,7 +1,5 @@
 import { Data, Effect } from "effect"
 import { FileSystemService } from "./FileSystemService"
-import { WorkbaseService } from "./WorkbaseService"
-import type { VersionControlKind } from "../workbase/version-control"
 
 export interface RegisteredWorkspace {
 	readonly name: string | null
@@ -12,35 +10,20 @@ export interface RegisteredWorkspace {
 	readonly dirty?: boolean
 }
 
-interface PullRequestDefaults {
-	readonly title: string
-	readonly body: string
-}
-
 interface RepositoryInspection {
 	readonly kind: "bare" | "repository"
 	readonly remote: string | null
 }
 
 export interface VersionControlBackend {
-	readonly kind: VersionControlKind
+	readonly kind: "git"
 	readonly cloneRepository: (
 		source: string,
 		destination: string,
 	) => Effect.Effect<void, unknown, any>
-	readonly initializeRepository: (
-		path: string,
-	) => Effect.Effect<void, unknown, any>
 	readonly inspectRepository: (
 		path: string,
 	) => Effect.Effect<RepositoryInspection | null, unknown, any>
-	readonly gitEnvironment: (
-		path: string,
-	) => Effect.Effect<Record<string, string>, unknown, any>
-	readonly pullRequestDefaults: (
-		workspacePath: string,
-		base: string,
-	) => Effect.Effect<PullRequestDefaults | null, unknown, any>
 	readonly listWorkspaces: (
 		repositoryPath: string,
 	) => Effect.Effect<readonly RegisteredWorkspace[], unknown, any>
@@ -54,26 +37,11 @@ export interface VersionControlBackend {
 	readonly workspaceDirty: (
 		workspacePath: string,
 	) => Effect.Effect<boolean | null, unknown, any>
-	readonly createWorkspace: (options: {
-		readonly repositoryPath: string
-		readonly workspacePath: string
-		readonly workspaceName: string
-		readonly revision: string
-		readonly branch?: string
-	}) => Effect.Effect<void, unknown, any>
-	readonly removeWorkspace: (options: {
-		readonly repositoryPath: string
-		readonly workspacePath: string
-		readonly workspaceName: string | null
-	}) => Effect.Effect<void, unknown, any>
 	readonly fetch: (
 		repositoryPath: string,
 		remote?: string,
 		branch?: string,
 	) => Effect.Effect<void, unknown, any>
-	readonly importGitRefs: (
-		repositoryPath: string,
-	) => Effect.Effect<void, unknown, any>
 	readonly push: (
 		workspacePath: string,
 		remote: string,
@@ -210,7 +178,6 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 							),
 						)
 					}),
-				initializeRepository: () => Effect.void,
 				inspectRepository: (path) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -243,8 +210,6 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 								remote === undefined ? null : expandGitUrl(remote, entries),
 						} as const
 					}),
-				gitEnvironment: () => Effect.succeed({}),
-				pullRequestDefaults: () => Effect.succeed(null),
 				listWorkspaces: (repositoryPath) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -299,54 +264,6 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 						)
 						return result.exitCode === 0 ? result.stdout.length > 0 : null
 					}),
-				createWorkspace: (options) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const command = options.branch
-							? [
-									"git",
-									"-C",
-									options.repositoryPath,
-									"worktree",
-									"add",
-									"-b",
-									options.branch,
-									options.workspacePath,
-									options.revision,
-								]
-							: [
-									"git",
-									"-C",
-									options.repositoryPath,
-									"worktree",
-									"add",
-									"--detach",
-									options.workspacePath,
-									options.revision,
-								]
-						yield* requireSuccess(
-							"Failed to create Git worktree",
-							fs.runCommand(command, { captureOutput: true }),
-						)
-					}),
-				removeWorkspace: (options) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to remove Git worktree",
-							fs.runCommand(
-								[
-									"git",
-									"-C",
-									options.repositoryPath,
-									"worktree",
-									"remove",
-									options.workspacePath,
-								],
-								{ captureOutput: true },
-							),
-						)
-					}),
 				fetch: (repositoryPath, remote = "origin", branch) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -365,7 +282,6 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 							),
 						)
 					}),
-				importGitRefs: () => Effect.void,
 				push: (workspacePath, remote, branch) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -422,352 +338,13 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 	},
 ) {}
 
-const jjCommand = (repositoryPath: string, args: readonly string[]) => [
-	"jj",
-	"-R",
-	repositoryPath,
-	"--no-pager",
-	...args,
-]
-
-export class JjVersionControlService extends Effect.Service<JjVersionControlService>()(
-	"JjVersionControlService",
-	{
-		sync: () =>
-			({
-				kind: "jj",
-				cloneRepository: (source, destination) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to clone jj repository",
-							fs.runCommand(
-								[
-									"jj",
-									"git",
-									"clone",
-									"--no-colocate",
-									"--",
-									source,
-									destination,
-								],
-								{ captureOutput: true },
-							),
-						)
-					}),
-				initializeRepository: (path) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						if (yield* fs.exists(`${path}/.jj`)) return
-						yield* requireSuccess(
-							"Failed to initialize jj repository",
-							fs.runCommand(["jj", "git", "init", "--colocate", path], {
-								captureOutput: true,
-							}),
-						)
-					}),
-				inspectRepository: (path) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const root = yield* fs.runCommand(jjCommand(path, ["root"]), {
-							captureOutput: true,
-						})
-						if (root.exitCode !== 0) return null
-						const remote = yield* fs.runCommand(
-							jjCommand(path, ["git", "remote", "list"]),
-							{ captureOutput: true },
-						)
-						return {
-							kind: "repository",
-							remote:
-								remote.exitCode === 0
-									? (remote.stdout
-											.split("\n")
-											.find((line) => line.startsWith("origin "))
-											?.slice("origin ".length)
-											.trim() ?? null)
-									: null,
-						} as const
-					}),
-				gitEnvironment: (path) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* requireSuccess(
-							"Failed to locate jj backing Git repository",
-							fs.runCommand(jjCommand(path, ["git", "root"]), {
-								captureOutput: true,
-							}),
-						)
-						return { GIT_DIR: result.stdout.trim() }
-					}),
-				pullRequestDefaults: (workspacePath, base) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* fs.runCommand(
-							jjCommand(workspacePath, [
-								"log",
-								"--ignore-working-copy",
-								"--no-graph",
-								"-r",
-								`${base}..@-`,
-								"-T",
-								'description.first_line() ++ "\\n"',
-							]),
-							{ captureOutput: true },
-						)
-						if (result.exitCode !== 0) return null
-						const commits = result.stdout
-							.split("\n")
-							.map((line) => line.trim())
-							.filter(Boolean)
-						if (commits.length === 0) return null
-						return {
-							title: commits.at(-1)!,
-							body:
-								commits.length === 1
-									? ""
-									: `Commits:\n${commits
-											.toReversed()
-											.map((commit) => `- ${commit}`)
-											.join("\n")}`,
-						} satisfies PullRequestDefaults
-					}),
-				listWorkspaces: (repositoryPath) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* requireSuccess(
-							"Failed to inspect jj workspaces",
-							fs.runCommand(
-								jjCommand(repositoryPath, [
-									"workspace",
-									"list",
-									"-T",
-									'name ++ "\\t" ++ root ++ "\\t" ++ target.commit_id() ++ "\\t" ++ target.parents().map(|commit| commit.commit_id()).join(",") ++ "\\t" ++ target.empty() ++ "\\n"',
-								]),
-								{ captureOutput: true },
-							),
-						)
-						return result.stdout
-							.trim()
-							.split("\n")
-							.filter(Boolean)
-							.map((line) => {
-								const [name, path, commit, parents, empty] = line.split("\t")
-								const parentCommits = parents?.split(",").filter(Boolean) ?? []
-								return {
-									name: name || null,
-									path: path!,
-									commit: commit || null,
-									branch: null,
-									head:
-										parentCommits.length === 1 ? parentCommits[0]! : undefined,
-									dirty: empty === "false",
-								}
-							})
-					}),
-				resolveRevision: (repositoryPath, revision) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const resolve = () =>
-							fs.runCommand(
-								jjCommand(repositoryPath, [
-									"log",
-									"--ignore-working-copy",
-									"--no-graph",
-									"-r",
-									revision,
-									"-T",
-									'commit_id ++ "\\n"',
-								]),
-								{ captureOutput: true },
-							)
-						let result = yield* resolve()
-						if (result.exitCode !== 0 || !result.stdout.trim()) {
-							const imported = yield* fs.runCommand(
-								jjCommand(repositoryPath, ["git", "import"]),
-								{ captureOutput: true },
-							)
-							if (imported.exitCode === 0) result = yield* resolve()
-						}
-						return result.exitCode === 0 ? result.stdout.trim() || null : null
-					}),
-				workspaceHead: (workspacePath) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* fs.runCommand(
-							jjCommand(workspacePath, [
-								"log",
-								"--ignore-working-copy",
-								"--no-graph",
-								"-r",
-								"@-",
-								"-T",
-								'commit_id ++ "\\n"',
-							]),
-							{ captureOutput: true },
-						)
-						return result.exitCode === 0 ? result.stdout.trim() || null : null
-					}),
-				workspaceDirty: (workspacePath) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* fs.runCommand(
-							jjCommand(workspacePath, ["diff", "--summary", "-r", "@"]),
-							{ captureOutput: true },
-						)
-						return result.exitCode === 0 ? result.stdout.length > 0 : null
-					}),
-				createWorkspace: (options) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to create jj workspace",
-							fs.runCommand(
-								jjCommand(options.repositoryPath, [
-									"workspace",
-									"add",
-									"--name",
-									options.workspaceName,
-									"-r",
-									options.revision,
-									options.workspacePath,
-								]),
-								{ captureOutput: true },
-							),
-						)
-					}),
-				removeWorkspace: (options) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						if (!options.workspaceName) {
-							return yield* new VersionControlError({
-								message: `Cannot remove unregistered jj workspace ${options.workspacePath}`,
-							})
-						}
-						yield* requireSuccess(
-							"Failed to forget jj workspace",
-							fs.runCommand(
-								jjCommand(options.repositoryPath, [
-									"workspace",
-									"forget",
-									options.workspaceName,
-								]),
-								{ captureOutput: true },
-							),
-						)
-						yield* fs.deleteDirectory(options.workspacePath)
-					}),
-				fetch: (repositoryPath, remote = "origin", branch) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to fetch jj repository",
-							fs.runCommand(
-								jjCommand(repositoryPath, [
-									"git",
-									"fetch",
-									"--remote",
-									remote,
-									...(branch ? ["--branch", branch] : []),
-								]),
-								{ captureOutput: true },
-							),
-						)
-					}),
-				importGitRefs: (repositoryPath) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to import Git refs into jj",
-							fs.runCommand(jjCommand(repositoryPath, ["git", "import"]), {
-								captureOutput: true,
-							}),
-						)
-					}),
-				push: (workspacePath, remote, branch) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						yield* requireSuccess(
-							"Failed to set jj delivery bookmark",
-							fs.runCommand(
-								jjCommand(workspacePath, [
-									"bookmark",
-									"set",
-									"--allow-backwards",
-									branch,
-									"-r",
-									"@-",
-								]),
-								{ captureOutput: true },
-							),
-						)
-						yield* requireSuccess(
-							"Failed to push branch",
-							fs.runCommand(
-								jjCommand(workspacePath, [
-									"git",
-									"push",
-									"--remote",
-									remote,
-									"--bookmark",
-									branch,
-								]),
-								{ captureOutput: true },
-							),
-						)
-					}),
-				remoteUrl: (repositoryPath, remote) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const result = yield* fs.runCommand(
-							jjCommand(repositoryPath, ["git", "remote", "list"]),
-							{ captureOutput: true },
-						)
-						if (result.exitCode !== 0) return null
-						return (
-							result.stdout
-								.split("\n")
-								.find((line) => line.startsWith(`${remote} `))
-								?.slice(remote.length + 1)
-								.trim() ?? null
-						)
-					}),
-				setRemoteUrl: (repositoryPath, remote, url) =>
-					Effect.gen(function* () {
-						const fs = yield* FileSystemService
-						const previous = yield* fs.runCommand(
-							jjCommand(repositoryPath, ["git", "remote", "list"]),
-							{ captureOutput: true },
-						)
-						const exists = previous.stdout
-							.split("\n")
-							.some((line) => line.startsWith(`${remote} `))
-						const args =
-							url === null
-								? ["git", "remote", "remove", remote]
-								: ["git", "remote", exists ? "set-url" : "add", remote, url]
-						yield* requireSuccess(
-							`Failed to update jj Git remote '${remote}'`,
-							fs.runCommand(jjCommand(repositoryPath, args), {
-								captureOutput: true,
-							}),
-						)
-					}),
-			}) satisfies VersionControlBackend,
-	},
-) {}
-
 export class VersionControlService extends Effect.Service<VersionControlService>()(
 	"VersionControlService",
 	{
 		sync: () => ({
-			forWorkbase: (root: string) =>
+			forWorkbase: (_root: string) =>
 				Effect.gen(function* () {
-					const workbase = yield* WorkbaseService
-					const git = yield* GitVersionControlService
-					const jj = yield* JjVersionControlService
-					const { config } = yield* workbase.loadConfig(root)
-					return config.vcs === "jj" ? jj : git
+					return yield* GitVersionControlService
 				}),
 		}),
 	},

package/src/services/WorkbaseService.test.ts

@@ -462,26 +462,6 @@ status: done
 		).rejects.toThrow("{worktree}")
 	})
 
-	test("rejects an invalid workspace command template", async () => {
-		await write(
-			root,
-			"agency.json",
-			JSON.stringify({
-				version: 2,
-				vcs: "jj",
-				workspaceCreateCommand: ["tool", "{repo}", "{workspace}", "{name}"],
-			}),
-		)
-
-		await expect(
-			runTestEffect(
-				WorkbaseService.pipe(
-					Effect.flatMap((service) => service.discover(root)),
-				),
-			),
-		).rejects.toThrow("{revision}")
-	})
-
 	test("rejects an unknown post-checkout command placeholder", async () => {
 		await write(
 			root,

package/src/services/WorkbaseService.ts

@@ -21,12 +21,10 @@ import {
 	type WorkbaseRegistration,
 } from "../workbase/schemas"
 import { validateWorktreeCreateCommand } from "../workbase/worktree-command"
-import { validateWorkspaceCreateCommand } from "../workbase/workspace-command"
 import { validatePostCheckoutCommand } from "../workbase/checkout-command"
 import { validateAgents } from "../workbase/agent-command"
 import { findDependencyCycles } from "../workbase/dependency-graph"
 import { validateDelivery } from "../workbase/delivery-command"
-import { preferredVersionControl } from "../workbase/version-control"
 import { documentRevision } from "../workbase/document-revision"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
@@ -247,7 +245,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 						[
 							fs.writeJSON(configPath, {
 								version: 2,
-								vcs: preferredVersionControl(),
+								vcs: "git",
 							}),
 							...["repos", "epics", "tasks"].map((directory) =>
 								fs.createDirectory(join(root, directory)),
@@ -332,21 +330,6 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 										})
 									}
 								}
-								if (decoded.value.workspaceCreateCommand) {
-									try {
-										validateWorkspaceCreateCommand(
-											decoded.value.workspaceCreateCommand,
-										)
-									} catch (cause) {
-										return yield* new WorkbaseConfigError({
-											path: configPath,
-											message:
-												cause instanceof Error
-													? cause.message
-													: "Invalid workspaceCreateCommand",
-										})
-									}
-								}
 								for (const [alias, repository] of Object.entries(
 									decoded.value.repositories ?? {},
 								)) {