@defrex/autobuild 0.8.0

package/packages/core/src/plugins/registry.ts

@@ -0,0 +1,274 @@
+import type {
+  AgentRuntimePluginFactory,
+  AutobuildPluginManifest,
+  ForgePluginFactory,
+  PluginApiCompatibility,
+  PluginContractDescriptor,
+  TicketSourcePluginFactory,
+  WorkspaceProviderPluginFactory,
+} from './manifest'
+import { pluginApiCompatibility } from './manifest'
+import type { AgentRunnerContractFactory } from '../ports/runner/contract'
+import type { TicketSourceContractFactory } from '../ports/tickets/contract'
+import type { WorkspaceProviderContractFactory } from '../ports/workspace/contract'
+import type { ForgeContractFactory } from '../ports/forge/contract'
+
+export type PluginPort = 'ticket-source' | 'agent-runtime' | 'workspace-provider' | 'forge'
+
+export const PLUGIN_PORTS: readonly PluginPort[] = [
+  'ticket-source',
+  'agent-runtime',
+  'workspace-provider',
+  'forge',
+]
+
+export type PluginResolutionKind = 'repo-path' | 'package'
+
+export type RegistrationOwner =
+  | { kind: 'builtin'; name: 'autobuild' }
+  | { kind: 'plugin'; name: string }
+
+export interface ConfiguredPluginSource {
+  kind: 'configured'
+  module: string
+  resolved: string
+  resolutionKind: PluginResolutionKind
+  pluginName: string
+  api: PluginApiCompatibility
+}
+
+export type RegistrationSource = { kind: 'builtin' } | ConfiguredPluginSource
+
+export interface AdapterRegistration<Factory, ContractFactory = unknown> {
+  owner: RegistrationOwner
+  /** Builtins reserve their names while host construction may remain outside
+   * the registry. Plugin registrations always carry a normalized factory for
+   * open selectors to consume lazily. */
+  factory?: Factory
+  /** Host-enforced ticket-source credential declarations. Undefined for
+   * builtins and every other plugin port. */
+  requiredEnv?: readonly string[]
+  contract?: PluginContractDescriptor<ContractFactory>
+  source: RegistrationSource
+}
+
+export interface AdapterProjection {
+  port: PluginPort
+  name: string
+  owner: RegistrationOwner
+  source: RegistrationSource
+  hasContract: boolean
+  live: boolean
+}
+
+const BUILTIN = { kind: 'builtin', name: 'autobuild' } as const
+
+function reserved<Factory, ContractFactory>(
+  names: readonly string[],
+): Map<string, AdapterRegistration<Factory, ContractFactory>> {
+  return new Map(names.map((name) => [name, { owner: BUILTIN, source: { kind: 'builtin' } }]))
+}
+
+export function pluginPortLabel(port: PluginPort): string {
+  switch (port) {
+    case 'ticket-source':
+      return 'ticket source'
+    case 'agent-runtime':
+      return 'agent runtime'
+    case 'workspace-provider':
+      return 'workspace provider'
+    case 'forge':
+      return 'forge'
+  }
+}
+
+function ownerDescription(owner: RegistrationOwner): string {
+  return owner.kind === 'builtin' ? 'builtin adapter' : `plugin "${owner.name}"`
+}
+
+interface PendingRegistration {
+  port: PluginPort
+  name: string
+  factory: unknown
+  requiredEnv?: readonly string[]
+  contract?: PluginContractDescriptor<unknown>
+  target: Map<string, AdapterRegistration<unknown, unknown>>
+}
+
+type InternalRegistration<AdapterFactory, ContractFactory> =
+  | AdapterFactory
+  | {
+      factory: AdapterFactory
+      requiredEnv?: readonly string[]
+      contract?: PluginContractDescriptor<ContractFactory>
+    }
+
+function normalize<AdapterFactory, ContractFactory>(
+  registration: InternalRegistration<AdapterFactory, ContractFactory>,
+): {
+  factory: AdapterFactory
+  requiredEnv?: readonly string[]
+  contract?: PluginContractDescriptor<ContractFactory>
+} {
+  if (typeof registration === 'function') {
+    return { factory: registration as AdapterFactory }
+  }
+  const object = registration as {
+    factory: AdapterFactory
+    requiredEnv?: readonly string[]
+    contract?: PluginContractDescriptor<ContractFactory>
+  }
+  return {
+    factory: object.factory,
+    ...(object.requiredEnv !== undefined ? { requiredEnv: [...object.requiredEnv] } : {}),
+    ...(object.contract !== undefined ? { contract: object.contract } : {}),
+  }
+}
+
+/** Owner-aware catalog populated at startup. Registration is atomic per
+ * plugin: every map and collision is checked before the first write. */
+export class PluginRegistry {
+  readonly ticketSources = reserved<TicketSourcePluginFactory, TicketSourceContractFactory>([
+    'file',
+    'hosted',
+    'linear',
+  ])
+  readonly agentRuntimes = reserved<AgentRuntimePluginFactory, AgentRunnerContractFactory>([
+    'claude',
+    'codex',
+    'pi',
+    // Init's independent author/reviewer arrangement is addressed by this
+    // profile value, so a runtime with the same name could never be selected.
+    'split',
+  ])
+  readonly workspaceProviders = reserved<
+    WorkspaceProviderPluginFactory,
+    WorkspaceProviderContractFactory
+  >(['git-worktree', 'vercel-sandbox'])
+  readonly forges = reserved<ForgePluginFactory, ForgeContractFactory>(['github', 'local-git'])
+
+  register(
+    plugin: AutobuildPluginManifest,
+    configuredSource?: Omit<ConfiguredPluginSource, 'kind' | 'pluginName' | 'api'>,
+  ): void {
+    const source: ConfiguredPluginSource = {
+      kind: 'configured',
+      module: configuredSource?.module ?? '<direct>',
+      resolved: configuredSource?.resolved ?? '<direct>',
+      resolutionKind: configuredSource?.resolutionKind ?? 'repo-path',
+      pluginName: plugin.name,
+      api: pluginApiCompatibility(plugin.apiVersion),
+    }
+    const pending: PendingRegistration[] = []
+    const collect = <AdapterFactory, ContractFactory>(
+      port: PluginPort,
+      registrations:
+        | Record<string, InternalRegistration<AdapterFactory, ContractFactory>>
+        | undefined,
+      target: Map<string, AdapterRegistration<AdapterFactory, ContractFactory>>,
+    ): void => {
+      for (const [name, registration] of Object.entries(registrations ?? {})) {
+        const existing = target.get(name)
+        if (existing !== undefined) {
+          throw new Error(
+            `${pluginPortLabel(port)} adapter "${name}" from plugin "${plugin.name}" collides ` +
+              `with ${ownerDescription(existing.owner)}; choose a unique adapter name`,
+          )
+        }
+        const normalized = normalize(registration)
+        pending.push({
+          port,
+          name,
+          factory: normalized.factory,
+          ...(normalized.requiredEnv !== undefined ? { requiredEnv: normalized.requiredEnv } : {}),
+          ...(normalized.contract !== undefined
+            ? { contract: normalized.contract as PluginContractDescriptor<unknown> }
+            : {}),
+          target: target as Map<string, AdapterRegistration<unknown, unknown>>,
+        })
+      }
+    }
+
+    collect(
+      'ticket-source',
+      plugin.ticketSources as
+        | Record<
+            string,
+            InternalRegistration<TicketSourcePluginFactory, TicketSourceContractFactory>
+          >
+        | undefined,
+      this.ticketSources,
+    )
+    collect('agent-runtime', plugin.agentRuntimes, this.agentRuntimes)
+    collect('workspace-provider', plugin.workspaceProviders, this.workspaceProviders)
+    collect('forge', plugin.forges, this.forges)
+
+    const seen = new Set<string>()
+    for (const registration of pending) {
+      const key = `${registration.port}\0${registration.name}`
+      if (seen.has(key)) {
+        throw new Error(
+          `${pluginPortLabel(registration.port)} adapter "${registration.name}" is registered ` +
+            `more than once by plugin "${plugin.name}"`,
+        )
+      }
+      seen.add(key)
+    }
+
+    for (const registration of pending) {
+      registration.target.set(registration.name, {
+        owner: { kind: 'plugin', name: plugin.name },
+        factory: registration.factory,
+        ...(registration.requiredEnv !== undefined
+          ? { requiredEnv: registration.requiredEnv }
+          : {}),
+        ...(registration.contract !== undefined ? { contract: registration.contract } : {}),
+        source,
+      })
+    }
+  }
+
+  adapters(port?: PluginPort): AdapterProjection[] {
+    const maps: Array<[PluginPort, Map<string, AdapterRegistration<unknown, unknown>>]> = [
+      ['ticket-source', this.ticketSources as Map<string, AdapterRegistration<unknown, unknown>>],
+      ['agent-runtime', this.agentRuntimes as Map<string, AdapterRegistration<unknown, unknown>>],
+      [
+        'workspace-provider',
+        this.workspaceProviders as Map<string, AdapterRegistration<unknown, unknown>>,
+      ],
+      ['forge', this.forges as Map<string, AdapterRegistration<unknown, unknown>>],
+    ]
+    const result: AdapterProjection[] = []
+    for (const [candidate, registrations] of maps) {
+      if (port !== undefined && candidate !== port) continue
+      for (const [name, registration] of registrations) {
+        result.push({
+          port: candidate,
+          name,
+          owner: registration.owner,
+          source: registration.source,
+          hasContract: registration.contract !== undefined,
+          live: registration.contract?.live === true,
+        })
+      }
+    }
+    return result
+  }
+
+  registration(port: PluginPort, name: string): AdapterRegistration<unknown, unknown> | undefined {
+    switch (port) {
+      case 'ticket-source':
+        return this.ticketSources.get(name)
+      case 'agent-runtime':
+        return this.agentRuntimes.get(name)
+      case 'workspace-provider':
+        return this.workspaceProviders.get(name)
+      case 'forge':
+        return this.forges.get(name)
+    }
+  }
+}
+
+export function createPluginRegistry(): PluginRegistry {
+  return new PluginRegistry()
+}

