@meltstudio/meltctl 4.33.2 → 4.35.0

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare function detectPackageManager(): 'npm' | 'yarn' | 'unknown';
+export declare function updateCommand(): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getCurrentCliVersion, getLatestCliVersion, getUpdateSeverity, } from '../utils/version-check.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function detectPackageManager() {
+    const installPath = path.resolve(__dirname, '../..');
+    try {
+        const npmGlobalPrefix = execSync('npm prefix -g', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (installPath.startsWith(npmGlobalPrefix)) {
+            return 'npm';
+        }
+    }
+    catch {
+        // npm not available
+    }
+    try {
+        const yarnGlobalDir = execSync('yarn global dir', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (installPath.startsWith(yarnGlobalDir)) {
+            return 'yarn';
+        }
+    }
+    catch {
+        // yarn not available
+    }
+    // Check path heuristics as fallback
+    if (installPath.includes('yarn'))
+        return 'yarn';
+    if (installPath.includes('npm'))
+        return 'npm';
+    return 'unknown';
+}
+export async function updateCommand() {
+    const currentVersion = await getCurrentCliVersion();
+    const latestVersion = await getLatestCliVersion();
+    if (!latestVersion) {
+        console.error(chalk.red('Could not check for updates. Check your network connection.'));
+        process.exit(1);
+    }
+    const severity = getUpdateSeverity(currentVersion, latestVersion);
+    if (severity === 'none') {
+        console.log(chalk.green(`  ✓ Already on the latest version (${currentVersion})`));
+        return;
+    }
+    console.log(chalk.dim(`  ${currentVersion} → ${latestVersion}`));
+    console.log();
+    const pm = detectPackageManager();
+    let cmd;
+    if (pm === 'yarn') {
+        cmd = 'yarn global add @meltstudio/meltctl@latest';
+    }
+    else if (pm === 'npm') {
+        cmd = 'npm install -g @meltstudio/meltctl@latest';
+    }
+    else {
+        // Unknown install method — try npm as default
+        console.log(chalk.dim('  Could not detect package manager, trying npm...'));
+        cmd = 'npm install -g @meltstudio/meltctl@latest';
+    }
+    console.log(chalk.dim(`  Running: ${cmd}`));
+    console.log();
+    try {
+        execSync(cmd, { stdio: 'inherit' });
+        console.log();
+        console.log(chalk.green(`  ✓ Updated to ${latestVersion}`));
+    }
+    catch {
+        console.error();
+        console.error(chalk.red('  Update failed. Try running manually:'));
+        console.error(chalk.cyan(`    ${cmd}`));
+        process.exit(1);
+    }
+}

package/dist/commands/update.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/update.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        readJson: vi.fn(),
+    },
+}));
+vi.mock('../utils/version-check.js', () => ({
+    getCurrentCliVersion: vi.fn(),
+    getLatestCliVersion: vi.fn(),
+    getUpdateSeverity: vi.fn(),
+}));
+import { execSync } from 'child_process';
+import { getCurrentCliVersion, getLatestCliVersion, getUpdateSeverity, } from '../utils/version-check.js';
+import { updateCommand, detectPackageManager } from './update.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+});
+describe('detectPackageManager', () => {
+    it('returns npm when install path matches npm prefix', () => {
+        ;
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            throw new Error('not found');
+        });
+        // This test depends on the actual install path, so just verify it returns a valid value
+        const result = detectPackageManager();
+        expect(['npm', 'yarn', 'unknown']).toContain(result);
+    });
+    it('returns unknown when neither npm nor yarn detected', () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('not found');
+        });
+        const result = detectPackageManager();
+        expect(['npm', 'yarn', 'unknown']).toContain(result);
+    });
+});
+describe('updateCommand', () => {
+    it('prints already up to date when on latest', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('none');
+        await updateCommand();
+        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+        expect(logCalls.some((msg) => msg.includes('Already on the latest'))).toBe(true);
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+    it('exits when latest version cannot be fetched', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue(null);
+        await updateCommand();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it('runs npm install when update available and npm detected', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.33.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('minor');
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            if (cmd.startsWith('npm install -g'))
+                return '';
+            throw new Error('not found');
+        });
+        await updateCommand();
+        expect(execSync).toHaveBeenCalledWith('npm install -g @meltstudio/meltctl@latest', {
+            stdio: 'inherit',
+        });
+    });
+    it('exits with error when install command fails', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.33.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('minor');
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            if (cmd.startsWith('npm install -g'))
+                throw new Error('permission denied');
+            throw new Error('not found');
+        });
+        await updateCommand();
+        expect(process.exit).toHaveBeenCalledWith(1);
+        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
+        expect(errorCalls.some((msg) => msg.includes('Update failed'))).toBe(true);
+    });
+});

