@guiho/mirror 3.0.0-alpha.4

package/source/errors.ts

@@ -0,0 +1,17 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+
+export class MirrorError extends Error {
+  readonly exitCode: number
+
+  constructor(message: string, exitCode = 1) {
+    super(message)
+    this.name = 'MirrorError'
+    this.exitCode = exitCode
+  }
+}
+
+export const invariant = (condition: unknown, message: string): asserts condition => {
+  if (!condition) throw new MirrorError(message)
+}

package/source/executor.ts

@@ -0,0 +1,39 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+
+import type { MirrorCliOptions, MirrorExecutionResult } from './types'
+import { MirrorError } from './errors'
+import { createGitCommit, createGitTag, isGitDirty, isGitRepository, pushGitRefs, writeJsrVersion, writePackageVersion } from './adapters'
+import { loadMirrorConfig } from './config'
+import { buildVersionPlan } from './plan'
+
+export const applyVersionPlan = async (target: string, options: MirrorCliOptions = {}): Promise<MirrorExecutionResult> => {
+  const plan = await buildVersionPlan(target, options)
+
+  return executeVersionPlan(plan, options)
+}
+
+export const executeVersionPlan = async (
+  plan: MirrorExecutionResult['plan'],
+  options: MirrorCliOptions = {},
+): Promise<MirrorExecutionResult> => {
+  if (options.dryRun) return { plan, applied: false, dryRun: true }
+  if (!plan.allowDirty && (await isGitRepository(plan.cwd)) && (await isGitDirty(plan.cwd))) {
+    throw new MirrorError('Git worktree is dirty. Commit changes or pass --allow-dirty.')
+  }
+  if (!options.yes) throw new MirrorError('Refusing to apply without confirmation. Pass --yes to apply the plan.')
+
+  const config = await loadMirrorConfig(options)
+
+  if (config.version.output.includes('package.json')) await writePackageVersion(config, plan.nextVersion)
+  if (config.version.output.includes('jsr.json')) await writeJsrVersion(config, plan.nextVersion)
+
+  for (const action of plan.actions) {
+    if (action.type === 'git-commit') await createGitCommit(plan.cwd, action.paths, action.message)
+    if (action.type === 'git-tag') await createGitTag(plan.cwd, action.tag)
+    if (action.type === 'git-push') await pushGitRefs(plan.cwd, action.includeCommit, action.includeTags)
+  }
+
+  return { plan, applied: true, dryRun: false }
+}

package/source/flags.ts

