@meltstudio/meltctl 4.38.0 → 4.39.0

package/dist/commands/standup.js

@@ -1,74 +0,0 @@
-import chalk from 'chalk';
-import { input, editor } from '@inquirer/prompts';
-import { isAuthenticated } from '../utils/auth.js';
-import { getClient } from '../utils/api.js';
-const EDITOR_HINT = chalk.dim('(type \\e to open your editor)');
-async function promptField(message, required) {
-    const value = await input({ message: `${message} ${EDITOR_HINT}` });
-    if (value === '\\e') {
-        try {
-            return await editor({ message });
-        }
-        catch {
-            console.log(chalk.yellow('Editor failed to open. Falling back to inline input.'));
-            return promptField(message, required);
-        }
-    }
-    if (required && !value.trim()) {
-        console.log(chalk.yellow('This field is required.'));
-        return promptField(message, required);
-    }
-    return value;
-}
-export async function standupCommand(options) {
-    if (!(await isAuthenticated())) {
-        console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
-        process.exit(1);
-    }
-    const client = await getClient();
-    // Check if already submitted today
-    try {
-        const existing = await client.standups.getStatus();
-        if (existing) {
-            console.log(chalk.yellow('\nYou already submitted a standup today:\n'));
-            console.log(chalk.bold('Yesterday:'), existing.yesterday);
-            console.log(chalk.bold('Today:'), existing.today);
-            if (existing.blockers) {
-                console.log(chalk.bold('Blockers:'), existing.blockers);
-            }
-            console.log(chalk.dim('\nTo edit your standup, use the Melt Connect frontend.'));
-            return;
-        }
-    }
-    catch {
-        // Status check failed — continue to submission
-    }
-    let yesterday;
-    let today;
-    let blockers;
-    if (options.yesterday && options.today) {
-        // Hidden flags for E2E testing
-        yesterday = options.yesterday;
-        today = options.today;
-        blockers = options.blockers ?? '';
-    }
-    else {
-        console.log(chalk.bold.cyan('\n  Daily Standup Report\n'));
-        console.log(chalk.dim('  Tip: Mention tickets, PRs, or features by name.\n'));
-        yesterday = await promptField('What did you work on yesterday?', true);
-        today = await promptField('What are you going to work on today?', true);
-        blockers = await promptField('Any blockers? (leave empty if none)', false);
-    }
-    try {
-        await client.standups.submit({
-            yesterday,
-            today,
-            blockers: blockers || undefined,
-        });
-        console.log(chalk.green('\n  ✓ Standup submitted!\n'));
-    }
-    catch (error) {
-        console.error(chalk.red(`\nFailed to submit standup: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        process.exit(1);
-    }
-}

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

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

package/dist/commands/standup.test.js

@@ -1,218 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../utils/auth.js', () => ({
-    isAuthenticated: vi.fn(),
-}));
-const mockClient = vi.hoisted(() => ({
-    standups: {
-        getStatus: vi.fn(),
-        submit: vi.fn(),
-    },
-}));
-vi.mock('../utils/api.js', () => ({
-    getClient: vi.fn().mockResolvedValue(mockClient),
-}));
-vi.mock('@inquirer/prompts', () => ({
-    input: vi.fn(),
-    editor: vi.fn(),
-}));
-import { isAuthenticated } from '../utils/auth.js';
-import { input, editor } from '@inquirer/prompts';
-import { standupCommand } from './standup.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-    vi.spyOn(process, 'exit').mockImplementation((code) => {
-        throw new Error(`process.exit(${code})`);
-    });
-});
-describe('standupCommand', () => {
-    it('exits with error when not authenticated', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(false);
-        await expect(standupCommand({})).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('returns early when standup already submitted today', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.standups.getStatus.mockResolvedValue({
-            yesterday: 'Did stuff',
-            today: 'More stuff',
-            blockers: null,
-        });
-        await standupCommand({});
-        expect(mockClient.standups.getStatus).toHaveBeenCalled();
-        // Should not call submit
-        expect(mockClient.standups.submit).not.toHaveBeenCalled();
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
-    });
-    it('submits standup with correct payload using option flags', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        // Status check returns null (no existing standup)
-        mockClient.standups.getStatus.mockResolvedValue(null);
-        mockClient.standups.submit.mockResolvedValue({});
-        await standupCommand({
-            yesterday: 'Fixed bugs',
-            today: 'Write tests',
-            blockers: 'None',
-        });
-        expect(mockClient.standups.submit).toHaveBeenCalledWith({
-            yesterday: 'Fixed bugs',
-            today: 'Write tests',
-            blockers: 'None',
-        });
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('Standup submitted'))).toBe(true);
-    });
-    it('submits standup without blockers when empty string', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.standups.getStatus.mockResolvedValue(null);
-        mockClient.standups.submit.mockResolvedValue({});
-        await standupCommand({
-            yesterday: 'Did things',
-            today: 'More things',
-        });
-        expect(mockClient.standups.submit).toHaveBeenCalledWith({
-            yesterday: 'Did things',
-            today: 'More things',
-            blockers: undefined,
-        });
-    });
-    it('exits with error when API returns failure', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.standups.getStatus.mockResolvedValue(null);
-        mockClient.standups.submit.mockRejectedValue(new Error('Invalid standup'));
-        await expect(standupCommand({ yesterday: 'x', today: 'y' })).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('continues to submission when status check throws', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.standups.getStatus.mockRejectedValue(new Error('Network error'));
-        mockClient.standups.submit.mockResolvedValue({});
-        await standupCommand({ yesterday: 'a', today: 'b' });
-        expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
-            yesterday: 'a',
-            today: 'b',
-        }));
-    });
-    it('displays existing standup with blockers', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.standups.getStatus.mockResolvedValue({
-            yesterday: 'Bug fixes',
-            today: 'Feature work',
-            blockers: 'Waiting on review',
-        });
-        await standupCommand({});
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
-    });
-    describe('interactive flow', () => {
-        function setupInteractiveAuth() {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            // Status check returns null (no existing standup)
-            mockClient.standups.getStatus.mockResolvedValue(null);
-        }
-        it('prompts for yesterday, today, and blockers in interactive mode', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockResolvedValue({});
-            input
-                .mockResolvedValueOnce('Worked on feature X')
-                .mockResolvedValueOnce('Working on feature Y')
-                .mockResolvedValueOnce('No blockers');
-            await standupCommand({});
-            expect(input).toHaveBeenCalledTimes(3);
-            expect(mockClient.standups.submit).toHaveBeenCalledWith({
-                yesterday: 'Worked on feature X',
-                today: 'Working on feature Y',
-                blockers: 'No blockers',
-            });
-        });
-        it('submits without blockers when left empty in interactive mode', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockResolvedValue({});
-            input
-                .mockResolvedValueOnce('Did code review')
-                .mockResolvedValueOnce('Deploy to staging')
-                .mockResolvedValueOnce('');
-            await standupCommand({});
-            expect(mockClient.standups.submit).toHaveBeenCalledWith({
-                yesterday: 'Did code review',
-                today: 'Deploy to staging',
-                blockers: undefined,
-            });
-        });
-        it('re-prompts when required field is empty', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockResolvedValue({});
-            input
-                .mockResolvedValueOnce('  ') // empty yesterday -> re-prompt
-                .mockResolvedValueOnce('Fixed a bug') // valid yesterday
-                .mockResolvedValueOnce('Write tests') // valid today
-                .mockResolvedValueOnce(''); // empty blockers (ok, not required)
-            await standupCommand({});
-            expect(input).toHaveBeenCalledTimes(4);
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('required'))).toBe(true);
-        });
-        it('opens editor when user types \\e', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockResolvedValue({});
-            input
-                .mockResolvedValueOnce('\\e') // trigger editor for yesterday
-                .mockResolvedValueOnce('Writing docs') // today
-                .mockResolvedValueOnce('') // no blockers
-            ;
-            editor.mockResolvedValueOnce('Detailed yesterday notes from editor');
-            await standupCommand({});
-            expect(editor).toHaveBeenCalledTimes(1);
-            expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
-                yesterday: 'Detailed yesterday notes from editor',
-            }));
-        });
-        it('falls back to inline input when editor fails', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockResolvedValue({});
-            input
-                .mockResolvedValueOnce('\\e') // trigger editor for yesterday
-                .mockResolvedValueOnce('Fallback input') // fallback after editor fails
-                .mockResolvedValueOnce('Today tasks') // today
-                .mockResolvedValueOnce('') // no blockers
-            ;
-            editor.mockRejectedValueOnce(new Error('Editor not found'));
-            await standupCommand({});
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('Editor failed'))).toBe(true);
-            expect(input).toHaveBeenCalledTimes(4);
-        });
-        it('exits with error when API fails in interactive mode', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockRejectedValue(new Error('Missing fields'));
-            input
-                .mockResolvedValueOnce('Yesterday work')
-                .mockResolvedValueOnce('Today work')
-                .mockResolvedValueOnce('');
-            await expect(standupCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Missing fields'))).toBe(true);
-        });
-        it('falls back to statusText when API error has no error body', async () => {
-            setupInteractiveAuth();
-            mockClient.standups.submit.mockRejectedValue(new Error('Bad Gateway'));
-            input
-                .mockResolvedValueOnce('Yesterday')
-                .mockResolvedValueOnce('Today')
-                .mockResolvedValueOnce('');
-            await expect(standupCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Bad Gateway'))).toBe(true);
-        });
-    });
-});

package/dist/commands/templates.d.ts

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

package/dist/commands/templates.js

@@ -1,37 +0,0 @@
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import { isAuthenticated } from '../utils/auth.js';
-import { fetchTemplates } from '../utils/templates.js';
-export async function templatesCommand() {
-    if (!(await isAuthenticated())) {
-        console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
-        process.exit(1);
-    }
-    let templates;
-    try {
-        templates = await fetchTemplates();
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('expired')) {
-            console.error(chalk.red('Session expired. Run `npx @meltstudio/meltctl@latest login` to re-authenticate.'));
-        }
-        else if (error instanceof Error && error.message.includes('fetch')) {
-            console.error(chalk.red('Could not reach Melt API. Check your connection.'));
-        }
-        else {
-            console.error(chalk.red(`Failed to fetch templates: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        }
-        process.exit(1);
-    }
-    const tmpDir = path.join(os.tmpdir(), `melt-templates-${Date.now()}`);
-    await fs.ensureDir(tmpDir);
-    for (const [filePath, content] of Object.entries(templates)) {
-        const fullPath = path.join(tmpDir, filePath);
-        await fs.ensureDir(path.dirname(fullPath));
-        await fs.writeFile(fullPath, content, 'utf-8');
-    }
-    // Print only the temp dir path to stdout (agent parses this)
-    console.log(tmpDir);
-}

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

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

package/dist/commands/templates.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs-extra', () => ({
-    default: {
-        ensureDir: vi.fn(),
-        writeFile: vi.fn(),
-    },
-}));
-vi.mock('../utils/auth.js', () => ({
-    isAuthenticated: vi.fn(),
-}));
-vi.mock('../utils/templates.js', () => ({
-    fetchTemplates: vi.fn(),
-}));
-import fs from 'fs-extra';
-import { isAuthenticated } from '../utils/auth.js';
-import { fetchTemplates } from '../utils/templates.js';
-import { templatesCommand } from './templates.js';
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-    vi.spyOn(process, 'exit').mockImplementation((code) => {
-        throw new Error(`process.exit(${code})`);
-    });
-});
-describe('templatesCommand', () => {
-    it('exits when not authenticated', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(false);
-        await expect(templatesCommand()).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-        expect(fetchTemplates).not.toHaveBeenCalled();
-    });
-    it('fetches and writes templates to temp dir', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        fetchTemplates.mockResolvedValue({
-            'AGENTS.md': '# Agents\nContent here',
-            '.claude/skills/setup.md': '# Setup skill',
-        });
-        await templatesCommand();
-        // Should have called ensureDir for the temp dir and subdirectories
-        expect(fs.ensureDir).toHaveBeenCalled();
-        // Should have written both files
-        expect(fs.writeFile).toHaveBeenCalledTimes(2);
-        // First file
-        const writeFileCalls = fs.writeFile.mock.calls;
-        const filePaths = writeFileCalls.map((c) => c[0]);
-        expect(filePaths.some((p) => p.endsWith('AGENTS.md'))).toBe(true);
-        expect(filePaths.some((p) => p.endsWith('setup.md'))).toBe(true);
-        // Verify content
-        const agentsCall = writeFileCalls.find((c) => c[0].endsWith('AGENTS.md'));
-        expect(agentsCall[1]).toBe('# Agents\nContent here');
-        // Should print the temp dir path
-        expect(console.log).toHaveBeenCalled();
-    });
-    it('exits with error when session expired', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        fetchTemplates.mockRejectedValue(new Error('Session expired'));
-        await expect(templatesCommand()).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('expired'))).toBe(true);
-    });
-    it('exits with error on fetch/network error', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        fetchTemplates.mockRejectedValue(new Error('fetch failed'));
-        await expect(templatesCommand()).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('connection'))).toBe(true);
-    });
-    it('exits with generic error for unknown failures', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        fetchTemplates.mockRejectedValue(new Error('Something weird'));
-        await expect(templatesCommand()).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('Something weird'))).toBe(true);
-    });
-    it('exits with generic message for non-Error thrown values', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        fetchTemplates.mockRejectedValue('string error');
-        await expect(templatesCommand()).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('Unknown error'))).toBe(true);
-    });
-});

package/dist/commands/update.d.ts

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

package/dist/commands/update.js

@@ -1,74 +0,0 @@
-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

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

package/dist/commands/update.test.js

@@ -1,93 +0,0 @@
-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/commands/version.d.ts

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

package/dist/commands/version.js

@@ -1,43 +0,0 @@
-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/commands/version.test.d.ts

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