package/dist/index.js

@@ -16,6 +16,7 @@ import { feedbackCommand } from './commands/feedback.js';
 import { coinsCommand } from './commands/coins.js';
 import { auditSubmitCommand, auditListCommand, auditViewCommand } from './commands/audit.js';
 import { planSubmitCommand, planListCommand } from './commands/plan.js';
+import { updateCommand } from './commands/update.js';
 import { trackCommand } from './utils/analytics.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -186,6 +187,12 @@ plan
     .action(async (options) => {
     await planListCommand(options);
 });
+program
+    .command('update')
+    .description('update meltctl to the latest version')
+    .action(async () => {
+    await updateCommand();
+});
 program
     .command('version')
     .description('show current version')

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

@@ -2,4 +2,6 @@ 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 type UpdateSeverity = 'none' | 'patch' | 'minor' | 'major';
+export declare function getUpdateSeverity(current: string, latest: string): UpdateSeverity;
 export declare function checkAndEnforceUpdate(): Promise<void>;

package/dist/utils/version-check.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
 import { execSync } from 'child_process';
 import fs from 'fs-extra';
 import path from 'path';
@@ -72,6 +73,19 @@ export function isCI() {
         process.env.MELTCTL_SKIP_UPDATE_CHECK // Custom override
     );
 }
+export function getUpdateSeverity(current, latest) {
+    const parseCurrent = current.split('-')[0].split('.').map(Number);
+    const parseLatest = latest.split('-')[0].split('.').map(Number);
+    const [curMajor = 0, curMinor = 0, curPatch = 0] = parseCurrent;
+    const [latMajor = 0, latMinor = 0, latPatch = 0] = parseLatest;
+    if (latMajor > curMajor)
+        return 'major';
+    if (latMajor === curMajor && latMinor > curMinor)
+        return 'minor';
+    if (latMajor === curMajor && latMinor === curMinor && latPatch > curPatch)
+        return 'patch';
+    return 'none';
+}
 export async function checkAndEnforceUpdate() {
     // Skip update check in CI environments
     if (isCI()) {
@@ -84,27 +98,38 @@ export async function checkAndEnforceUpdate() {
         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:'));
+        const severity = getUpdateSeverity(currentVersion, latestVersion);
+        if (severity === 'none') {
+            return;
+        }
+        if (severity === 'patch') {
+            // Patch updates: warn but allow continuing
             console.log();
-            console.log(chalk.cyan('  npm install -g @meltstudio/meltctl@latest'));
+            console.log(chalk.yellow(`  Update available: ${currentVersion} → ${latestVersion} (run: meltctl update)`));
             console.log();
-            console.log(chalk.gray('Or with yarn:'));
-            console.log(chalk.cyan('  yarn global add @meltstudio/meltctl@latest'));
+            return;
+        }
+        // Minor/major updates: offer to update, block if declined
+        console.log();
+        console.log(chalk.yellow(`  Update required: ${currentVersion} → ${latestVersion}`));
+        console.log();
+        const shouldUpdate = await confirm({
+            message: 'Update now?',
+            default: true,
+        });
+        if (shouldUpdate) {
+            const { updateCommand } = await import('../commands/update.js');
+            await updateCommand();
+            // Re-run the original command after update
             console.log();
-            console.log(chalk.gray('To skip this check (CI/CD), set MELTCTL_SKIP_UPDATE_CHECK=1'));
+            console.log(chalk.dim('  Please re-run your command.'));
             console.log();
-            process.exit(1);
+            process.exit(0);
         }
+        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

package/dist/utils/version-check.test.js

@@ -7,9 +7,16 @@ vi.mock('fs-extra', () => ({
         readJson: vi.fn(),
     },
 }));
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn(),
+}));
+vi.mock('../commands/update.js', () => ({
+    updateCommand: vi.fn().mockResolvedValue(undefined),
+}));
 import { execSync } from 'child_process';
 import fs from 'fs-extra';