@@ -0,0 +1,84 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+
+import type { MirrorAdapterName, MirrorCliOptions, MirrorFormat } from './types'
+import { MirrorError } from './errors'
+
+const booleanFlags = new Set(['dry-run', 'commit', 'push', 'allow-dirty', 'yes', 'no-color', 'help', 'version'])
+const adapterNames = new Set(['package.json', 'jsr.json', 'git'])
+
+const shortFlagAliases: Record<string, string> = {
+  '-dy': '--dry-run',
+  '-y': '--yes',
+}
+
+const normalizeKey = (key: string) => key.replace(/-([a-z])/g, (_match, letter: string) => letter.toUpperCase())
+
+const expandShortFlags = (rawArgs: string[]) => rawArgs.map((token) => shortFlagAliases[token] ?? token)
+
+export const parseMirrorCliOptions = (rawArgs: string[]): MirrorCliOptions => {
+  const parsed: Record<string, string | boolean | string[]> = {}
+  const args = expandShortFlags(rawArgs)
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]
+
+    if (!token?.startsWith('--')) continue
+
+    const withoutPrefix = token.slice(2)
+    const equalsIndex = withoutPrefix.indexOf('=')
+    const rawKey = equalsIndex >= 0 ? withoutPrefix.slice(0, equalsIndex) : withoutPrefix
+    const key = normalizeKey(rawKey)
+
+    if (booleanFlags.has(rawKey)) {
+      parsed[key] = true
+      continue
+    }
+
+    const value =
+      equalsIndex >= 0
+        ? withoutPrefix.slice(equalsIndex + 1)
+        : args[index + 1] && !args[index + 1]?.startsWith('-')
+        ? args[++index] ?? ''
+        : ''
+
+    if (!value) throw new MirrorError(`Missing value for --${rawKey}`)
+
+    if (key === 'output') {
+      const nextValues = value.split(',').map((item) => item.trim()).filter(Boolean)
+      const current = parsed['output']
+      parsed['output'] = [...(Array.isArray(current) ? current : current ? [String(current)] : []), ...nextValues]
+      continue
+    }
+
+    parsed[key] = value
+  }
+
+  return {
+    cwd: typeof parsed['cwd'] === 'string' ? parsed['cwd'] : undefined,
+    config: typeof parsed['config'] === 'string' ? parsed['config'] : undefined,
+    format: typeof parsed['format'] === 'string' ? assertFormat(parsed['format']) : undefined,
+    noColor: parsed['noColor'] === true,
+    source: typeof parsed['source'] === 'string' ? assertAdapter(parsed['source'], '--source') : undefined,
+    output: Array.isArray(parsed['output']) ? parsed['output'].map((value) => assertAdapter(value, '--output')) : undefined,
+    packageFile: typeof parsed['packageFile'] === 'string' ? parsed['packageFile'] : undefined,
+    jsrFile: typeof parsed['jsrFile'] === 'string' ? parsed['jsrFile'] : undefined,
+    preid: typeof parsed['preid'] === 'string' ? parsed['preid'] : undefined,
+    dryRun: parsed['dryRun'] === true,
+    commit: parsed['commit'] === true,
+    push: parsed['push'] === true,
+    allowDirty: parsed['allowDirty'] === true,
+    yes: parsed['yes'] === true,
+  }
+}
+
+const assertAdapter = (value: string, flagName: string): MirrorAdapterName => {
+  if (!adapterNames.has(value)) throw new MirrorError(`Invalid ${flagName} value: ${value}`)
+  return value as MirrorAdapterName
+}
+
+const assertFormat = (value: string): MirrorFormat => {
+  if (value !== 'text' && value !== 'json') throw new MirrorError(`Invalid --format value: ${value}`)
+  return value
+}

package/source/guiho-mirror-bin.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+
+import { runMirrorCli } from './guiho-mirror'
+
+await runMirrorCli()

package/source/guiho-mirror.spec.ts

