@capawesome/cli 2.1.4-dev.6aa4113.1756747595 → 2.1.4-dev.6aa4113.1756907810

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import configService from './services/config.js';
 import updateService from './services/update.js';
-import { CliError, getMessageFromUnknownError } from './utils/error.js';
+import { getMessageFromUnknownError } from './utils/error.js';
 import { defineConfig, processConfig, ZliError } from '@robingenz/zli';
 import * as Sentry from '@sentry/node';
 import { AxiosError } from 'axios';
@@ -33,24 +33,14 @@ const config = defineConfig({
         'apps:channels:update': await import('./commands/apps/channels/update.js').then((mod) => mod.default),
         'apps:devices:delete': await import('./commands/apps/devices/delete.js').then((mod) => mod.default),
         'manifests:generate': await import('./commands/manifests/generate.js').then((mod) => mod.default),
-        'mutate:version:get': await import('./commands/mutate/version/get.js').then((mod) => mod.default),
-        'mutate:version:set': await import('./commands/mutate/version/set.js').then((mod) => mod.default),
-        'mutate:version:major': await import('./commands/mutate/version/major.js').then((mod) => mod.default),
-        'mutate:version:minor': await import('./commands/mutate/version/minor.js').then((mod) => mod.default),
-        'mutate:version:patch': await import('./commands/mutate/version/patch.js').then((mod) => mod.default),
-        'mutate:version:hotfix': await import('./commands/mutate/version/hotfix.js').then((mod) => mod.default),
-        'mutate:version:sync': await import('./commands/mutate/version/sync.js').then((mod) => mod.default),
         'organizations:create': await import('./commands/organizations/create.js').then((mod) => mod.default),
     },
 });
 const captureException = async (error) => {
-    // Ignore expected CLI errors (e.g. "No command found.")
+    // Ignore errors from the CLI itself (e.g. "No command found.")
     if (error instanceof ZliError) {
         return;
     }
-    if (error instanceof CliError) {
-        return;
-    }
     // Ignore validation errors
     if (error instanceof ZodError) {
         return;
@@ -65,7 +55,7 @@ const captureException = async (error) => {
     }
     Sentry.init({
         dsn: 'https://19f30f2ec4b91899abc33818568ceb42@o4507446340747264.ingest.de.sentry.io/4508506426966096',
-        release: pkg.version,
+        release: `capawesome-team-cli@${pkg.version}`,
     });
     if (process.argv.slice(2).length > 0) {
         Sentry.setTag('cli_command', process.argv.slice(2)[0]);

package/dist/utils/error.js

@@ -1,17 +1,8 @@
 import { AxiosError } from 'axios';
 import { ZodError } from 'zod';
-export class CliError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CliError';
-    }
-}
 export const getMessageFromUnknownError = (error) => {
     let message = 'An unknown error has occurred.';
-    if (error instanceof CliError) {
-        message = error.message;
-    }
-    else if (error instanceof AxiosError) {
+    if (error instanceof AxiosError) {
         message = getErrorMessageFromAxiosError(error);
     }
     else if (error instanceof ZodError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capawesome/cli",
-  "version": "2.1.4-dev.6aa4113.1756747595",
+  "version": "2.1.4-dev.6aa4113.1756907810",
   "description": "The Capawesome Cloud Command Line Interface (CLI) to manage Live Updates and more.",
   "type": "module",
   "scripts": {
@@ -12,9 +12,9 @@
     "lint": "npm run prettier -- --check",
     "fmt": "npm run prettier -- --write",
     "prettier": "prettier \"**/*.{css,html,ts,js}\"",
-    "sentry:releases:new": "sentry-cli releases new $npm_package_version --org genz-it-solutions-gmbh --project capawesome-team-cli",
-    "sentry:releases:set-commits": "sentry-cli releases set-commits $npm_package_version --auto --org genz-it-solutions-gmbh --project capawesome-team-cli",
-    "sentry:releases:finalize": "sentry-cli releases finalize $npm_package_version --org genz-it-solutions-gmbh --project capawesome-team-cli",
+    "sentry:releases:new": "sentry-cli releases new capawesome-team-cli@$npm_package_version --org genz-it-solutions-gmbh --project capawesome-team-cli",
+    "sentry:releases:set-commits": "sentry-cli releases set-commits capawesome-team-cli@$npm_package_version --auto --org genz-it-solutions-gmbh --project capawesome-team-cli --ignore-missing",
+    "sentry:releases:finalize": "sentry-cli releases finalize capawesome-team-cli@$npm_package_version --org genz-it-solutions-gmbh --project capawesome-team-cli",
     "release": "commit-and-tag-version",
     "prepublishOnly": "npm run build && npm run sentry:releases:new && npm run sentry:releases:set-commits",
     "postpublish": "npm run sentry:releases:finalize"
@@ -55,7 +55,6 @@
     "@clack/prompts": "0.7.0",
     "@robingenz/zli": "0.1.5",
     "@sentry/node": "8.55.0",
-    "@trapezedev/project": "7.1.3",
     "archiver": "7.0.1",
     "axios": "1.8.4",
     "axios-retry": "4.5.0",

package/dist/commands/mutate/version/get.js

@@ -1,47 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Get the version of the app from all relevant files',
-    action: async () => {
-        const versions = await versionService.getAllVersions();
-        if (versions.length === 0) {
-            throw new CliError('No platform versions found');
-        }
-        const firstVersion = versions[0].version;
-        // Check major.minor.patch synchronization for all platforms
-        const allVersionsInSync = versions.every((pv) => {
-            return (pv.version.major === firstVersion.major &&
-                pv.version.minor === firstVersion.minor &&
-                pv.version.patch === firstVersion.patch);
-        });
-        // Check hotfix synchronization between iOS and Android
-        const iosVersion = versions.find((pv) => pv.platform === 'ios');
-        const androidVersion = versions.find((pv) => pv.platform === 'android');
-        let hotfixInSync = true;
-        if (iosVersion && androidVersion) {
-            const iosHotfix = iosVersion.version.hotfix || 0;
-            const androidHotfix = androidVersion.version.hotfix || 0;
-            hotfixInSync = iosHotfix === androidHotfix;
-        }
-        if (!allVersionsInSync || !hotfixInSync) {
-            consola.error('Versions are not synchronized across platforms:');
-            versions.forEach((pv) => {
-                const versionStr = versionToString(pv.version);
-                const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
-                consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr} (${pv.source})`);
-            });
-            throw new CliError('Versions are not synchronized across platforms');
-        }
-        const versionStr = versionToString(firstVersion);
-        // Show hotfix if iOS or Android has one
-        const platformWithHotfix = versions.find((pv) => pv.platform !== 'web' && pv.version.hotfix && pv.version.hotfix > 0);
-        const hotfixStr = platformWithHotfix ? ` (hotfix: ${platformWithHotfix.version.hotfix})` : '';
-        consola.success(`Version: ${versionStr}${hotfixStr}`);
-        versions.forEach((pv) => {
-            consola.log(`  ${pv.platform}: ${pv.source}`);
-        });
-    },
-});

package/dist/commands/mutate/version/get.test.js

@@ -1,85 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import getCommand from './get.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:get', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should display synchronized versions across all platforms', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-            {
-                platform: 'android',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
-                source: 'android/app/build.gradle',
-            },
-            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
-        ];
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        await getCommand.action({}, undefined);
-        expect(mockConsola.success).toHaveBeenCalledWith('Version: 1.2.3');
-        expect(mockConsola.log).toHaveBeenCalledWith('  ios: ios/App/App.xcodeproj/project.pbxproj');
-        expect(mockConsola.log).toHaveBeenCalledWith('  android: android/app/build.gradle');
-        expect(mockConsola.log).toHaveBeenCalledWith('  web: package.json');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should display hotfix when iOS/Android have one', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-            {
-                platform: 'android',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
-                source: 'android/app/build.gradle',
-            },
-            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
-        ];
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        await getCommand.action({}, undefined);
-        expect(mockConsola.success).toHaveBeenCalledWith('Version: 1.2.3 (hotfix: 5)');
-    });
-    it('should error when versions are not synchronized', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-            {
-                platform: 'android',
-                version: { major: 1, minor: 2, patch: 4, hotfix: 0 },
-                source: 'android/app/build.gradle',
-            },
-            { platform: 'web', version: { major: 1, minor: 2, patch: 3 }, source: 'package.json' },
-        ];
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        await expect(getCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(getCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
-        expect(mockConsola.error).toHaveBeenCalledWith('Versions are not synchronized across platforms:');
-        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3 (ios/App/App.xcodeproj/project.pbxproj)');
-        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.2.4 (android/app/build.gradle)');
-        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.3 (package.json)');
-    });
-    it('should error when no platform versions found', async () => {
-        mockVersionService.getAllVersions.mockResolvedValue([]);
-        await expect(getCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(getCommand.action({}, undefined)).rejects.toThrow('No platform versions found');
-    });
-});

package/dist/commands/mutate/version/hotfix.js

@@ -1,22 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { incrementHotfix, versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Increment the hotfix version of the app in all relevant files',
-    action: async () => {
-        const currentVersion = await versionService.ensureVersionsInSync();
-        // Check for hotfix version limit
-        const currentHotfix = currentVersion.hotfix || 0;
-        if (currentHotfix >= 99) {
-            throw new CliError('Cannot increment hotfix version: would exceed maximum value of 99');
-        }
-        const newVersion = incrementHotfix(currentVersion);
-        const versionStr = versionToString(currentVersion);
-        const newHotfix = newVersion.hotfix || 0;
-        consola.info(`Incrementing hotfix for version ${versionStr} (${currentHotfix} -> ${newHotfix})...`);
-        await versionService.setVersion(newVersion);
-        consola.success(`Hotfix incremented for version ${versionStr} (now ${newHotfix})`);
-    },
-});

package/dist/commands/mutate/version/hotfix.test.js

@@ -1,49 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import hotfixCommand from './hotfix.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:hotfix', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should increment hotfix version from 0', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await hotfixCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing hotfix for version 1.2.3 (0 -> 1)...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3, hotfix: 1 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Hotfix incremented for version 1.2.3 (now 1)');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should increment existing hotfix version', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await hotfixCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing hotfix for version 1.2.3 (5 -> 6)...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3, hotfix: 6 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Hotfix incremented for version 1.2.3 (now 6)');
-    });
-    it('should handle maximum hotfix version limit', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 99 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow('Cannot increment hotfix version: would exceed maximum value of 99');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should handle hotfix sync errors between iOS and Android', async () => {
-        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Hotfix versions are not synchronized between iOS and Android'));
-        await expect(hotfixCommand.action({}, undefined)).rejects.toThrow('Hotfix versions are not synchronized between iOS and Android');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-});

package/dist/commands/mutate/version/major.js

@@ -1,14 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { incrementMajor, versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Increment the major version of the app in all relevant files',
-    action: async () => {
-        const currentVersion = await versionService.ensureVersionsInSync();
-        const newVersion = incrementMajor(currentVersion);
-        consola.info(`Incrementing major version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-        await versionService.setVersion(newVersion);
-        consola.success(`Major version incremented to ${versionToString(newVersion)}`);
-    },
-});

package/dist/commands/mutate/version/major.test.js

@@ -1,49 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import majorCommand from './major.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:major', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should increment major version successfully', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await majorCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing major version from 1.2.3 to 2.0.0...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 2, minor: 0, patch: 0 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Major version incremented to 2.0.0');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should handle large major versions', async () => {
-        const currentVersion = { major: 999, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await majorCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing major version from 999.2.3 to 1000.0.0...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1000, minor: 0, patch: 0 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Major version incremented to 1000.0.0');
-    });
-    it('should handle version sync errors', async () => {
-        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
-        await expect(majorCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should handle service errors during set', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockRejectedValue(new Error('Failed to update version'));
-        await expect(majorCommand.action({}, undefined)).rejects.toThrow('Failed to update version');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 2, minor: 0, patch: 0 });
-    });
-});