-import { getCurrentCliVersion, getLatestCliVersion, compareVersions, isCI, checkAndEnforceUpdate, } from './version-check.js';
+import { confirm } from '@inquirer/prompts';
+import { getCurrentCliVersion, getLatestCliVersion, compareVersions, getUpdateSeverity, isCI, checkAndEnforceUpdate, } from './version-check.js';
 beforeEach(() => {
     vi.clearAllMocks();
     vi.spyOn(console, 'log').mockImplementation(() => { });
@@ -96,6 +103,26 @@ describe('isCI', () => {
         expect(isCI()).toBe(true);
     });
 });
+describe('getUpdateSeverity', () => {
+    it('returns major when major version is higher', () => {
+        expect(getUpdateSeverity('1.0.0', '2.0.0')).toBe('major');
+    });
+    it('returns minor when minor version is higher', () => {
+        expect(getUpdateSeverity('1.0.0', '1.1.0')).toBe('minor');
+    });
+    it('returns patch when only patch is higher', () => {
+        expect(getUpdateSeverity('1.0.0', '1.0.1')).toBe('patch');
+    });
+    it('returns none when versions are equal', () => {
+        expect(getUpdateSeverity('1.0.0', '1.0.0')).toBe('none');
+    });
+    it('returns none when current is newer', () => {
+        expect(getUpdateSeverity('2.0.0', '1.0.0')).toBe('none');
+    });
+    it('returns major over minor', () => {
+        expect(getUpdateSeverity('1.5.3', '2.0.0')).toBe('major');
+    });
+});
 describe('checkAndEnforceUpdate', () => {
     it('skips check in CI environment', async () => {
         process.env.CI = 'true';
@@ -119,13 +146,40 @@ describe('checkAndEnforceUpdate', () => {
         await checkAndEnforceUpdate();
         // Should not throw or exit
     });
-    it('calls process.exit when update is required', async () => {
+    it('exits when user declines update on minor bump', async () => {
         const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
         fs.readJson.mockResolvedValue({ version: '4.25.0' });
         execSync.mockReturnValue('"4.26.0"\n');
+        vi.mocked(confirm).mockResolvedValue(false);
         await checkAndEnforceUpdate();
+        expect(confirm).toHaveBeenCalled();
         expect(exitSpy).toHaveBeenCalledWith(1);
     });
+    it('runs update when user accepts on minor bump', async () => {
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        fs.readJson.mockResolvedValue({ version: '4.25.0' });
+        execSync.mockReturnValue('"4.26.0"\n');
+        vi.mocked(confirm).mockResolvedValue(true);
+        await checkAndEnforceUpdate();
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+    it('exits when user declines update on major bump', async () => {
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        fs.readJson.mockResolvedValue({ version: '4.33.0' });
+        execSync.mockReturnValue('"5.0.0"\n');
+        vi.mocked(confirm).mockResolvedValue(false);
+        await checkAndEnforceUpdate();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('warns but does not block on patch update', async () => {
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        fs.readJson.mockResolvedValue({ version: '4.33.0' });
+        execSync.mockReturnValue('"4.33.2"\n');
+        await checkAndEnforceUpdate();
+        expect(exitSpy).not.toHaveBeenCalled();
+        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+        expect(logCalls.some((msg) => msg.includes('Update available'))).toBe(true);
+    });
     it('allows continuing when getCurrentCliVersion throws', async () => {
         ;
         fs.readJson.mockRejectedValue(new Error('file not found'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.33.2",
+  "version": "4.35.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and OpenCode standards",
   "main": "dist/index.js",
   "type": "module",