@@ -0,0 +1,501 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  applyVersionPlan,
+  buildVersionPlan,
+  loadMirrorConfig,
+  parseMirrorCliOptions,
+  readJsrName,
+  readJsrVersion,
+  readPackageName,
+  readPackageVersion,
+  renderGitTag,
+  resolveNextVersion,
+  validateMirrorConfig,
+  versionFromTag,
+  writeJsrVersion,
+  writePackageVersion,
+} from './guiho-mirror'
+
+const temporaryDirectories: string[] = []
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })))
+})
+
+describe('Mirror v3', () => {
+  test('parses operational and override flags', () => {
+    const options = parseMirrorCliOptions([
+      '--source',
+      'package.json',
+      '--output',
+      'package.json',
+      '--output=jsr.json,git',
+      '--package-file=custom-package.json',
+      '--jsr-file',
+      'custom-jsr.json',
+      '--preid',
+      'alpha',
+      '--dry-run',
+      '--commit',
+      '--push',
+      '--allow-dirty',
+      '--yes',
+    ])
+
+    expect(options).toMatchObject({
+      source: 'package.json',
+      output: ['package.json', 'jsr.json', 'git'],
+      packageFile: 'custom-package.json',
+      jsrFile: 'custom-jsr.json',
+      preid: 'alpha',
+      dryRun: true,
+      commit: true,
+      push: true,
+      allowDirty: true,
+      yes: true,
+    })
+  })
+
+  test('expands short flag aliases -dy and -y', () => {
+    const options = parseMirrorCliOptions(['-dy', '-y'])
+
+    expect(options.dryRun).toBe(true)
+    expect(options.yes).toBe(true)
+  })
+
+  test('discovers explicit, root, and nested configs with root precedence', async () => {
+    const cwd = await createTempDir()
+    await mkdir(join(cwd, 'config'), { recursive: true })
+    await writeText(join(cwd, 'explicit.toml'), packageConfig({ output: ['jsr.json'], source: 'jsr.json' }))
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'] }))
+    await writeText(join(cwd, 'config', 'mirror.config.toml'), gitConfig())
+
+    const explicit = await loadMirrorConfig({ cwd, config: 'explicit.toml' })
+    const root = await loadMirrorConfig({ cwd })
+
+    await rm(join(cwd, 'mirror.config.toml'))
+    const nested = await loadMirrorConfig({ cwd })
+
+    expect(explicit.configPath).toBe(join(cwd, 'explicit.toml'))
+    expect(explicit.version.source).toBe('jsr.json')
+    expect(root.configPath).toBe(join(cwd, 'mirror.config.toml'))
+    expect(root.version.source).toBe('package.json')
+    expect(nested.configPath).toBe(join(cwd, 'config', 'mirror.config.toml'))
+    expect(nested.version.source).toBe('git')
+  })
+
+  test('validates schema, adapter names, project name sources, and tag templates', async () => {
+    const cwd = await createPackageAndJsrFixture()
+
+    await writeText(join(cwd, 'mirror.config.toml'), 'schema = 2\n')
+    await expect(loadMirrorConfig({ cwd })).rejects.toThrow('schema')
+
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['npm'] }))
+    await expect(loadMirrorConfig({ cwd })).rejects.toThrow('version.output')
+
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'], nameSource: 'git' }))
+    await expect(loadMirrorConfig({ cwd })).rejects.toThrow('project.name_source')
+
+    await initializeGitRepository(cwd)
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['git'], tagTemplate: 'release-{version}' }))
+    await expect(validateMirrorConfig({ cwd })).rejects.toThrow('Unsupported Git tag template')
+  })
+
+  test('merges CLI overrides over config values', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'custom-package.json'), JSON.stringify({ name: 'custom-package', version: '2.0.0' }, null, 2))
+    await writeText(join(cwd, 'custom-jsr.json'), JSON.stringify({ name: 'custom-jsr', version: '2.3.0' }, null, 2))
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'], preid: 'beta' }))
+
+    const config = await loadMirrorConfig({
+      cwd,
+      source: 'jsr.json',
+      output: ['jsr.json', 'git'],
+      packageFile: 'custom-package.json',
+      jsrFile: 'custom-jsr.json',
+      preid: 'alpha',
+      push: true,
+      allowDirty: true,
+    })
+
+    expect(config.version.source).toBe('jsr.json')
+    expect(config.version.output).toEqual(['jsr.json', 'git'])
+    expect(config.package.path).toBe('custom-package.json')
+    expect(config.jsr.path).toBe('custom-jsr.json')
+    expect(config.version.prereleaseId).toBe('alpha')
+    expect(config.git.commit).toBe(true)
+    expect(config.git.push).toBe(true)
+    expect(config.git.allowDirty).toBe(true)
+  })
+
+  test('reads and writes package and JSR names and versions', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'jsr.json'] }))
+    const config = await loadMirrorConfig({ cwd })
+
+    expect(await readPackageName(config)).toBe('@guiho/mirror')
+    expect(await readJsrName(config)).toBe('@guiho/mirror')
+    expect(await readPackageVersion(config)).toBe('1.0.0')
+    expect(await readJsrVersion(config)).toBe('1.0.0')
+
+    await writePackageVersion(config, '1.0.1')
+    await writeJsrVersion(config, '1.0.1')
+
+    expect(await readPackageVersion(config)).toBe('1.0.1')
+    expect(await readJsrVersion(config)).toBe('1.0.1')
+  })
+
+  test('resolves semantic version targets and prerelease identifiers', () => {
+    expect(resolveNextVersion('1.0.0', 'patch')).toBe('1.0.1')
+    expect(resolveNextVersion('1.0.0', 'prepatch')).toBe('1.0.1-0')
+    expect(resolveNextVersion('1.0.0', 'prepatch', 'alpha')).toBe('1.0.1-alpha.0')
+    expect(resolveNextVersion('1.0.0', '2.3.4')).toBe('2.3.4')
+  })
+
+  test('extracts and renders versions with supported Git tag templates', () => {
+    expect(versionFromTag('v{version}', 'v1.2.3')).toBe('1.2.3')
+    expect(versionFromTag('{name}@{version}', '@guiho/mirror@1.2.3', '@guiho/mirror')).toBe('1.2.3')
+    expect(versionFromTag('v{version}', 'not-a-version')).toBeUndefined()
+    expect(renderGitTag('v{version}', '1.2.3')).toBe('v1.2.3')
+    expect(renderGitTag('{name}@{version}', '1.2.3', '@guiho/mirror')).toBe('@guiho/mirror@1.2.3')
+  })
+
+  test('plans package and JSR file outputs', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'jsr.json'] }))
+
+    const plan = await buildVersionPlan('patch', { cwd })
+
+    expect(plan.currentVersion).toBe('1.0.0')
+    expect(plan.nextVersion).toBe('1.0.1')
+    expect(plan.actions.map((action) => action.type)).toEqual(['write-file', 'write-file'])
+  })
+
+  test('applies package and JSR file outputs outside Git', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'jsr.json'] }))
+
+    const result = await applyVersionPlan('minor', { cwd, yes: true })
+
+    expect(result.applied).toBe(true)
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.1.0')
+    expect(await readJsrVersion(await loadMirrorConfig({ cwd }))).toBe('1.1.0')
+  })
+
+  test('dry-run apply does not mutate files and does not require confirmation', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'] }))
+
+    const result = await applyVersionPlan('patch', { cwd, dryRun: true })
+
+    expect(result.applied).toBe(false)
+    expect(result.dryRun).toBe(true)
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.0.0')
+  })
+
+  test('reads the current version from matching Git tags', async () => {
+    const cwd = await createGitFixture()
+    await git(cwd, 'tag', 'v1.0.0')
+    await git(cwd, 'tag', 'v1.2.0')
+    await writeText(join(cwd, 'mirror.config.toml'), gitConfig())
+
+    const plan = await buildVersionPlan('patch', { cwd })
+
+    expect(plan.currentVersion).toBe('1.2.0')
+    expect(plan.nextVersion).toBe('1.2.1')
+    expect(plan.gitTag).toBe('v1.2.1')
+  })
+
+  test('requires commit or push when file outputs and Git tag output are combined', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await initializeGitRepository(cwd)
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'git'] }))
+
+    await expect(buildVersionPlan('patch', { cwd })).rejects.toThrow('requires --commit or --push')
+
+    const packageJson = await Bun.file(join(cwd, 'package.json')).json()
+    expect(packageJson.version).toBe('1.0.0')
+  })
+
+  test('fails on dirty Git worktrees unless allow-dirty is set', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await initializeGitRepository(cwd)
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'] }))
+    await commitAll(cwd, 'Add Mirror config')
+    await writeText(join(cwd, 'README.md'), '# dirty fixture\n')
+
+    await expect(applyVersionPlan('patch', { cwd, yes: true })).rejects.toThrow('dirty')
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.0.0')
+
+    const result = await applyVersionPlan('patch', { cwd, yes: true, allowDirty: true })
+    expect(result.applied).toBe(true)
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.0.1')
+  })
+
+  test('applies file output, release commit, and Git tag with --commit', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await initializeGitRepository(cwd)
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'git'] }))
+    await commitAll(cwd, 'Add Mirror config')
+
+    const result = await applyVersionPlan('patch', { cwd, commit: true, yes: true })
+
+    expect(result.applied).toBe(true)
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.0.1')
+    expect((await gitText(cwd, 'tag', '--list')).trim()).toBe('@guiho/mirror@1.0.1')
+    expect((await gitText(cwd, 'status', '--porcelain')).trim()).toBe('')
+  })
+
+  test('push implies commit and pushes the release tag', async () => {
+    const remote = await createBareGitRepository()
+    const cwd = await createPackageAndJsrFixture()
+    await initializeGitRepository(cwd)
+    await git(cwd, 'remote', 'add', 'origin', remote)
+    await git(cwd, 'push', '-u', 'origin', 'HEAD')
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json', 'git'] }))
+    await commitAll(cwd, 'Add Mirror config')
+
+    const result = await applyVersionPlan('patch', { cwd, push: true, yes: true })
+
+    expect(result.plan.commitEnabled).toBe(true)
+    expect(result.plan.pushEnabled).toBe(true)
+    expect((await gitText(remote, 'tag', '--list')).trim()).toBe('@guiho/mirror@1.0.1')
+  })
+
+  test('git-only releases with --commit create tags without empty commits', async () => {
+    const cwd = await createGitFixture()
+    await git(cwd, 'tag', 'v1.0.0')
+    await writeText(join(cwd, 'mirror.config.toml'), gitConfig())
+    await commitAll(cwd, 'Add Mirror config')
+    const commitsBefore = (await gitText(cwd, 'rev-list', '--count', 'HEAD')).trim()
+
+    const result = await applyVersionPlan('patch', { cwd, commit: true, yes: true })
+
+    expect(result.applied).toBe(true)
+    expect((await gitText(cwd, 'rev-list', '--count', 'HEAD')).trim()).toBe(commitsBefore)
+    expect((await gitText(cwd, 'tag', '--list')).trim().split(/\r?\n/).sort()).toEqual(['v1.0.0', 'v1.0.1'])
+  })
+
+  test('runs CLI config show and config check', async () => {
+    const cwd = await createGitFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), gitConfig())
+
+    const show = await runMirrorCli('config', 'show', '--cwd', cwd)
+    const check = await runMirrorCli('config', 'check', '--cwd', cwd)
+
+    expect(show.exitCode).toBe(0)
+    expect(show.stdout).toContain('source: git')
+    expect(check.exitCode).toBe(0)
+    expect(check.stdout.trim()).toBe('ok')
+  })
+
+  test('runs the top-level CLI as successful help output', async () => {
+    const result = await runMirrorCli()
+
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toMatch(/mirror v\d+\.\d+\.\d+/)
+    expect(result.stdout).toContain('USAGE')
+  })
+
+  test('runs CLI help without ANSI colors when no-color is set', async () => {
+    const result = await runMirrorCli('--no-color', '--help')
+
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('USAGE')
+    expect(result.stdout).not.toContain('\u001B[')
+  })
+
+  test('runs CLI version current, next, plan, and apply', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'] }))
+
+    const current = await runMirrorCli('version', 'current', '--cwd', cwd)
+    const next = await runMirrorCli('version', 'next', 'patch', '--cwd', cwd)
+    const plan = await runMirrorCli('version', 'plan', 'patch', '--cwd', cwd)
+    const apply = await runMirrorCli('version', 'apply', 'patch', '--cwd', cwd, '--yes')
+
+    expect(current.exitCode).toBe(0)
+    expect(current.stdout.trim()).toBe('1.0.0')
+    expect(next.exitCode).toBe(0)
+    expect(next.stdout.trim()).toBe('1.0.1')
+    expect(plan.exitCode).toBe(0)
+    expect(plan.stdout).toContain('next: 1.0.1')
+    expect(apply.exitCode).toBe(0)
+    expect(apply.stdout).toContain('next: 1.0.1')
+    expect(apply.stdout).toContain('applied: true')
+    expect(await readPackageVersion(await loadMirrorConfig({ cwd }))).toBe('1.0.1')
+  })
+
+  test('runs CLI source and repeated output overrides', async () => {
+    const cwd = await createPackageAndJsrFixture()
+    await writeText(join(cwd, 'mirror.config.toml'), packageConfig({ output: ['package.json'] }))
+
+    const result = await runMirrorCli(
+      'version',
+      'plan',
+      'patch',
+      '--cwd',
+      cwd,
+      '--source',
+      'package.json',
+      '--output',
+      'package.json',
+      '--output',
+      'jsr.json',
+    )
+
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('output: package.json, jsr.json')
+    expect(result.stdout).toContain('next: 1.0.1')
+  })
+})
+
+const createTempDir = async () => {
+  const path = await mkdtemp(join(tmpdir(), 'guiho-mirror-'))
+  temporaryDirectories.push(path)
+  return path
+}
+
+const createPackageAndJsrFixture = async () => {
+  const cwd = await createTempDir()
+  await writeJson(join(cwd, 'package.json'), {
+    name: '@guiho/mirror',
+    version: '1.0.0',
+  })
+  await writeJson(join(cwd, 'jsr.json'), {
+    name: '@guiho/mirror',
+    version: '1.0.0',
+    exports: './source/guiho-mirror.ts',
+  })
+  return cwd
+}
+
+const createGitFixture = async () => {
+  const cwd = await createTempDir()
+  await initializeGitRepository(cwd)
+  return cwd
+}
+
+const createBareGitRepository = async () => {
+  const cwd = await createTempDir()
+  await git(cwd, 'init', '--bare')
+  return cwd
+}
+
+const initializeGitRepository = async (cwd: string) => {
+  await git(cwd, 'init')
+  await git(cwd, 'config', 'user.email', 'mirror@example.com')
+  await git(cwd, 'config', 'user.name', 'Mirror Test')
+  await writeText(join(cwd, 'README.md'), '# fixture\n')
+  await git(cwd, 'add', '.')
+  await git(cwd, 'commit', '-m', 'Initial commit')
+}
+
+const commitAll = async (cwd: string, message: string) => {
+  await git(cwd, 'add', '.')
+  await git(cwd, 'commit', '-m', message)
+}
+
+const writeText = async (path: string, content: string) => {
+  await Bun.write(path, content)
+}
+
+const writeJson = async (path: string, object: Record<string, unknown>) => {
+  await writeText(path, `${JSON.stringify(object, null, 2)}\n`)
+}
+
+const packageConfig = ({
+  output,
+  source = 'package.json',
+  nameSource = 'package.json',
+  tagTemplate = '{name}@{version}',
+  preid = '',
+}: {
+  output: string[]
+  source?: string
+  nameSource?: string
+  tagTemplate?: string
+  preid?: string
+}) => `schema = 1
+
+[project]
+name_source = "${nameSource}"
+
+[version]
+scheme = "semver"
+source = "${source}"
+output = [${output.map((value) => `"${value}"`).join(', ')}]
+prerelease_id = "${preid}"
+
+[package]
+path = "package.json"
+
+[jsr]
+path = "jsr.json"
+
+[git]
+tag_template = "${tagTemplate}"
+commit = false
+push = false
+allow_dirty = false
+`
+
+const gitConfig = () => `schema = 1
+
+[project]
+name = "fixture"
+
+[version]
+scheme = "semver"
+source = "git"
+output = ["git"]
+prerelease_id = ""
+
+[git]
+tag_template = "v{version}"
+commit = false
+push = false
+allow_dirty = false
+`
+
+const git = async (cwd: string, ...args: string[]) => {
+  const result = Bun.spawn(['git', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const exitCode = await result.exited
+
+  if (exitCode !== 0) {
+    // @ts-expect-error
+    throw new Error(`git ${args.join(' ')} failed: ${await result.stderr.text()}`)
+  }
+}
+
+const gitText = async (cwd: string, ...args: string[]) => {
+  const result = Bun.spawn(['git', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const exitCode = await result.exited
+  // @ts-expect-error
+  const stdout = await result.stdout.text()
+
+  if (exitCode !== 0) {
+    // @ts-expect-error
+    throw new Error(`git ${args.join(' ')} failed: ${await result.stderr.text()}`)
+  }
+
+  return stdout
+}
+
+const runMirrorCli = async (...args: string[]) => {
+  const result = Bun.spawn(['bun', join(import.meta.dir, 'guiho-mirror-bin.ts'), ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  // @ts-expect-error
+  const [exitCode, stdout, stderr] = await Promise.all([result.exited, result.stdout.text(), result.stderr.text()])
+
+  return { exitCode, stdout, stderr }
+}