package/dist/commands/mutate/version/minor.js

@@ -1,19 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { incrementMinor, versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Increment the minor version of the app in all relevant files',
-    action: async () => {
-        const currentVersion = await versionService.ensureVersionsInSync();
-        // Check for minor version limit
-        if (currentVersion.minor >= 999) {
-            throw new CliError('Cannot increment minor version: would exceed maximum value of 999');
-        }
-        const newVersion = incrementMinor(currentVersion);
-        consola.info(`Incrementing minor version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-        await versionService.setVersion(newVersion);
-        consola.success(`Minor version incremented to ${versionToString(newVersion)}`);
-    },
-});

package/dist/commands/mutate/version/minor.test.js

@@ -1,48 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import minorCommand from './minor.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:minor', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should increment minor version successfully', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await minorCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing minor version from 1.2.3 to 1.3.0...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 3, patch: 0 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Minor version incremented to 1.3.0');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should handle maximum minor version limit', async () => {
-        const currentVersion = { major: 1, minor: 999, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        await expect(minorCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(minorCommand.action({}, undefined)).rejects.toThrow('Cannot increment minor version: would exceed maximum value of 999');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should reset patch and hotfix when incrementing minor', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 5, hotfix: 3 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await minorCommand.action({}, undefined);
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 3, patch: 0 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Minor version incremented to 1.3.0');
-    });
-    it('should handle version sync errors', async () => {
-        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
-        await expect(minorCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-});

package/dist/commands/mutate/version/patch.js

@@ -1,19 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { incrementPatch, versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Increment the patch version of the app in all relevant files',
-    action: async () => {
-        const currentVersion = await versionService.ensureVersionsInSync();
-        // Check for patch version limit
-        if (currentVersion.patch >= 99) {
-            throw new CliError('Cannot increment patch version: would exceed maximum value of 99');
-        }
-        const newVersion = incrementPatch(currentVersion);
-        consola.info(`Incrementing patch version from ${versionToString(currentVersion)} to ${versionToString(newVersion)}...`);
-        await versionService.setVersion(newVersion);
-        consola.success(`Patch version incremented to ${versionToString(newVersion)}`);
-    },
-});

package/dist/commands/mutate/version/patch.test.js

@@ -1,48 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import patchCommand from './patch.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:patch', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should increment patch version successfully', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await patchCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Incrementing patch version from 1.2.3 to 1.2.4...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 4 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Patch version incremented to 1.2.4');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should handle maximum patch version limit', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 99, hotfix: 0 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        await expect(patchCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(patchCommand.action({}, undefined)).rejects.toThrow('Cannot increment patch version: would exceed maximum value of 99');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should reset hotfix when incrementing patch', async () => {
-        const currentVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
-        mockVersionService.ensureVersionsInSync.mockResolvedValue(currentVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await patchCommand.action({}, undefined);
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 4 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Patch version incremented to 1.2.4');
-    });
-    it('should handle version sync errors', async () => {
-        mockVersionService.ensureVersionsInSync.mockRejectedValue(new CliError('Versions are not synchronized across platforms'));
-        await expect(patchCommand.action({}, undefined)).rejects.toThrow('Versions are not synchronized across platforms');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-});

package/dist/commands/mutate/version/set.js

@@ -1,22 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { parseVersion, versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-import { z } from 'zod';
-export default defineCommand({
-    description: 'Set the version of the app in all relevant files',
-    args: z.tuple([z.string().describe('Version')]),
-    action: async (_options, args) => {
-        let version;
-        try {
-            version = parseVersion(args[0]);
-        }
-        catch (error) {
-            throw new CliError("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
-        }
-        consola.info(`Setting version to ${versionToString(version)}...`);
-        await versionService.setVersion(version);
-        consola.success(`Version set to ${versionToString(version)}`);
-    },
-});

package/dist/commands/mutate/version/set.test.js

@@ -1,41 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import setCommand from './set.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:set', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should set a valid version', async () => {
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await setCommand.action({}, ['1.2.3']);
-        expect(mockConsola.info).toHaveBeenCalledWith('Setting version to 1.2.3...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3 });
-        expect(mockConsola.success).toHaveBeenCalledWith('Version set to 1.2.3');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should handle invalid version format', async () => {
-        await expect(setCommand.action({}, ['1.2'])).rejects.toThrow(CliError);
-        await expect(setCommand.action({}, ['1.2'])).rejects.toThrow("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should handle non-numeric version parts', async () => {
-        await expect(setCommand.action({}, ['1.2.abc'])).rejects.toThrow(CliError);
-        await expect(setCommand.action({}, ['1.2.abc'])).rejects.toThrow("Invalid version format. Please use the format 'major.minor.patch' (e.g. '1.2.3').");
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should handle service errors', async () => {
-        mockVersionService.setVersion.mockRejectedValue(new Error('Failed to set version'));
-        await expect(setCommand.action({}, ['1.2.3'])).rejects.toThrow('Failed to set version');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith({ major: 1, minor: 2, patch: 3 });
-    });
-});

package/dist/commands/mutate/version/sync.js

@@ -1,26 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import { versionToString } from '../../../utils/version.js';
-import { defineCommand } from '@robingenz/zli';
-import consola from 'consola';
-export default defineCommand({
-    description: 'Set the highest version number among all platforms in all relevant files',
-    action: async () => {
-        const versions = await versionService.getAllVersions();
-        if (versions.length === 0) {
-            throw new CliError('No platform versions found');
-        }
-        const highestVersion = await versionService.getHighestVersion();
-        consola.info('Current versions:');
-        versions.forEach((pv) => {
-            const versionStr = versionToString(pv.version);
-            const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
-            consola.log(`  ${pv.platform}: ${versionStr}${hotfixStr}`);
-        });
-        const highestVersionStr = versionToString(highestVersion);
-        const hotfixStr = highestVersion.hotfix ? ` (hotfix: ${highestVersion.hotfix})` : '';
-        consola.info(`Syncing all platforms to highest version: ${highestVersionStr}${hotfixStr}...`);
-        await versionService.setVersion(highestVersion);
-        consola.success(`All platforms synced to version ${highestVersionStr}${hotfixStr}`);
-    },
-});

package/dist/commands/mutate/version/sync.test.js

@@ -1,90 +0,0 @@
-import versionService from '../../../services/mutate/version.js';
-import { CliError } from '../../../utils/error.js';
-import consola from 'consola';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import syncCommand from './sync.js';
-vi.mock('consola');
-vi.mock('@/services/mutate/version.js');
-describe('mutate:version:sync', () => {
-    const mockConsola = vi.mocked(consola);
-    const mockVersionService = vi.mocked(versionService);
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should sync to highest version across platforms', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-            {
-                platform: 'android',
-                version: { major: 1, minor: 3, patch: 0, hotfix: 0 },
-                source: 'android/app/build.gradle',
-            },
-            { platform: 'web', version: { major: 1, minor: 2, patch: 4 }, source: 'package.json' },
-        ];
-        const highestVersion = { major: 1, minor: 3, patch: 0, hotfix: 0 };
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        mockVersionService.getHighestVersion.mockResolvedValue(highestVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await syncCommand.action({}, undefined);
-        expect(mockConsola.info).toHaveBeenCalledWith('Current versions:');
-        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3');
-        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.3.0');
-        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.4');
-        expect(mockConsola.info).toHaveBeenCalledWith('Syncing all platforms to highest version: 1.3.0...');
-        expect(mockVersionService.setVersion).toHaveBeenCalledWith(highestVersion);
-        expect(mockConsola.success).toHaveBeenCalledWith('All platforms synced to version 1.3.0');
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('should sync including hotfix for iOS/Android', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-            {
-                platform: 'android',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 5 },
-                source: 'android/app/build.gradle',
-            },
-            { platform: 'web', version: { major: 1, minor: 2, patch: 2 }, source: 'package.json' },
-        ];
-        const highestVersion = { major: 1, minor: 2, patch: 3, hotfix: 5 };
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        mockVersionService.getHighestVersion.mockResolvedValue(highestVersion);
-        mockVersionService.setVersion.mockResolvedValue(undefined);
-        await syncCommand.action({}, undefined);
-        expect(mockConsola.log).toHaveBeenCalledWith('  ios: 1.2.3 (hotfix: 5)');
-        expect(mockConsola.log).toHaveBeenCalledWith('  android: 1.2.3 (hotfix: 5)');
-        expect(mockConsola.log).toHaveBeenCalledWith('  web: 1.2.2');
-        expect(mockConsola.info).toHaveBeenCalledWith('Syncing all platforms to highest version: 1.2.3 (hotfix: 5)...');
-        expect(mockConsola.success).toHaveBeenCalledWith('All platforms synced to version 1.2.3 (hotfix: 5)');
-    });
-    it('should handle no platform versions found', async () => {
-        mockVersionService.getAllVersions.mockResolvedValue([]);
-        await expect(syncCommand.action({}, undefined)).rejects.toThrow(CliError);
-        await expect(syncCommand.action({}, undefined)).rejects.toThrow('No platform versions found');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-    it('should handle service errors', async () => {
-        const mockVersions = [
-            {
-                platform: 'ios',
-                version: { major: 1, minor: 2, patch: 3, hotfix: 0 },
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            },
-        ];
-        mockVersionService.getAllVersions.mockResolvedValue(mockVersions);
-        mockVersionService.getHighestVersion.mockRejectedValue(new Error('Failed to determine highest version'));
-        await expect(syncCommand.action({}, undefined)).rejects.toThrow('Failed to determine highest version');
-        expect(mockVersionService.setVersion).not.toHaveBeenCalled();
-    });
-});

package/dist/services/mutate/version.js

@@ -1,213 +0,0 @@
-import { CliError } from '../../utils/error.js';
-import { compareVersions, parseBuildNumber, parseVersion, versionToBuildNumber, versionToString, } from '../../utils/version.js';
-import { MobileProject, Logger } from '@trapezedev/project';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-// Disable Trapeze logging
-Logger.log = () => { };
-Logger.v = () => { };
-Logger.debug = () => { };
-Logger.warn = () => { };
-Logger.error = () => { };
-export class VersionService {
-    projectPath;
-    constructor(projectPath = process.cwd()) {
-        this.projectPath = projectPath;
-    }
-    async getAllVersions() {
-        const versions = [];
-        const iosVersion = await this.getIosVersion();
-        if (iosVersion) {
-            versions.push(iosVersion);
-        }
-        const androidVersion = await this.getAndroidVersion();
-        if (androidVersion) {
-            versions.push(androidVersion);
-        }
-        const webVersion = await this.getWebVersion();
-        if (webVersion) {
-            versions.push(webVersion);
-        }
-        return versions;
-    }
-    async getIosVersion() {
-        const iosPath = join(this.projectPath, 'ios');
-        if (!existsSync(iosPath)) {
-            return null;
-        }
-        try {
-            const project = new MobileProject(this.projectPath, {
-                ios: {
-                    path: 'ios/App',
-                },
-            });
-            await project.load();
-            if (!project.ios) {
-                return null;
-            }
-            const iosProject = project.ios.getPbxProject();
-            if (!iosProject) {
-                return null;
-            }
-            const buildNumber = await project.ios.getBuild(null, null);
-            if (!buildNumber) {
-                return null;
-            }
-            const version = parseBuildNumber(buildNumber);
-            return {
-                platform: 'ios',
-                version,
-                source: 'ios/App/App.xcodeproj/project.pbxproj',
-            };
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    async getAndroidVersion() {
-        const androidPath = join(this.projectPath, 'android');
-        if (!existsSync(androidPath)) {
-            return null;
-        }
-        try {
-            const project = new MobileProject(this.projectPath, {
-                android: {
-                    path: 'android',
-                },
-            });
-            await project.load();
-            if (!project.android) {
-                return null;
-            }
-            const versionCode = await project.android.getVersionCode();
-            if (!versionCode) {
-                return null;
-            }
-            const version = parseBuildNumber(versionCode);
-            return {
-                platform: 'android',
-                version,
-                source: 'android/app/build.gradle',
-            };
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    async getWebVersion() {
-        const packageJsonPath = join(this.projectPath, 'package.json');
-        if (!existsSync(packageJsonPath)) {
-            return null;
-        }
-        try {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            if (!packageJson.version) {
-                return null;
-            }
-            // Web only has version string, no build number (hotfix will always be 0)
-            const version = parseVersion(packageJson.version);
-            return {
-                platform: 'web',
-                version,
-                source: 'package.json',
-            };
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    async setVersion(version) {
-        const iosPath = join(this.projectPath, 'ios');
-        const androidPath = join(this.projectPath, 'android');
-        const packageJsonPath = join(this.projectPath, 'package.json');
-        const project = new MobileProject(this.projectPath, {
-            ios: existsSync(iosPath)
-                ? {
-                    path: 'ios/App',
-                }
-                : undefined,
-            android: existsSync(androidPath)
-                ? {
-                    path: 'android',
-                }
-                : undefined,
-        });
-        await project.load();
-        const versionString = versionToString(version);
-        const buildNumber = versionToBuildNumber(version);
-        if (project.ios) {
-            await project.ios.setVersion(null, null, versionString);
-            await project.ios.setBuild(null, null, buildNumber.toString());
-            const infoPlistPath = await project.ios.getInfoPlist(null, null);
-            if (infoPlistPath) {
-                const infoPlist = await project.ios.getPlistFile(infoPlistPath);
-                if (infoPlist) {
-                    await infoPlist.set({
-                        CFBundleShortVersionString: versionString,
-                        CFBundleVersion: buildNumber.toString(),
-                    });
-                }
-            }
-        }
-        if (project.android) {
-            await project.android.setVersionName(versionString);
-            await project.android.setVersionCode(buildNumber);
-        }
-        if (existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            packageJson.version = versionString;
-            // Web only stores version string, not build number
-            const fs = await import('fs/promises');
-            await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
-        }
-        await project.commit();
-    }
-    async ensureVersionsInSync() {
-        const versions = await this.getAllVersions();
-        const firstVersion = versions && versions[0] ? versions[0].version : null;
-        if (!firstVersion) {
-            throw new CliError('No platform versions found');
-        }
-        // Check major.minor.patch synchronization for all platforms
-        const allVersionsInSync = versions.every((pv) => pv.version.major === firstVersion.major &&
-            pv.version.minor === firstVersion.minor &&
-            pv.version.patch === firstVersion.patch);
-        if (!allVersionsInSync) {
-            const versionStrings = versions.map((pv) => {
-                const versionStr = versionToString(pv.version);
-                const hotfixStr = pv.platform !== 'web' && pv.version.hotfix ? ` (hotfix: ${pv.version.hotfix})` : '';
-                return `${pv.platform}: ${versionStr}${hotfixStr} (${pv.source})`;
-            });
-            throw new CliError(`Versions are not synchronized across platforms:\n${versionStrings.join('\n')}`);
-        }
-        // Check hotfix synchronization between iOS and Android only
-        const iosVersion = versions.find((pv) => pv.platform === 'ios');
-        const androidVersion = versions.find((pv) => pv.platform === 'android');
-        if (iosVersion && androidVersion) {
-            const iosHotfix = iosVersion.version.hotfix || 0;
-            const androidHotfix = androidVersion.version.hotfix || 0;
-            if (iosHotfix !== androidHotfix) {
-                throw new CliError(`Hotfix versions are not synchronized between iOS and Android:\n` +
-                    `iOS: ${versionToString(iosVersion.version)} (hotfix: ${iosHotfix})\n` +
-                    `Android: ${versionToString(androidVersion.version)} (hotfix: ${androidHotfix})`);
-            }
-        }
-        // Return version with hotfix from iOS or Android if available
-        const versionWithHotfix = versions.find((pv) => pv.platform !== 'web' && pv.version.hotfix && pv.version.hotfix > 0);
-        return versionWithHotfix ? versionWithHotfix.version : firstVersion;
-    }
-    async getHighestVersion() {
-        const versions = await this.getAllVersions();
-        if (versions.length === 0) {
-            throw new CliError('No platform versions found');
-        }
-        let highest = versions[0];
-        for (const current of versions) {
-            if (compareVersions(current.version, highest.version) > 0) {
-                highest = current;
-            }
-        }
-        return highest.version;
-    }
-}
-export default new VersionService();

package/dist/utils/error.test.js

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CliError, getMessageFromUnknownError } from './error.js';
-describe('CliError', () => {
-    it('should be an instance of Error', () => {
-        const error = new CliError('Test error');
-        expect(error).toBeInstanceOf(Error);
-        expect(error).toBeInstanceOf(CliError);
-    });
-    it('should have the correct name', () => {
-        const error = new CliError('Test error');
-        expect(error.name).toBe('CliError');
-    });
-    it('should have the correct message', () => {
-        const message = 'This is a test error message';
-        const error = new CliError(message);
-        expect(error.message).toBe(message);
-    });
-});
-describe('getMessageFromUnknownError', () => {
-    it('should handle CliError correctly', () => {
-        const message = 'This is a CLI error';
-        const error = new CliError(message);
-        expect(getMessageFromUnknownError(error)).toBe(message);
-    });
-    it('should handle regular Error', () => {
-        const message = 'This is a regular error';
-        const error = new Error(message);
-        expect(getMessageFromUnknownError(error)).toBe(message);
-    });
-    it('should handle unknown error types', () => {
-        expect(getMessageFromUnknownError('string error')).toBe('An unknown error has occurred.');
-        expect(getMessageFromUnknownError(123)).toBe('An unknown error has occurred.');
-        expect(getMessageFromUnknownError(null)).toBe('An unknown error has occurred.');
-        expect(getMessageFromUnknownError(undefined)).toBe('An unknown error has occurred.');
-    });
-});

package/dist/utils/version.js

@@ -1,96 +0,0 @@
-export const parseVersion = (versionString) => {
-    const parts = versionString.split('.');
-    if (parts.length !== 3) {
-        throw new Error(`Invalid version format: ${versionString}. Expected format: major.minor.patch`);
-    }
-    const major = parseInt(parts[0] || '0', 10);
-    const minor = parseInt(parts[1] || '0', 10);
-    const patch = parseInt(parts[2] || '0', 10);
-    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-        throw new Error(`Invalid version format: ${versionString}. Version parts must be numbers.`);
-    }
-    if (major < 0 || minor < 0 || patch < 0) {
-        throw new Error(`Invalid version format: ${versionString}. Version parts must be non-negative.`);
-    }
-    return { major, minor, patch };
-};
-export const parseBuildNumber = (buildNumber) => {
-    const buildStr = buildNumber.toString();
-    // Build number format: [major][minor:3][patch:2][hotfix:2]
-    // The last 7 digits are always minor(3) + patch(2) + hotfix(2)
-    if (buildStr.length < 8) {
-        throw new Error(`Invalid build number: ${buildNumber}. Build number must be at least 8 digits.`);
-    }
-    const fixedPartStart = buildStr.length - 7;
-    const major = parseInt(buildStr.substring(0, fixedPartStart), 10);
-    const minor = parseInt(buildStr.substring(fixedPartStart, fixedPartStart + 3), 10);
-    const patch = parseInt(buildStr.substring(fixedPartStart + 3, fixedPartStart + 5), 10);
-    const hotfix = parseInt(buildStr.substring(fixedPartStart + 5, fixedPartStart + 7), 10);
-    return { major, minor, patch, hotfix };
-};
-export const versionToString = (version) => {
-    return `${version.major}.${version.minor}.${version.patch}`;
-};
-export const versionToBuildNumber = (version) => {
-    // Build number format: [major][minor:3][patch:2][hotfix:2]
-    // Major version has no limit and uses as many digits as needed
-    const majorStr = version.major.toString();
-    const minor = version.minor.toString().padStart(3, '0');
-    const patch = version.patch.toString().padStart(2, '0');
-    const hotfix = (version.hotfix || 0).toString().padStart(2, '0');
-    if (version.minor > 999) {
-        throw new Error(`Minor version ${version.minor} exceeds maximum value of 999`);
-    }
-    if (version.patch > 99) {
-        throw new Error(`Patch version ${version.patch} exceeds maximum value of 99`);
-    }
-    if (version.hotfix && version.hotfix > 99) {
-        throw new Error(`Hotfix version ${version.hotfix} exceeds maximum value of 99`);
-    }
-    return parseInt(`${majorStr}${minor}${patch}${hotfix}`, 10);
-};
-export const incrementMajor = (version) => {
-    const newMajor = version.major + 1;
-    return { major: newMajor, minor: 0, patch: 0 };
-};
-export const incrementMinor = (version) => {
-    const newMinor = version.minor + 1;
-    if (newMinor > 999) {
-        throw new Error(`Cannot increment minor version: would exceed maximum value of 999`);
-    }
-    return { major: version.major, minor: newMinor, patch: 0 };
-};
-export const incrementPatch = (version) => {
-    const newPatch = version.patch + 1;
-    if (newPatch > 99) {
-        throw new Error(`Cannot increment patch version: would exceed maximum value of 99`);
-    }
-    return { major: version.major, minor: version.minor, patch: newPatch };
-};
-export const incrementHotfix = (version) => {
-    const currentHotfix = version.hotfix || 0;
-    const newHotfix = currentHotfix + 1;
-    if (newHotfix > 99) {
-        throw new Error(`Cannot increment hotfix version: would exceed maximum value of 99`);
-    }
-    return { ...version, hotfix: newHotfix };
-};
-export const compareVersions = (v1, v2) => {
-    if (v1.major !== v2.major)
-        return v1.major - v2.major;
-    if (v1.minor !== v2.minor)
-        return v1.minor - v2.minor;
-    if (v1.patch !== v2.patch)
-        return v1.patch - v2.patch;
-    const h1 = v1.hotfix || 0;
-    const h2 = v2.hotfix || 0;
-    if (h1 !== h2)
-        return h1 - h2;
-    return 0;
-};
-export const versionsEqual = (v1, v2, ignoreHotfix = false) => {
-    if (ignoreHotfix) {
-        return v1.major === v2.major && v1.minor === v2.minor && v1.patch === v2.patch;
-    }
-    return compareVersions(v1, v2) === 0;
-};