@guiho/mirror 3.0.0-alpha.4 → 3.0.0-alpha.9

package/source/cli.ts

@@ -1,285 +0,0 @@
-/**
- * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
- */
-
-import { defineCommand, runMain } from 'citty'
-import type { ArgsDef } from 'citty'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { MirrorError } from './errors'
-import { readCurrentVersion, resolveProjectName } from './adapters'
-import { configPathForDisplay, discoverMirrorConfig, loadMirrorConfig, relativeFromCwd, writeInitConfig } from './config'
-import { executeVersionPlan } from './executor'
-import { parseMirrorCliOptions } from './flags'
-import { buildVersionPlan, validateMirrorConfig } from './plan'
-import { mirrorBanner, reportConfig, reportConfigSchema, reportExecution, reportExecutionSummary, reportPlan, reportValue } from './reporter'
-import type { MirrorAdapterName, MirrorCliOptions } from './types'
-import { resolveNextVersion } from './version'
-
-const mirrorVersion = readInstalledVersion()
-
-const globalArgs = {
-  config: { type: 'string', description: 'Path to mirror.config.toml' },
-  cwd: { type: 'string', description: 'Run as if Mirror started in this directory' },
-  format: { type: 'enum', options: ['text', 'json'], default: 'text', description: 'Output format' },
-  'no-color': { type: 'boolean', description: 'Disable color output' },
-} satisfies ArgsDef
-
-const overrideArgs = {
-  ...globalArgs,
-  source: { type: 'enum', options: ['package.json', 'jsr.json', 'git'], description: 'Override version source' },
-  output: { type: 'string', description: 'Override version output. Repeat or comma-separate values.' },
-  'package-file': { type: 'string', description: 'Override package.json path' },
-  'jsr-file': { type: 'string', description: 'Override jsr.json path' },
-  preid: { type: 'string', description: 'Override prerelease identifier' },
-} satisfies ArgsDef
-
-const applyArgs = {
-  ...overrideArgs,
-  'dry-run': { type: 'boolean', alias: 'dy', description: 'Build and print the plan without applying it' },
-  commit: { type: 'boolean', description: 'Create a release commit when file outputs changed' },
-  push: { type: 'boolean', description: 'Create the release commit when needed, then push release refs' },
-  'allow-dirty': { type: 'boolean', description: 'Allow release in a dirty Git worktree' },
-  yes: { type: 'boolean', alias: 'y', description: 'Apply without interactive confirmation' },
-} satisfies ArgsDef
-
-const targetArg = {
-  target: { type: 'positional', description: 'Release target or exact semantic version', required: true },
-} satisfies ArgsDef
-
-export const createMirrorCommand = () =>
-  defineCommand({
-    meta: {
-      name: 'mirror',
-      version: mirrorVersion,
-      description: 'Open source project versioning for Bun, npm, JSR, and Git.',
-    },
-    args: globalArgs,
-    subCommands: {
-      init: createInitCommand(),
-      config: createConfigCommand(),
-      version: createVersionCommand(),
-    },
-  })
-
-export const runMirrorCli = async (rawArgs = process.argv.slice(2)) => {
-  const effectiveArgs = rawArgs.length === 0 ? ['--help'] : rawArgs
-  const restoreColorOutput = effectiveArgs.includes('--no-color') ? stripColorFromProcessOutput() : () => {}
-
-  try {
-    if (effectiveArgs.includes('--no-color')) process.env['NO_COLOR'] = '1'
-
-    if (effectiveArgs.includes('--help')) {
-      const parsed = parseMirrorCliOptions(effectiveArgs)
-      const cwd = resolve(parsed.cwd ?? process.cwd())
-      const discovery = await discoverMirrorConfig(cwd, parsed.config)
-      const configDisplay = discovery.path ? relativeFromCwd(cwd, discovery.path) : ''
-      process.stdout.write(mirrorBanner(configDisplay))
-    }
-
-    if (rawArgs.length === 0) {
-      process.on('exit', () => {
-        process.stdout.write([
-          'EXAMPLES',
-          '',
-          '  mirror version current                 # Print the current version',
-          '  mirror version plan patch              # Preview a patch release plan',
-          '  mirror version apply minor --commit    # Apply a minor release with commit',
-          '  mirror version plan patch --output=package.json,jsr.json,git  # Plan with package, jsr, and git',
-          '  mirror config schema                   # Print the configuration file reference',
-          '',
-        ].join('\n') + '\n')
-      })
-    }
-
-    await runMain(createMirrorCommand(), { rawArgs: effectiveArgs })
-  } catch (error) {
-    if (error instanceof MirrorError) {
-      console.error(error.message)
-      process.exit(error.exitCode)
-    }
-
-    throw error
-  } finally {
-    restoreColorOutput()
-  }
-}
-
-const createInitCommand = () =>
-  defineCommand({
-    meta: { name: 'init', description: 'Create a Mirror configuration file.' },
-    subCommands: {
-      'package.json': createInitKindCommand('package.json'),
-      'jsr.json': createInitKindCommand('jsr.json'),
-      git: createInitKindCommand('git'),
-    },
-  })
-
-const createInitKindCommand = (kind: MirrorAdapterName) =>
-  defineCommand({
-    meta: { name: kind, description: `Create ${kind} project configuration.` },
-    args: {
-      ...globalArgs,
-      yes: { type: 'boolean', description: 'Overwrite existing mirror.config.toml' },
-    },
-    async run(context) {
-      const options = cliOptions(context.rawArgs, context.args)
-      const path = await writeInitConfig(kind, options.cwd ?? process.cwd(), Boolean(options.yes))
-      process.stdout.write(reportValue(`created ${path}`, options.format))
-    },
-  })
-
-const createConfigCommand = () =>
-  defineCommand({
-    meta: { name: 'config', description: 'Inspect and validate Mirror configuration.' },
-    subCommands: {
-      show: defineCommand({
-        meta: { name: 'show', description: 'Print the resolved configuration.' },
-        args: overrideArgs,
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          const config = await loadMirrorConfig(options)
-          if (options.format !== 'json') process.stdout.write(mirrorBanner(configPathForDisplay(config)))
-          process.stdout.write(reportConfig(config, options.format))
-        },
-      }),
-      check: defineCommand({
-        meta: { name: 'check', description: 'Validate the resolved configuration.' },
-        args: overrideArgs,
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          await validateMirrorConfig(options)
-          process.stdout.write(reportValue('ok', options.format))
-        },
-      }),
-      schema: defineCommand({
-        meta: { name: 'schema', description: 'Print the configuration file reference.' },
-        args: globalArgs,
-        run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          if (options.format !== 'json') process.stdout.write(mirrorBanner())
-          process.stdout.write(reportConfigSchema(options.format))
-        },
-      }),
-    },
-  })
-
-const createVersionCommand = () =>
-  defineCommand({
-    meta: { name: 'version', description: 'Read, plan, and apply version changes.' },
-    subCommands: {
-      current: defineCommand({
-        meta: { name: 'current', description: 'Print the current project version.' },
-        args: overrideArgs,
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          const config = await loadMirrorConfig(options)
-          const projectName = await resolveProjectName(config)
-          process.stdout.write(reportValue(await readCurrentVersion(config, projectName), options.format))
-        },
-      }),
-      next: defineCommand({
-        meta: { name: 'next', description: 'Print the next version without checking outputs.' },
-        args: { ...overrideArgs, ...targetArg },
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          const config = await loadMirrorConfig(options)
-          const projectName = await resolveProjectName(config)
-          const currentVersion = await readCurrentVersion(config, projectName)
-          process.stdout.write(reportValue(resolveNextVersion(currentVersion, String(context.args['target']), config.version.prereleaseId), options.format))
-        },
-      }),
-      plan: defineCommand({
-        meta: { name: 'plan', description: 'Print the release plan without writing anything.' },
-        args: { ...overrideArgs, ...targetArg },
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          const plan = await buildVersionPlan(String(context.args['target']), options)
-          if (options.format !== 'json') process.stdout.write(mirrorBanner(plan.configPath ? plan.configPath : ''))
-          process.stdout.write(reportPlan(plan, options.format))
-        },
-      }),
-      apply: defineCommand({
-        meta: { name: 'apply', description: 'Apply the release plan.' },
-        args: { ...applyArgs, ...targetArg },
-        async run(context) {
-          const options = cliOptions(context.rawArgs, context.args)
-          const plan = await buildVersionPlan(String(context.args['target']), options)
-
-          if (options.format !== 'json') process.stdout.write(mirrorBanner(plan.configPath ? plan.configPath : ''))
-          if (options.format !== 'json') process.stdout.write(reportPlan(plan, options.format))
-
-          const result = await executeVersionPlan(plan, options)
-          process.stdout.write(options.format === 'json' ? reportExecution(result, options.format) : reportExecutionSummary(result, options.format))
-        },
-      }),
-    },
-  })
-
-const cliOptions = (rawArgs: string[], args: Record<string, unknown>): MirrorCliOptions => {
-  const parsed = parseMirrorCliOptions(rawArgs)
-
-  return {
-    ...parsed,
-    config: parsed.config ?? stringArg(args['config']),
-    cwd: parsed.cwd ?? stringArg(args['cwd']),
-    format: parsed.format ?? (args['format'] === 'json' ? 'json' : 'text'),
-    source: parsed.source ?? adapterArg(args['source']),
-    output: parsed.output ?? outputArg(args['output']),
-    packageFile: parsed.packageFile ?? stringArg(args['packageFile']),
-    jsrFile: parsed.jsrFile ?? stringArg(args['jsrFile']),
-    preid: parsed.preid ?? stringArg(args['preid']),
-    dryRun: parsed.dryRun || args['dryRun'] === true,
-    commit: parsed.commit || args['commit'] === true,
-    push: parsed.push || args['push'] === true,
-    allowDirty: parsed.allowDirty || args['allowDirty'] === true,
-    yes: parsed.yes || args['yes'] === true,
-  }
-}
-
-const stringArg = (value: unknown) => (typeof value === 'string' ? value : undefined)
-
-const adapterArg = (value: unknown) => {
-  if (value === 'package.json' || value === 'jsr.json' || value === 'git') return value
-  return undefined
-}
-
-const outputArg = (value: unknown): MirrorCliOptions['output'] => {
-  if (typeof value !== 'string') return undefined
-
-  const values = value.split(',').map((item) => item.trim()).filter(Boolean)
-
-  if (values.length === 0) return undefined
-
-  return values.map((item) => {
-    const adapter = adapterArg(item)
-    if (!adapter) throw new MirrorError(`Invalid --output value: ${item}`)
-    return adapter
-  })
-}
-
-function readInstalledVersion() {
-  try {
-    const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as Record<string, unknown>
-    return typeof packageJson['version'] === 'string' ? packageJson['version'] : '0.0.0'
-  } catch {
-    return '0.0.0'
-  }
-}
-
-const stripAnsi = (value: string) => value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '')
-
-const stripColorFromProcessOutput = () => {
-  const originalLog = console.log
-  const originalError = console.error
-
-  console.log = (...values: unknown[]) => originalLog(...values.map(stripAnsiValue))
-  console.error = (...values: unknown[]) => originalError(...values.map(stripAnsiValue))
-
-  return () => {
-    console.log = originalLog
-    console.error = originalError
-  }
-}
-
-const stripAnsiValue = (value: unknown) => (typeof value === 'string' ? stripAnsi(value) : value)

