@guiho/mirror 2.3.2

package/library/cli.js

@@ -0,0 +1,310 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import { defineCommand, runMain } 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 { 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' },
+    verbose: { type: 'boolean', description: 'Show full error details and stack traces' },
+};
+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' },
+};
+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' },
+};
+const targetArg = {
+    target: { type: 'positional', description: 'Release target or exact semantic version', required: true },
+};
+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 verbose = effectiveArgs.includes('--verbose');
+    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');
+            });
+        }
+        // Intercept console.error during runMain to suppress citty's default
+        // ugly error dump (it does console.error(error, "\n") for non-CLIErrors).
+        // We capture the error object and handle it ourselves below.
+        let capturedError = undefined;
+        const originalConsoleError = console.error;
+        console.error = (...args) => {
+            // citty prints CLIError messages as strings — let those through
+            // citty prints non-CLIError errors as objects — capture those
+            if (args.length > 0 && args[0] instanceof Error) {
+                capturedError = args[0];
+                return;
+            }
+            originalConsoleError(...args);
+        };
+        const originalProcessExit = process.exit;
+        let exitCode;
+        process.exit = ((code) => {
+            // If runMain calls process.exit(1) after an error, intercept it
+            // so we can handle the error ourselves. Let exit(0) through (--help).
+            if (code !== 0 && capturedError) {
+                exitCode = code;
+                return undefined;
+            }
+            originalProcessExit(code);
+        });
+        try {
+            await runMain(createMirrorCommand(), { rawArgs: effectiveArgs });
+        }
+        finally {
+            console.error = originalConsoleError;
+            process.exit = originalProcessExit;
+        }
+        if (capturedError) {
+            handleCliError(capturedError, verbose, exitCode);
+        }
+    }
+    catch (error) {
+        handleCliError(error, verbose);
+    }
+    finally {
+        restoreColorOutput();
+    }
+};
+const handleCliError = (error, verbose, exitCode) => {
+    if (error instanceof MirrorError) {
+        console.error(`error: ${error.message}`);
+        if (verbose)
+            console.error(error.stack);
+        process.exit(error.exitCode);
+    }
+    if (error instanceof Error) {
+        console.error(`error: ${error.message}`);
+        if (verbose)
+            console.error(error.stack);
+    }
+    else {
+        console.error('error: An unexpected error occurred.');
+        if (verbose)
+            console.error(error);
+    }
+    process.exit(exitCode ?? 1);
+};
+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) => 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, args) => {
+    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,
+        verbose: parsed.verbose || args['verbose'] === true,
+    };
+};
+const stringArg = (value) => (typeof value === 'string' ? value : undefined);
+const adapterArg = (value) => {
+    if (value === 'package.json' || value === 'jsr.json' || value === 'git')
+        return value;
+    return undefined;
+};
+const outputArg = (value) => {
+    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'));
+        return typeof packageJson['version'] === 'string' ? packageJson['version'] : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const stripAnsi = (value) => value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
+const stripColorFromProcessOutput = () => {
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = (...values) => originalLog(...values.map(stripAnsiValue));
+    console.error = (...values) => originalError(...values.map(stripAnsiValue));
+    return () => {
+        console.log = originalLog;
+        console.error = originalError;
+    };
+};
+const stripAnsiValue = (value) => (typeof value === 'string' ? stripAnsi(value) : value);

package/library/config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { MirrorAdapterName, MirrorCliOptions, MirrorConfig, MirrorConfigDiscovery, MirrorRawConfig } from './types';
+export declare const resolveMirrorPath: (cwd: string, path: string) => string;
+export declare const relativeFromCwd: (cwd: string, path: string) => string;
+export declare const discoverMirrorConfig: (cwd: string, explicitPath?: string) => Promise<MirrorConfigDiscovery>;
+export declare const readConfigFile: (path: string) => Promise<MirrorRawConfig>;
+export declare const loadMirrorConfig: (options?: MirrorCliOptions) => Promise<MirrorConfig>;
+export declare const normalizeMirrorConfig: (raw: MirrorRawConfig, cwd: string, configPath: string | undefined, options?: MirrorCliOptions) => MirrorConfig;
+export declare const createInitConfig: (kind: MirrorAdapterName, cwd: string) => string;
+export declare const writeInitConfig: (kind: MirrorAdapterName, cwd: string, overwrite?: boolean) => Promise<string>;
+export declare const configPathForDisplay: (config: MirrorConfig) => string;
+//# sourceMappingURL=config.d.ts.map

package/library/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../source/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,EAErB,eAAe,EAChB,MAAM,SAAS,CAAA;AAMhB,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,EAAE,MAAM,MAAM,WAAmD,CAAA;AAE9G,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,EAAE,MAAM,MAAM,WAGxD,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAU,KAAK,MAAM,EAAE,eAAe,MAAM,KAAG,OAAO,CAAC,qBAAqB,CAa5G,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,eAAe,CAQ1E,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAU,UAAS,gBAAqB,KAAG,OAAO,CAAC,YAAY,CAO3F,CAAA;AAED,eAAO,MAAM,qBAAqB,GAChC,KAAK,eAAe,EACpB,KAAK,MAAM,EACX,YAAY,MAAM,GAAG,SAAS,EAC9B,UAAS,gBAAqB,KAC7B,YA6CF,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,MAAM,iBAAiB,EAAE,KAAK,MAAM,WAqEpE,CAAA;AAED,eAAO,MAAM,eAAe,GAAU,MAAM,iBAAiB,EAAE,KAAK,MAAM,EAAE,mBAAiB,oBAO5F,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,QAAQ,YAAY,WAAoF,CAAA"}

package/library/config.js

@@ -0,0 +1,193 @@
+/**
+ * @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 { MirrorError } from './errors';
+const adapters = new Set(['package.json', 'jsr.json', 'git']);
+const projectNameSources = new Set(['package.json', 'jsr.json']);
+export const resolveMirrorPath = (cwd, path) => (isAbsolute(path) ? path : resolve(cwd, path));
+export const relativeFromCwd = (cwd, path) => {
+    const relativePath = relative(cwd, resolveMirrorPath(cwd, path));
+    return relativePath || '.';
+};
+export const discoverMirrorConfig = async (cwd, explicitPath) => {
+    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) => {
+    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;
+};
+export const loadMirrorConfig = async (options = {}) => {
+    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, cwd, configPath, options = {}) => {
+    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 = 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, cwd) => {
+    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, cwd, 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) => (config.configPath ? relativeFromCwd(config.cwd, config.configPath) : '(none)');
+const assertAdapter = (value, key) => {
+    if (typeof value !== 'string' || !adapters.has(value))
+        throw new MirrorError(`Invalid or missing ${key}. Expected package.json, jsr.json, or git.`);
+    return value;
+};
+const assertProjectNameSource = (value, key) => {
+    if (typeof value !== 'string' || !projectNameSources.has(value))
+        throw new MirrorError(`Invalid ${key}. Expected package.json or jsr.json.`);
+    return value;
+};
+const assertOutput = (value) => {
+    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) => [...new Set(value)];
+const optionalString = (value, key) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new MirrorError(`Invalid ${key}. Expected a string.`);
+    return value;
+};
+const optionalBoolean = (value, key) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean')
+        throw new MirrorError(`Invalid ${key}. Expected true or false.`);
+    return value;
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

package/library/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export declare class MirrorError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare const invariant: (condition: unknown, message: string) => asserts condition;
+//# sourceMappingURL=errors.d.ts.map

package/library/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../source/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAEb,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI;CAK1C;AAED,eAAO,MAAM,SAAS,GAAI,WAAW,OAAO,EAAE,SAAS,MAAM,KAAG,QAAQ,SAEvE,CAAA"}

package/library/errors.js

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

package/library/executor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { MirrorCliOptions, MirrorExecutionResult } from './types';
+export declare const applyVersionPlan: (target: string, options?: MirrorCliOptions) => Promise<MirrorExecutionResult>;
+export declare const executeVersionPlan: (plan: MirrorExecutionResult["plan"], options?: MirrorCliOptions) => Promise<MirrorExecutionResult>;
+//# sourceMappingURL=executor.d.ts.map

package/library/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../source/executor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAMtE,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,EAAE,UAAS,gBAAqB,KAAG,OAAO,CAAC,qBAAqB,CAIpH,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,MAAM,qBAAqB,CAAC,MAAM,CAAC,EACnC,UAAS,gBAAqB,KAC7B,OAAO,CAAC,qBAAqB,CAmB/B,CAAA"}

package/library/executor.js

@@ -0,0 +1,34 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+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, options = {}) => {
+    const plan = await buildVersionPlan(target, options);
+    return executeVersionPlan(plan, options);
+};
+export const executeVersionPlan = async (plan, options = {}) => {
+    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/library/flags.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @copyright Copyright (c) 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { MirrorCliOptions } from './types';
+export declare const parseMirrorCliOptions: (rawArgs: string[]) => MirrorCliOptions;
+//# sourceMappingURL=flags.d.ts.map

package/library/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../source/flags.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAqB,gBAAgB,EAAgB,MAAM,SAAS,CAAA;AAehF,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,EAAE,KAAG,gBAuDzD,CAAA"}