@meltstudio/meltctl 2.1.0 → 2.3.0

package/README.md

@@ -70,6 +70,40 @@ Updates your project templates to the latest version. This command:
 - Verifies .melt/ workspace migration status
 - Handles version compatibility automatically
 
+### Clean Project
+
+```bash
+meltctl project clean
+```
+
+Safely removes all Melt-generated files from your project while preserving user-created content. This command:
+- Removes the entire `.melt/` directory (all Melt-generated content)
+- Selectively removes only Melt commands from `.cursor/commands/`
+- Preserves user-created files in `.cursor/commands/`
+- Provides interactive confirmation before deletion
+
+### Version Check
+
+```bash
+meltctl version --check
+```
+
+Checks for available updates to the meltctl CLI. This command:
+- Compares your current version with the latest published version
+- Provides update instructions based on your package manager (npm/yarn)
+- Handles network errors gracefully
+
+### CI/CD Usage
+
+For automated environments (CI/CD pipelines), you can skip the update check that runs before every command:
+
+```bash
+export MELTCTL_SKIP_UPDATE_CHECK=1
+meltctl project init
+```
+
+This environment variable bypasses the automatic update enforcement that normally prevents running commands with outdated versions.
+
 ## 🛠️ Requirements
 
 - Node.js 22+ (works with Node.js 18+ but 22+ recommended)

package/dist/commands/project/clean.d.ts

@@ -0,0 +1,5 @@
+interface CleanOptions {
+    placeholder?: never;
+}
+export declare function cleanCommand(_options?: CleanOptions): Promise<void>;
+export {};

package/dist/commands/project/clean.js

