@meltstudio/meltctl 2.2.0 → 2.3.0

package/README.md

@@ -82,6 +82,28 @@ Safely removes all Melt-generated files from your project while preserving user-
 - 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/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

@@ -6,6 +6,8 @@ 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);
@@ -14,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')
@@ -41,4 +46,17 @@ projectCommand
     .action(() => {
     return cleanCommand();
 });
-program.parse(process.argv);
+// 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.2.0",
+  "version": "2.3.0",
   "description": "CLI tool for Melt development process automation - initialize and update project configurations",
   "main": "dist/index.js",
   "type": "module",