package/packages/core/src/plugins/runtimes.ts

@@ -0,0 +1,75 @@
+import type { PluginFactoryContext } from './manifest'
+import type { PluginRegistry } from './registry'
+import { validateRuntimeRegistration, type RuntimeRegistry } from '../ports/runner/runtime'
+
+export interface MaterializePluginRuntimesOpts {
+  repoRoot: string
+  env: Readonly<Record<string, string | undefined>>
+}
+
+function reason(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * Materialize plugin runtime factories into a fresh registry. Factories run in
+ * plugin registration order and receive the same repository-scoped context as
+ * the other adapter selectors. The caller's registry is never mutated, and a
+ * failure never exposes a partially assembled registry.
+ */
+export async function materializePluginRuntimes(
+  builtins: RuntimeRegistry,
+  plugins: PluginRegistry,
+  opts: MaterializePluginRuntimesOpts,
+): Promise<RuntimeRegistry> {
+  const pluginEntries = [...plugins.agentRuntimes.entries()].filter(
+    (entry) => entry[1].owner.kind === 'plugin',
+  )
+
+  // The normal PluginRegistry reserves shipped names. Keep this independent
+  // preflight for injected/test registries and future composition callers.
+  for (const [name, registration] of pluginEntries) {
+    if (Object.hasOwn(builtins, name)) {
+      throw new Error(
+        `agent runtime "${name}" from plugin "${registration.owner.name}" ` +
+          'collides with an existing runtime registration',
+      )
+    }
+  }
+
+  const merged = Object.assign(Object.create(null) as RuntimeRegistry, builtins)
+  const config = Object.freeze({})
+  const env = Object.freeze({ ...opts.env })
+  const context: PluginFactoryContext = {
+    config,
+    env,
+    repoRoot: opts.repoRoot,
+  }
+
+  for (const [name, adapter] of pluginEntries) {
+    const owner = adapter.owner
+    if (owner.kind !== 'plugin' || adapter.factory === undefined) continue
+
+    let value: unknown
+    try {
+      value = await adapter.factory(context)
+    } catch (error) {
+      throw new Error(
+        `agent runtime "${name}" factory from plugin "${owner.name}" failed: ${reason(error)}`,
+        { cause: error },
+      )
+    }
+
+    try {
+      merged[name] = validateRuntimeRegistration(value)
+    } catch (error) {
+      throw new Error(
+        `agent runtime "${name}" from plugin "${owner.name}" returned an ` +
+          `invalid runtime registration: ${reason(error)}`,
+        { cause: error },
+      )
+    }
+  }
+
+  return merged
+}

package/packages/core/src/ports/forge/contract.ts

@@ -0,0 +1,258 @@
+import { describe, expect, test } from 'bun:test'
+import type { Forge, PrRef } from '../types'
+
+export interface ForgeContractFactoryOptions {
+  /** Install/represent a real merge-blocking gate on the temporary base. */
+  gated?: boolean
+}
+
+/** Fixture controls arrange provider lifecycle that the Forge port does not
+ * expose. Probes are independent of the port call under assertion. */
+export interface ForgeContractControls {
+  remoteHead(branch: string): Promise<string>
+  prepareMergeable(number: number): Promise<void>
+  closePr(number: number): Promise<void>
+  makeConflict(number: number): Promise<void>
+  advanceHead(number: number): Promise<string>
+  nativeAutoMergeEnabled(number: number): Promise<boolean>
+  commentExists(number: number, body: string): Promise<boolean>
+  mergeSha(number: number): Promise<string>
+  trackPr(number: number): Promise<void> | void
+}
+
+export interface ForgeContractHarness {
+  forge: Forge
+  /** Whether this provider exposes a native gated auto-merge setting. Local
+   * forges may support only the universal ungated guarded-squash path. */
+  nativeAutoMerge?: boolean
+  workspacePath: string
+  head: string
+  base: string
+  title: string
+  body: string
+  controls: ForgeContractControls
+  cleanup?: () => Promise<void>
+}
+
+export type ForgeContractFactory = (
+  opts?: ForgeContractFactoryOptions,
+) => Promise<ForgeContractHarness>
+
+async function withForge(
+  factory: ForgeContractFactory,
+  opts: ForgeContractFactoryOptions | undefined,
+  run: (harness: ForgeContractHarness) => Promise<void>,
+): Promise<void> {
+  const harness = await factory(opts)
+  let failure: unknown
+  try {
+    await run(harness)
+  } catch (error) {
+    failure = error
+  }
+
+  try {
+    await harness.cleanup?.()
+  } catch (cleanupError) {
+    if (failure !== undefined) {
+      throw new AggregateError(
+        [failure, cleanupError],
+        'Forge contract assertion and cleanup both failed',
+      )
+    }
+    throw cleanupError
+  }
+  if (failure !== undefined) throw failure
+}
+
+async function pushAndOpen(harness: ForgeContractHarness): Promise<{
+  pr: PrRef
+  remoteHead: string
+}> {
+  await harness.forge.pushBranch(harness.workspacePath, harness.head)
+  const remoteHead = await harness.controls.remoteHead(harness.head)
+  const pr = await harness.forge.openPr({
+    workspacePath: harness.workspacePath,
+    head: harness.head,
+    base: harness.base,
+    title: harness.title,
+    body: harness.body,
+    mergeMessage: `${harness.title}\n\n${harness.body}`,
+  })
+  await harness.controls.trackPr(pr.number)
+  return { pr, remoteHead }
+}
+
+/**
+ * Reusable Forge semantics. Live fixtures manipulate only UUID-namespaced
+ * scratch branches/PRs; fake controls arrange the same states without changing
+ * the expected answers declared here.
+ */
+export function describeForgeContract(name: string, factory: ForgeContractFactory): void {
+  describe(`Forge contract: ${name}`, () => {
+    test('pushBranch publishes the head and openPr returns/adopts the actual PR', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr, remoteHead } = await pushAndOpen(harness)
+        expect(pr.number).toBeGreaterThan(0)
+        expect(pr.url.trim()).not.toBe('')
+        expect(pr.headSha).toBe(remoteHead)
+
+        const retry = await harness.forge.openPr({
+          workspacePath: harness.workspacePath,
+          head: harness.head,
+          base: harness.base,
+          title: `${harness.title} retry must adopt`,
+          body: 'retry body must not create another PR',
+          mergeMessage: 'retry merge message must not replace the original',
+        })
+        expect(retry).toEqual(pr)
+      })
+    })
+
+    test('getPrState discriminates an open mergeable PR', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.prepareMergeable(pr.number)
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'open',
+          mergeable: true,
+        })
+      })
+    })
+
+    test('getPrState discriminates an open conflict', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.makeConflict(pr.number)
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'open',
+          mergeable: false,
+        })
+      })
+    })
+
+    test('getPrState discriminates a closed PR', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.closePr(pr.number)
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'closed',
+        })
+      })
+    })
+
+    test('getPrState discriminates a merged PR with its independently observed landing SHA', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.prepareMergeable(pr.number)
+        const candidate = await harness.forge.setAutoMerge(harness.workspacePath, pr.number, true)
+        expect(candidate).toEqual({ kind: 'ungated', headSha: pr.headSha })
+        await harness.forge.squashMerge(harness.workspacePath, pr.number, pr.headSha)
+        const landingSha = await harness.controls.mergeSha(pr.number)
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'merged',
+          sha: landingSha,
+        })
+      })
+    })
+
+    test('setAutoMerge acknowledges native state and is idempotent', async () => {
+      await withForge(factory, { gated: true }, async (harness) => {
+        if (harness.nativeAutoMerge === false) return
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.prepareMergeable(pr.number)
+        expect(await harness.controls.nativeAutoMergeEnabled(pr.number)).toBe(false)
+
+        expect(await harness.forge.setAutoMerge(harness.workspacePath, pr.number, true)).toEqual({
+          kind: 'applied',
+        })
+        expect(await harness.controls.nativeAutoMergeEnabled(pr.number)).toBe(true)
+
+        expect(await harness.forge.setAutoMerge(harness.workspacePath, pr.number, true)).toEqual({
+          kind: 'applied',
+        })
+        expect(await harness.controls.nativeAutoMergeEnabled(pr.number)).toBe(true)
+
+        expect(await harness.forge.setAutoMerge(harness.workspacePath, pr.number, false)).toEqual({
+          kind: 'applied',
+        })
+        expect(await harness.controls.nativeAutoMergeEnabled(pr.number)).toBe(false)
+      })
+    })
+
+    test('squashMerge rejects a moved head and merges only the matching head', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        await harness.controls.prepareMergeable(pr.number)
+        const inspected = await harness.forge.setAutoMerge(harness.workspacePath, pr.number, true)
+        expect(inspected).toEqual({ kind: 'ungated', headSha: pr.headSha })
+
+        const advancedHead = await harness.controls.advanceHead(pr.number)
+        expect(advancedHead).not.toBe(pr.headSha)
+        await expect(
+          harness.forge.squashMerge(harness.workspacePath, pr.number, pr.headSha),
+        ).rejects.toThrow()
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'open',
+          mergeable: true,
+        })
+
+        const refreshed = await harness.forge.setAutoMerge(harness.workspacePath, pr.number, true)
+        expect(refreshed).toEqual({ kind: 'ungated', headSha: advancedHead })
+        await harness.forge.squashMerge(harness.workspacePath, pr.number, advancedHead)
+        const landingSha = await harness.controls.mergeSha(pr.number)
+        expect(await harness.forge.getPrState(harness.workspacePath, pr.number)).toEqual({
+          state: 'merged',
+          sha: landingSha,
+        })
+      })
+    })
+
+    test('closePr is idempotent and preserves merged PRs', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        expect(harness.forge.closePr).toBeDefined()
+        const { pr } = await pushAndOpen(harness)
+        expect(await harness.forge.closePr!(harness.workspacePath, pr.number)).toEqual({
+          state: 'closed',
+        })
+        expect(await harness.forge.closePr!(harness.workspacePath, pr.number)).toEqual({
+          state: 'closed',
+        })
+
+        const merged = await pushAndOpen(harness)
+        await harness.controls.prepareMergeable(merged.pr.number)
+        const candidate = await harness.forge.setAutoMerge(
+          harness.workspacePath,
+          merged.pr.number,
+          true,
+        )
+        expect(candidate).toEqual({ kind: 'ungated', headSha: merged.pr.headSha })
+        await harness.forge.squashMerge(harness.workspacePath, merged.pr.number, merged.pr.headSha)
+        const sha = await harness.controls.mergeSha(merged.pr.number)
+        expect(await harness.forge.closePr!(harness.workspacePath, merged.pr.number)).toEqual({
+          state: 'merged',
+          sha,
+        })
+      })
+    })
+
+    test('deleteBranch removes the exact published branch and is idempotent', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        expect(harness.forge.deleteBranch).toBeDefined()
+        await harness.forge.pushBranch(harness.workspacePath, harness.head)
+        await harness.forge.deleteBranch!(harness.workspacePath, harness.head)
+        await expect(harness.controls.remoteHead(harness.head)).rejects.toThrow()
+        await harness.forge.deleteBranch!(harness.workspacePath, harness.head)
+      })
+    })
+
+    test('commentOnPr delivers the exact unique body', async () => {
+      await withForge(factory, undefined, async (harness) => {
+        const { pr } = await pushAndOpen(harness)
+        const body = `Autobuild forge contract comment ${crypto.randomUUID()}`
+        await harness.forge.commentOnPr(harness.workspacePath, pr.number, body)
+        expect(await harness.controls.commentExists(pr.number, body)).toBe(true)
+      })
+    })
+  })
+}