package/source/config.ts

@@ -1,224 +0,0 @@
-/**
- * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
- */
-
-import { existsSync } from 'node:fs'
-import { basename, isAbsolute, join, relative, resolve } from 'node:path'
-import type {
-  MirrorAdapterName,
-  MirrorCliOptions,
-  MirrorConfig,
-  MirrorConfigDiscovery,
-  MirrorProjectNameSource,
-  MirrorRawConfig,
-} from './types'
-import { MirrorError } from './errors'
-
-const adapters = new Set(['package.json', 'jsr.json', 'git'])
-const projectNameSources = new Set(['package.json', 'jsr.json'])
-
-export const resolveMirrorPath = (cwd: string, path: string) => (isAbsolute(path) ? path : resolve(cwd, path))
-
-export const relativeFromCwd = (cwd: string, path: string) => {
-  const relativePath = relative(cwd, resolveMirrorPath(cwd, path))
-  return relativePath || '.'
-}
-
-export const discoverMirrorConfig = async (cwd: string, explicitPath?: string): Promise<MirrorConfigDiscovery> => {
-  if (explicitPath) {
-    const configPath = resolveMirrorPath(cwd, explicitPath)
-    return { path: configPath, raw: await readConfigFile(configPath) }
-  }
-
-  const rootConfigPath = resolve(cwd, 'mirror.config.toml')
-  if (existsSync(rootConfigPath)) return { path: rootConfigPath, raw: await readConfigFile(rootConfigPath) }
-
-  const nestedConfigPath = resolve(cwd, 'config', 'mirror.config.toml')
-  if (existsSync(nestedConfigPath)) return { path: nestedConfigPath, raw: await readConfigFile(nestedConfigPath) }
-
-  return {}
-}
-
-export const readConfigFile = async (path: string): Promise<MirrorRawConfig> => {
-  if (!existsSync(path)) throw new MirrorError(`Configuration file not found: ${path}`)
-
-  const parsed = Bun.TOML.parse(await Bun.file(path).text())
-
-  if (!isRecord(parsed)) throw new MirrorError(`Configuration file must contain a TOML object: ${path}`)
-
-  return parsed as MirrorRawConfig
-}
-
-export const loadMirrorConfig = async (options: MirrorCliOptions = {}): Promise<MirrorConfig> => {
-  const cwd = resolve(options.cwd ?? process.cwd())
-  const discovered = await discoverMirrorConfig(cwd, options.config)
-
-  if (!discovered.raw) throw new MirrorError('Mirror configuration not found. Run `mirror init package`, `mirror init jsr`, or `mirror init git`.')
-
-  return normalizeMirrorConfig(discovered.raw, cwd, discovered.path, options)
-}
-
-export const normalizeMirrorConfig = (
-  raw: MirrorRawConfig,
-  cwd: string,
-  configPath: string | undefined,
-  options: MirrorCliOptions = {},
-): MirrorConfig => {
-  if (raw.schema !== 1) throw new MirrorError('Unsupported or missing configuration schema. Expected `schema = 1`.')
-  if (raw.version?.scheme !== undefined && raw.version.scheme !== 'semver') throw new MirrorError('Only `version.scheme = "semver"` is supported.')
-
-  const source = options.source ?? assertAdapter(raw.version?.source, 'version.source')
-  const output = dedupeAdapters(options.output ?? assertOutput(raw.version?.output))
-  const nameSource: MirrorProjectNameSource | undefined = raw.project?.name_source
-    ? assertProjectNameSource(raw.project.name_source, 'project.name_source')
-    : undefined
-  const projectName = optionalString(raw.project?.name, 'project.name')
-  const prereleaseId = options.preid ?? optionalString(raw.version?.prerelease_id, 'version.prerelease_id') ?? ''
-  const packagePath = options.packageFile ?? optionalString(raw.package?.path, 'package.path') ?? 'package.json'
-  const jsrPath = options.jsrFile ?? optionalString(raw.jsr?.path, 'jsr.path') ?? 'jsr.json'
-  const tagTemplate = optionalString(raw.git?.tag_template, 'git.tag_template') ?? 'v{version}'
-  const gitCommit = optionalBoolean(raw.git?.commit, 'git.commit') === true
-  const gitPush = optionalBoolean(raw.git?.push, 'git.push') === true
-  const gitAllowDirty = optionalBoolean(raw.git?.allow_dirty, 'git.allow_dirty') === true
-
-  return {
-    schema: 1,
-    cwd,
-    configPath,
-    project: {
-      name: projectName,
-      nameSource,
-    },
-    version: {
-      scheme: 'semver',
-      source,
-      output,
-      prereleaseId,
-    },
-    package: {
-      path: packagePath,
-    },
-    jsr: {
-      path: jsrPath,
-    },
-    git: {
-      tagTemplate,
-      commit: options.commit === true || options.push === true || gitCommit || gitPush,
-      push: options.push === true || gitPush,
-      allowDirty: options.allowDirty === true || gitAllowDirty,
-    },
-  }
-}
-
-export const createInitConfig = (kind: MirrorAdapterName, cwd: string) => {
-  const projectName = basename(cwd)
-
-  if (kind === 'package.json') {
-    return `schema = 1
-
-[project]
-name_source = "package.json"
-
-[version]
-scheme = "semver"
-source = "package.json"
-output = ["package.json"]
-prerelease_id = ""
-
-[package]
-path = "package.json"
-
-[jsr]
-path = "jsr.json"
-
-[git]
-tag_template = "{name}@{version}"
-commit = false
-push = false
-allow_dirty = false
-`
-  }
-
-  if (kind === 'jsr.json') {
-    return `schema = 1
-
-[project]
-name_source = "jsr.json"
-
-[version]
-scheme = "semver"
-source = "jsr.json"
-output = ["jsr.json"]
-prerelease_id = ""
-
-[jsr]
-path = "jsr.json"
-
-[git]
-tag_template = "{name}@{version}"
-commit = false
-push = false
-allow_dirty = false
-`
-  }
-
-  return `schema = 1
-
-[project]
-name = "${projectName}"
-
-[version]
-scheme = "semver"
-source = "git"
-output = ["git"]
-prerelease_id = ""
-
-[git]
-tag_template = "v{version}"
-commit = false
-push = false
-allow_dirty = false
-`
-}
-
-export const writeInitConfig = async (kind: MirrorAdapterName, cwd: string, overwrite = false) => {
-  const path = join(cwd, 'mirror.config.toml')
-
-  if (existsSync(path) && !overwrite) throw new MirrorError(`Configuration already exists: ${path}`)
-
-  await Bun.write(path, createInitConfig(kind, cwd))
-  return path
-}
-
-export const configPathForDisplay = (config: MirrorConfig) => (config.configPath ? relativeFromCwd(config.cwd, config.configPath) : '(none)')
-
-const assertAdapter = (value: unknown, key: string): MirrorAdapterName => {
-  if (typeof value !== 'string' || !adapters.has(value)) throw new MirrorError(`Invalid or missing ${key}. Expected package.json, jsr.json, or git.`)
-  return value as MirrorAdapterName
-}
-
-const assertProjectNameSource = (value: unknown, key: string): MirrorProjectNameSource => {
-  if (typeof value !== 'string' || !projectNameSources.has(value)) throw new MirrorError(`Invalid ${key}. Expected package.json or jsr.json.`)
-  return value as MirrorProjectNameSource
-}
-
-const assertOutput = (value: unknown): MirrorAdapterName[] => {
-  if (!Array.isArray(value) || value.length === 0) throw new MirrorError('Invalid or missing version.output. Expected at least one output adapter.')
-  return value.map((item) => assertAdapter(item, 'version.output'))
-}
-
-const dedupeAdapters = (value: MirrorAdapterName[]) => [...new Set(value)]
-
-const optionalString = (value: unknown, key: string) => {
-  if (value === undefined) return undefined
-  if (typeof value !== 'string') throw new MirrorError(`Invalid ${key}. Expected a string.`)
-  return value
-}
-
-const optionalBoolean = (value: unknown, key: string) => {
-  if (value === undefined) return undefined
-  if (typeof value !== 'boolean') throw new MirrorError(`Invalid ${key}. Expected true or false.`)
-  return value
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value)

package/source/errors.ts

@@ -1,17 +0,0 @@
-/**
- * @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

@@ -1,39 +0,0 @@
-/**
- * @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

@@ -1,84 +0,0 @@
-/**
- * @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

@@ -1,8 +0,0 @@
-#!/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()