@@ -0,0 +1,239 @@
+import { intro, outro, confirm, spinner } from '@clack/prompts';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+// List of Melt-generated command files to remove
+const MELT_COMMAND_FILES = [
+    'melt-plan.md',
+    'melt-test-plan.md',
+    'melt-docs.md',
+    'melt-implement.md',
+    'melt-pr.md',
+    'melt-review.md',
+    'melt-complete.md',
+    'melt-debug.md',
+];
+export async function cleanCommand(_options = {}) {
+    intro(chalk.blue('🧹 Melt Project - Clean'));
+    const currentDir = process.cwd();
+    const meltDir = path.join(currentDir, '.melt');
+    const cursorCommandsDir = path.join(currentDir, '.cursor', 'commands');
+    // Check if this is a Melt workspace
+    const hasMeltWorkspace = await fs.pathExists(meltDir);
+    const hasCursorCommands = await fs.pathExists(cursorCommandsDir);
+    if (!hasMeltWorkspace && !hasCursorCommands) {
+        console.log(chalk.yellow('⚠️  No Melt workspace found in this directory.'));
+        console.log("This project doesn't appear to have Melt tools installed.");
+        outro(chalk.gray('Nothing to clean.'));
+        return;
+    }
+    // Analyze what will be cleaned
+    const analysisResult = await analyzeCleanupTarget(currentDir);
+    if (analysisResult.removedFiles.length === 0 && analysisResult.removedDirs.length === 0) {
+        console.log(chalk.yellow('⚠️  No Melt files found to clean.'));
+        outro(chalk.gray('Nothing to clean.'));
+        return;
+    }
+    // Show what will be cleaned
+    displayCleanupPlan(analysisResult);
+    // Get confirmation
+    const shouldProceed = await confirm({
+        message: 'Do you want to proceed with cleaning? This action cannot be undone.',
+    });
+    if (!shouldProceed) {
+        outro(chalk.gray('Clean operation cancelled.'));
+        return;
+    }
+    // Perform the cleanup
+    const s = spinner();
+    s.start('Cleaning Melt workspace...');
+    try {
+        const cleanResult = await performCleanup(currentDir);
+        s.stop('✅ Cleanup completed!');
+        displayCleanupResults(cleanResult);
+        outro(chalk.green('🎉 Melt workspace cleaned successfully!'));
+    }
+    catch (error) {
+        s.stop('❌ Cleanup failed');
+        console.error(chalk.red('Error during cleanup:'), error);
+        process.exit(1);
+    }
+}
+async function analyzeCleanupTarget(baseDir) {
+    const result = {
+        removedFiles: [],
+        removedDirs: [],
+        preservedFiles: [],
+        errors: [],
+    };
+    const meltDir = path.join(baseDir, '.melt');
+    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
+    try {
+        // Check .melt directory (remove entirely)
+        if (await fs.pathExists(meltDir)) {
+            result.removedDirs.push('.melt/');
+        }
+        // Check .cursor/commands directory (selective removal)
+        if (await fs.pathExists(cursorCommandsDir)) {
+            const commandFiles = await fs.readdir(cursorCommandsDir);
+            for (const file of commandFiles) {
+                const filePath = path.join(cursorCommandsDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isFile()) {
+                    if (MELT_COMMAND_FILES.includes(file)) {
+                        result.removedFiles.push(path.join('.cursor/commands', file));
+                    }
+                    else {
+                        result.preservedFiles.push(path.join('.cursor/commands', file));
+                    }
+                }
+            }
+            // Check if .cursor/commands will be empty after cleaning
+            const meltFiles = commandFiles.filter(file => MELT_COMMAND_FILES.includes(file));
+            const nonMeltFiles = commandFiles.filter(file => !MELT_COMMAND_FILES.includes(file));
+            if (meltFiles.length > 0 && nonMeltFiles.length === 0) {
+                result.removedDirs.push('.cursor/commands/');
+                // Also check if .cursor itself would be empty
+                const cursorDir = path.join(baseDir, '.cursor');
+                const cursorContents = await fs.readdir(cursorDir);
+                if (cursorContents.length === 1 && cursorContents[0] === 'commands') {
+                    result.removedDirs.push('.cursor/');
+                }
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to analyze cleanup target: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+async function performCleanup(baseDir) {
+    const result = {
+        removedFiles: [],
+        removedDirs: [],
+        preservedFiles: [],
+        errors: [],
+    };
+    const meltDir = path.join(baseDir, '.melt');
+    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
+    try {
+        // Remove .melt directory entirely
+        if (await fs.pathExists(meltDir)) {
+            await fs.remove(meltDir);
+            result.removedDirs.push('.melt/');
+        }
+        // Remove Melt command files from .cursor/commands
+        if (await fs.pathExists(cursorCommandsDir)) {
+            const commandFiles = await fs.readdir(cursorCommandsDir);
+            let hasNonMeltFiles = false;
+            for (const file of commandFiles) {
+                const filePath = path.join(cursorCommandsDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isFile()) {
+                    if (MELT_COMMAND_FILES.includes(file)) {
+                        try {
+                            await fs.remove(filePath);
+                            result.removedFiles.push(path.join('.cursor/commands', file));
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to remove ${file}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    else {
+                        hasNonMeltFiles = true;
+                        result.preservedFiles.push(path.join('.cursor/commands', file));
+                    }
+                }
+            }
+            // Remove empty directories if no user files remain
+            if (!hasNonMeltFiles) {
+                try {
+                    await fs.remove(cursorCommandsDir);
+                    result.removedDirs.push('.cursor/commands/');
+                    // Check if .cursor directory is now empty
+                    const cursorDir = path.join(baseDir, '.cursor');
+                    if (await fs.pathExists(cursorDir)) {
+                        const cursorContents = await fs.readdir(cursorDir);
+                        if (cursorContents.length === 0) {
+                            await fs.remove(cursorDir);
+                            result.removedDirs.push('.cursor/');
+                        }
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Failed to remove empty directories: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+function displayCleanupPlan(result) {
+    console.log();
+    console.log(chalk.cyan('📋 Cleanup Plan:'));
+    console.log();
+    if (result.removedDirs.length > 0) {
+        console.log(chalk.yellow('Directories to be removed:'));
+        result.removedDirs.forEach(dir => {
+            console.log(`  • ${chalk.red(dir)}`);
+        });
+        console.log();
+    }
+    if (result.removedFiles.length > 0) {
+        console.log(chalk.yellow('Files to be removed:'));
+        result.removedFiles.forEach(file => {
+            console.log(`  • ${chalk.red(file)}`);
+        });
+        console.log();
+    }
+    if (result.preservedFiles.length > 0) {
+        console.log(chalk.green('Files to be preserved:'));
+        result.preservedFiles.forEach(file => {
+            console.log(`  • ${chalk.cyan(file)}`);
+        });
+        console.log();
+    }
+    if (result.errors.length > 0) {
+        console.log(chalk.red('Analysis errors:'));
+        result.errors.forEach(error => {
+            console.log(`  ⚠️  ${error}`);
+        });
+        console.log();
+    }
+}
+function displayCleanupResults(result) {
+    console.log();
+    console.log(chalk.green('🎯 Cleanup Summary:'));
+    console.log();
+    if (result.removedDirs.length > 0) {
+        console.log(chalk.green(`✅ Removed ${result.removedDirs.length} directories:`));
+        result.removedDirs.forEach(dir => {
+            console.log(`   • ${dir}`);
+        });
+        console.log();
+    }
+    if (result.removedFiles.length > 0) {
+        console.log(chalk.green(`✅ Removed ${result.removedFiles.length} files:`));
+        result.removedFiles.forEach(file => {
+            console.log(`   • ${file}`);
+        });
+        console.log();
+    }
+    if (result.preservedFiles.length > 0) {
+        console.log(chalk.cyan(`🔒 Preserved ${result.preservedFiles.length} user files:`));
+        result.preservedFiles.forEach(file => {
+            console.log(`   • ${file}`);
+        });
+        console.log();
+    }
+    if (result.errors.length > 0) {
+        console.log(chalk.red(`❌ Errors encountered (${result.errors.length}):`));
+        result.errors.forEach(error => {
+            console.log(`   • ${error}`);
+        });
+        console.log();
+    }
+}

package/dist/commands/project/update.js

@@ -4,66 +4,15 @@ import { execSync } from 'child_process';
 import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { getCurrentCliVersion, getLatestCliVersion, compareVersions, } from '../../utils/version-check.js';
+import { detectPackageManager } from '../../utils/package-manager.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function getCurrentCliVersion() {
-    const packagePath = path.join(__dirname, '../../../package.json');
-    const packageJson = await fs.readJson(packagePath);
-    return packageJson.version;
-}
-async function getLatestCliVersion() {
-    try {
-        const result = execSync('npm view @meltstudio/meltctl version --json', {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        return JSON.parse(result.trim());
-    }
-    catch (error) {
-        console.error(chalk.red('Failed to check latest version from npm registry'));
-        throw error;
-    }
-}
-function compareVersions(current, latest) {
-    // Parse semver strings, handling pre-release tags
-    const parseVersion = (version) => {
-        const [base, prerelease] = version.split('-');
-        const parts = (base || '').split('.').map(Number);
-        return {
-            major: parts[0] || 0,
-            minor: parts[1] || 0,
-            patch: parts[2] || 0,
-            prerelease: prerelease || null,
-        };
-    };
-    const currentVer = parseVersion(current);
-    const latestVer = parseVersion(latest);
-    // Compare major.minor.patch first
-    if (latestVer.major !== currentVer.major) {
-        return latestVer.major > currentVer.major;
-    }
-    if (latestVer.minor !== currentVer.minor) {
-        return latestVer.minor > currentVer.minor;
-    }
-    if (latestVer.patch !== currentVer.patch) {
-        return latestVer.patch > currentVer.patch;
-    }
-    // If base versions are equal, handle pre-release comparison
-    // No pre-release (stable) > pre-release
-    if (!latestVer.prerelease && currentVer.prerelease)
-        return true;
-    if (latestVer.prerelease && !currentVer.prerelease)
-        return false;
-    // Both have pre-release or both are stable
-    if (latestVer.prerelease && currentVer.prerelease) {
-        return latestVer.prerelease > currentVer.prerelease;
-    }
-    return false; // Versions are equal
-}
 async function updateCliPackage() {
     const s = spinner();
     s.start('Updating @meltstudio/meltctl package...');
     try {
-        execSync('npm install -g @meltstudio/meltctl@latest', {
+        const { updateCommand } = detectPackageManager();
+        execSync(updateCommand, {
             stdio: 'pipe',
         });
         s.stop('CLI package updated successfully!');
@@ -115,22 +64,29 @@ export async function updateCommand() {
     try {
         const currentVersion = await getCurrentCliVersion();
         const latestVersion = await getLatestCliVersion();
-        console.log(chalk.gray(`Current CLI version: ${currentVersion}`));
-        console.log(chalk.gray(`Latest CLI version: ${latestVersion}`));
-        console.log();
-        if (compareVersions(currentVersion, latestVersion)) {
-            console.log(chalk.yellow(`📦 New version available: ${latestVersion}`));
-            const shouldUpdate = await confirm({
-                message: 'Would you like to update the CLI package?',
-            });
-            if (shouldUpdate) {
-                await updateCliPackage();
-                console.log();
-            }
+        if (!latestVersion) {
+            console.log(chalk.yellow('⚠️  Unable to check for updates (network error)'));
+            console.log(chalk.gray(`Current CLI version: ${currentVersion}`));
+            console.log();
         }
         else {
-            console.log(chalk.green('✅ CLI package is up to date'));
+            console.log(chalk.gray(`Current CLI version: ${currentVersion}`));
+            console.log(chalk.gray(`Latest CLI version: ${latestVersion}`));
             console.log();
+            if (compareVersions(currentVersion, latestVersion)) {
+                console.log(chalk.yellow(`📦 New version available: ${latestVersion}`));
+                const shouldUpdate = await confirm({
+                    message: 'Would you like to update the CLI package?',
+                });
+                if (shouldUpdate) {
+                    await updateCliPackage();
+                    console.log();
+                }
+            }
+            else {
+                console.log(chalk.green('✅ CLI package is up to date'));
+                console.log();
+            }
         }
         const shouldUpdateCommands = await confirm({
             message: 'Would you like to update .cursor/commands/ with latest prompts?',

package/dist/commands/version.d.ts

@@ -0,0 +1 @@
+export declare function versionCheckCommand(): Promise<void>;

package/dist/commands/version.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { getCurrentCliVersion, getLatestCliVersion, compareVersions, } from '../utils/version-check.js';
+import { getUpdateInstructions } from '../utils/package-manager.js';
+export async function versionCheckCommand() {
+    try {
+        const currentVersion = await getCurrentCliVersion();
+        const latestVersion = await getLatestCliVersion();
+        if (!latestVersion) {
+            console.log(chalk.yellow('⚠️  Unable to check for updates (network error)'));
+            console.log(chalk.gray(`Current version: ${currentVersion}`));
+            return;
+        }
+        if (compareVersions(currentVersion, latestVersion)) {
+            // Update available
+            console.log(chalk.yellow(`⚠  Update available: ${currentVersion} → ${latestVersion}`));
+            console.log();
+            console.log(chalk.white('To update, run:'));
+            const instructions = getUpdateInstructions();
+            instructions.forEach((instruction, index) => {
+                if (index === 0) {
+                    console.log(chalk.cyan(`  ${instruction}`));
+                }
+                else if (instruction === '') {
+                    console.log();
+                }
+                else if (instruction.startsWith('Or with')) {
+                    console.log(chalk.gray(instruction));
+                }
+                else {
+                    console.log(chalk.cyan(instruction));
+                }
+            });
+        }
+        else {
+            // Up to date
+            console.log(chalk.green(`✓ meltctl ${currentVersion} is up to date`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to check for updates:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -5,6 +5,9 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { initCommand } from './commands/project/init.js';
 import { updateCommand } from './commands/project/update.js';
+import { cleanCommand } from './commands/project/clean.js';
+import { checkAndEnforceUpdate } from './utils/version-check.js';
+import { versionCheckCommand } from './commands/version.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -13,7 +16,10 @@ const program = new Command();
 program
     .name('meltctl')
     .description('CLI tool for Melt development process automation')
-    .version(packageJson.version);
+    .version(packageJson.version)
+    .hook('preAction', async () => {
+    await checkAndEnforceUpdate();
+});
 // Project management commands
 const projectCommand = program
     .command('project')
@@ -34,4 +40,23 @@ projectCommand
     .command('update')
     .description('Update project configurations to latest version')
     .action(updateCommand);
-program.parse(process.argv);
+projectCommand
+    .command('clean')
+    .description('Remove all Melt-generated files from the project')
+    .action(() => {
+    return cleanCommand();
+});
+// Version check command
+program
+    .command('version')
+    .description('Display version information')
+    .option('--check', 'check for updates')
+    .action(async (options) => {
+    if (options.check) {
+        await versionCheckCommand();
+    }
+    else {
+        console.log(packageJson.version);
+    }
+});
+program.parseAsync(process.argv);

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,7 @@
+export type PackageManager = 'npm' | 'yarn' | 'unknown';
+export interface PackageManagerInfo {
+    type: PackageManager;
+    updateCommand: string;
+}
+export declare function detectPackageManager(): PackageManagerInfo;
+export declare function getUpdateInstructions(): string[];

package/dist/utils/package-manager.js

@@ -0,0 +1,55 @@
+import { execSync } from 'child_process';
+export function detectPackageManager() {
+    // Try to detect if meltctl is installed via npm or yarn
+    try {
+        // Check npm global installation
+        execSync('npm list -g @meltstudio/meltctl', {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return {
+            type: 'npm',
+            updateCommand: 'npm install -g @meltstudio/meltctl@latest',
+        };
+    }
+    catch {
+        // npm check failed, try yarn
+    }
+    try {
+        // Check yarn global installation
+        execSync('yarn global list @meltstudio/meltctl', {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return {
+            type: 'yarn',
+            updateCommand: 'yarn global add @meltstudio/meltctl@latest',
+        };
+    }
+    catch {
+        // yarn check failed
+    }
+    // Default to npm if detection fails
+    return {
+        type: 'unknown',
+        updateCommand: 'npm install -g @meltstudio/meltctl@latest',
+    };
+}
+export function getUpdateInstructions() {
+    const { type, updateCommand } = detectPackageManager();
+    if (type === 'npm') {
+        return [updateCommand, '', 'Or with yarn:', '  yarn global add @meltstudio/meltctl@latest'];
+    }
+    else if (type === 'yarn') {
+        return [updateCommand, '', 'Or with npm:', '  npm install -g @meltstudio/meltctl@latest'];
+    }
+    else {
+        // Unknown, show both options
+        return [
+            'npm install -g @meltstudio/meltctl@latest',
+            '',
+            'Or with yarn:',
+            '  yarn global add @meltstudio/meltctl@latest',
+        ];
+    }
+}

package/dist/utils/version-check.d.ts

@@ -0,0 +1,5 @@
+export declare function getCurrentCliVersion(): Promise<string>;
+export declare function getLatestCliVersion(): Promise<string | null>;
+export declare function compareVersions(current: string, latest: string): boolean;
+export declare function isCI(): boolean;
+export declare function checkAndEnforceUpdate(): Promise<void>;

package/dist/utils/version-check.js

@@ -0,0 +1,114 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function getCurrentCliVersion() {
+    const packagePath = path.join(__dirname, '../../package.json');
+    const packageJson = await fs.readJson(packagePath);
+    return packageJson.version;
+}
+export async function getLatestCliVersion() {
+    try {
+        const result = execSync('npm view @meltstudio/meltctl version --json', {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 5000, // 5 second timeout
+        });
+        return JSON.parse(result.trim());
+    }
+    catch {
+        // Network error or timeout - return null to indicate check failed
+        return null;
+    }
+}
+export function compareVersions(current, latest) {
+    // Parse semver strings, handling pre-release tags
+    const parseVersion = (version) => {
+        const [base, prerelease] = version.split('-');
+        const parts = (base || '').split('.').map(Number);
+        return {
+            major: parts[0] || 0,
+            minor: parts[1] || 0,
+            patch: parts[2] || 0,
+            prerelease: prerelease || null,
+        };
+    };
+    const currentVer = parseVersion(current);
+    const latestVer = parseVersion(latest);
+    // Compare major.minor.patch first
+    if (latestVer.major !== currentVer.major) {
+        return latestVer.major > currentVer.major;
+    }
+    if (latestVer.minor !== currentVer.minor) {
+        return latestVer.minor > currentVer.minor;
+    }
+    if (latestVer.patch !== currentVer.patch) {
+        return latestVer.patch > currentVer.patch;
+    }
+    // If base versions are equal, handle pre-release comparison
+    // No pre-release (stable) > pre-release
+    if (!latestVer.prerelease && currentVer.prerelease)
+        return true;
+    if (latestVer.prerelease && !currentVer.prerelease)
+        return false;
+    // Both have pre-release or both are stable
+    if (latestVer.prerelease && currentVer.prerelease) {
+        return latestVer.prerelease > currentVer.prerelease;
+    }
+    return false; // Versions are equal
+}
+export function isCI() {
+    // Check common CI environment variables
+    return !!(process.env.CI || // Generic CI flag
+        process.env.GITHUB_ACTIONS || // GitHub Actions
+        process.env.GITLAB_CI || // GitLab CI
+        process.env.CIRCLECI || // CircleCI
+        process.env.TRAVIS || // Travis CI
+        process.env.JENKINS_URL || // Jenkins
+        process.env.BUILDKITE || // Buildkite
+        process.env.DRONE || // Drone
+        process.env.MELTCTL_SKIP_UPDATE_CHECK // Custom override
+    );
+}
+export async function checkAndEnforceUpdate() {
+    // Skip update check in CI environments
+    if (isCI()) {
+        return;
+    }
+    try {
+        const currentVersion = await getCurrentCliVersion();
+        const latestVersion = await getLatestCliVersion();
+        // If we can't fetch latest version (network error), allow continuing
+        if (!latestVersion) {
+            return;
+        }
+        // Check if update is needed
+        if (compareVersions(currentVersion, latestVersion)) {
+            console.log();
+            console.log(chalk.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            console.log(chalk.red.bold('  ⚠️  Update Required'));
+            console.log(chalk.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+            console.log();
+            console.log(chalk.yellow(`Current version: ${currentVersion}`));
+            console.log(chalk.green(`Latest version:  ${latestVersion}`));
+            console.log();
+            console.log(chalk.white('Please update meltctl to continue:'));
+            console.log();
+            console.log(chalk.cyan('  npm install -g @meltstudio/meltctl@latest'));
+            console.log();
+            console.log(chalk.gray('Or with yarn:'));
+            console.log(chalk.cyan('  yarn global add @meltstudio/meltctl@latest'));
+            console.log();
+            console.log(chalk.gray('To skip this check (CI/CD), set MELTCTL_SKIP_UPDATE_CHECK=1'));
+            console.log();
+            process.exit(1);
+        }
+    }
+    catch {
+        // If any error occurs during version check, allow continuing
+        // This ensures the CLI remains usable even if version check fails
+        return;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "CLI tool for Melt development process automation - initialize and update project configurations",
   "main": "dist/index.js",
   "type": "module",