package/packages/core/src/ports/forge/create.ts

@@ -0,0 +1,74 @@
+import { resolve } from 'node:path'
+import type { PluginFactoryContext } from '../../plugins/manifest'
+import type { AdapterRegistration, PluginRegistry } from '../../plugins/registry'
+import type { Forge } from '../types'
+import { GitHubForge } from './github'
+import { LocalGitForge } from './local-git'
+
+const EMPTY_CONFIG: Readonly<Record<string, unknown>> = Object.freeze({})
+
+function reason(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/** Resolve a forge selector without constructing the adapter. Composition
+ * boundaries use this before opening stores or invoking injectable wiring. */
+export function resolveForgeRegistration(
+  name: string,
+  registry: PluginRegistry,
+): AdapterRegistration<(context: PluginFactoryContext) => Forge | Promise<Forge>> {
+  const registration = registry.forges.get(name)
+  if (registration !== undefined) return registration
+
+  const available = [...registry.forges.keys()].sort()
+  throw new Error(
+    `unknown forge adapter ${JSON.stringify(name)}; available forges: ${available.join(', ')}`,
+  )
+}
+
+/** Construct the configured Forge lazily from the validated startup catalog.
+ * The selected object is returned by identity so optional capabilities such as
+ * `prAttachments` remain authoritative. */
+export async function createForge(opts: {
+  name: string
+  registry: PluginRegistry
+  env: Readonly<Record<string, string | undefined>>
+  repoRoot: string
+  /** Explicit repository identity (normalized origin). Origin-mode dispatch
+   * passes it so the builtin GitHub forge never probes a local checkout. */
+  repository?: string
+}): Promise<Forge> {
+  const registration = resolveForgeRegistration(opts.name, opts.registry)
+  if (registration.owner.kind === 'builtin') {
+    if (opts.name === 'github') {
+      return new GitHubForge({
+        env: opts.env,
+        repoRoot: opts.repoRoot,
+        ...(opts.repository !== undefined ? { repository: opts.repository } : {}),
+      })
+    }
+    if (opts.name === 'local-git') return new LocalGitForge()
+    throw new Error(`builtin forge adapter ${JSON.stringify(opts.name)} has no constructor`)
+  }
+
+  if (registration.factory === undefined) {
+    throw new Error(
+      `forge adapter ${JSON.stringify(opts.name)} from plugin ` +
+        `${JSON.stringify(registration.owner.name)} has no factory`,
+    )
+  }
+
+  try {
+    return await registration.factory({
+      config: EMPTY_CONFIG,
+      env: opts.env,
+      repoRoot: resolve(opts.repoRoot),
+    })
+  } catch (error) {
+    throw new Error(
+      `forge adapter ${JSON.stringify(opts.name)} from plugin ` +
+        `${JSON.stringify(registration.owner.name)} failed to initialize: ${reason(error)}`,
+      { cause: error },
+    )
+  }
+}