@meltstudio/meltctl 4.34.0 → 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.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';
@@ -101,29 +102,30 @@ export async function checkAndEnforceUpdate() {
         if (severity === 'none') {
             return;
         }
-        const updateCmd = 'npm install -g @meltstudio/meltctl@latest';
         if (severity === 'patch') {
             // Patch updates: warn but allow continuing
             console.log();
-            console.log(chalk.yellow(`  Update available: ${currentVersion} → ${latestVersion} (run: ${updateCmd})`));
+            console.log(chalk.yellow(`  Update available: ${currentVersion} → ${latestVersion} (run: meltctl update)`));
             console.log();
             return;
         }
-        // Minor/major updates: block until updated
+        // Minor/major updates: offer to update, block if declined
         console.log();
-        console.log(chalk.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        console.log(chalk.red.bold('  ⚠️  Update Required'));
-        console.log(chalk.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.yellow(`  Update required: ${currentVersion} → ${latestVersion}`));
         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(`  ${updateCmd}`));
-        console.log();
-        console.log(chalk.gray('Or with yarn:'));
-        console.log(chalk.cyan('  yarn global add @meltstudio/meltctl@latest'));
+        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.dim('  Please re-run your command.'));
+            console.log();
+            process.exit(0);
+        }
         console.log();
         console.log(chalk.gray('To skip this check (CI/CD), set MELTCTL_SKIP_UPDATE_CHECK=1'));
         console.log();

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

@@ -7,8 +7,15 @@ 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 { confirm } from '@inquirer/prompts';
 import { getCurrentCliVersion, getLatestCliVersion, compareVersions, getUpdateSeverity, isCI, checkAndEnforceUpdate, } from './version-check.js';
 beforeEach(() => {
     vi.clearAllMocks();
@@ -139,17 +146,28 @@ describe('checkAndEnforceUpdate', () => {
         await checkAndEnforceUpdate();
         // Should not throw or exit
     });
-    it('blocks on minor version update', 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('blocks on major version update', async () => {
+    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);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "4.34.0",
+  "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",