@meltstudio/meltctl 4.38.0 → 4.38.1

package/dist/commands/coins.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../utils/auth.js', () => ({
-    isAuthenticated: vi.fn(),
-}));
-const mockClient = vi.hoisted(() => ({
-    coins: {
-        getBalance: vi.fn(),
-        getLeaderboard: vi.fn(),
-    },
-}));
-vi.mock('../utils/api.js', () => ({
-    getClient: vi.fn().mockResolvedValue(mockClient),
-}));
-import { isAuthenticated } from '../utils/auth.js';
-import { coinsCommand } from './coins.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('coinsCommand', () => {
-    describe('balance (default)', () => {
-        it('exits with error when not authenticated', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(false);
-            await expect(coinsCommand({})).rejects.toThrow('process.exit(1)');
-            expect(console.error).toHaveBeenCalled();
-        });
-        it('displays coin balance on success', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getBalance.mockResolvedValue({ coins: 5, period: '28d' });
-            await coinsCommand({});
-            expect(mockClient.coins.getBalance).toHaveBeenCalled();
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('5'))).toBe(true);
-        });
-        it('displays singular coin text for 1 coin', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getBalance.mockResolvedValue({ coins: 1, period: '28d' });
-            await coinsCommand({});
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('coin') && !msg.includes('coins'))).toBe(true);
-        });
-        it('displays plural coin text for multiple coins', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getBalance.mockResolvedValue({ coins: 3, period: '28d' });
-            await coinsCommand({});
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('coins'))).toBe(true);
-        });
-        it('exits with error when API returns failure', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getBalance.mockRejectedValue(new Error('Something went wrong'));
-            await expect(coinsCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Something went wrong'))).toBe(true);
-        });
-    });
-    describe('leaderboard', () => {
-        it('exits with error when not authenticated', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(false);
-            await expect(coinsCommand({ leaderboard: true })).rejects.toThrow('process.exit(1)');
-        });
-        it('displays leaderboard entries on success', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            const entries = [
-                { name: 'Alice', coins: 10 },
-                { name: 'Bob', coins: 7 },
-                { name: 'Charlie', coins: 3 },
-            ];
-            mockClient.coins.getLeaderboard.mockResolvedValue(entries);
-            await coinsCommand({ leaderboard: true });
-            expect(mockClient.coins.getLeaderboard).toHaveBeenCalled();
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('Leaderboard'))).toBe(true);
-            expect(logCalls.some((msg) => msg.includes('Alice'))).toBe(true);
-            expect(logCalls.some((msg) => msg.includes('Bob'))).toBe(true);
-        });
-        it('shows message when no coins have been sent', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getLeaderboard.mockResolvedValue([]);
-            await coinsCommand({ leaderboard: true });
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('No coins'))).toBe(true);
-        });
-        it('exits with error when leaderboard API fails', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getLeaderboard.mockRejectedValue(new Error('Access denied'));
-            await expect(coinsCommand({ leaderboard: true })).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Access denied'))).toBe(true);
-        });
-        it('calls getLeaderboard not getBalance', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-            mockClient.coins.getLeaderboard.mockResolvedValue([{ name: 'Test', coins: 1 }]);
-            await coinsCommand({ leaderboard: true });
-            expect(mockClient.coins.getLeaderboard).toHaveBeenCalled();
-            expect(mockClient.coins.getBalance).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/commands/feedback.d.ts

@@ -1,7 +0,0 @@
-interface FeedbackOptions {
-    to?: string;
-    coins?: string;
-    description?: string;
-}
-export declare function feedbackCommand(options: FeedbackOptions): Promise<void>;
-export {};

package/dist/commands/feedback.js

@@ -1,90 +0,0 @@
-import chalk from 'chalk';
-import { input, select, 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 promptDescription() {
-    const value = await input({
-        message: `Write your feedback (50–500 chars): ${EDITOR_HINT}`,
-    });
-    if (value === '\\e') {
-        try {
-            const editorValue = await editor({ message: 'Write your feedback:' });
-            return validateDescription(editorValue);
-        }
-        catch {
-            console.log(chalk.yellow('Editor failed to open. Falling back to inline input.'));
-            return promptDescription();
-        }
-    }
-    return validateDescription(value);
-}
-function validateDescription(value) {
-    const trimmed = value.trim();
-    if (trimmed.length < 50) {
-        console.log(chalk.yellow(`Too short (${trimmed.length}/50 min). Please write more.`));
-        return promptDescription();
-    }
-    if (trimmed.length > 500) {
-        console.log(chalk.yellow(`Too long (${trimmed.length}/500 max). Please shorten it.`));
-        return promptDescription();
-    }
-    return trimmed;
-}
-export async function feedbackCommand(options) {
-    if (!(await isAuthenticated())) {
-        console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
-        process.exit(1);
-    }
-    const client = await getClient();
-    let toUserId;
-    let coins;
-    let description;
-    if (options.to && options.coins && options.description) {
-        // Hidden flags for E2E testing
-        toUserId = parseInt(options.to, 10);
-        coins = parseInt(options.coins, 10);
-        description = options.description;
-    }
-    else {
-        console.log(chalk.bold.cyan('\n  Send Feedback\n'));
-        // Fetch recipients
-        let recipients;
-        try {
-            recipients = await client.feedback.getRecipients();
-        }
-        catch {
-            console.error(chalk.red('Failed to connect to the server.'));
-            process.exit(1);
-        }
-        if (recipients.length === 0) {
-            console.log(chalk.yellow('No recipients available.'));
-            return;
-        }
-        const selectedRecipient = await select({
-            message: 'Who would you like to recognize?',
-            choices: recipients.map(r => ({
-                name: `${r.firstName} ${r.lastName} (${r.email})`,
-                value: r.id,
-            })),
-        });
-        toUserId = selectedRecipient;
-        coins = await select({
-            message: 'How many coins?',
-            choices: [
-                { name: '1 coin', value: 1 },
-                { name: '2 coins', value: 2 },
-                { name: '3 coins', value: 3 },
-            ],
-        });
-        description = await promptDescription();
-    }
-    try {
-        await client.feedback.submit({ toUserId, coins, description });
-        console.log(chalk.green(`\n  ✓ Feedback sent! You gave ${coins} coin${coins > 1 ? 's' : ''}.\n`));
-    }
-    catch (error) {
-        console.error(chalk.red(`\nFailed to send feedback: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        process.exit(1);
-    }
-}

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

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

package/dist/commands/feedback.test.js

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../utils/auth.js', () => ({
-    isAuthenticated: vi.fn(),
-}));
-const mockClient = vi.hoisted(() => ({
-    feedback: {
-        submit: vi.fn(),
-        getRecipients: vi.fn(),
-    },
-}));
-vi.mock('../utils/api.js', () => ({
-    getClient: vi.fn().mockResolvedValue(mockClient),
-}));
-vi.mock('@inquirer/prompts', () => ({
-    input: vi.fn(),
-    select: vi.fn(),
-    editor: vi.fn(),
-}));
-import { isAuthenticated } from '../utils/auth.js';
-import { input, select } from '@inquirer/prompts';
-import { feedbackCommand } from './feedback.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('feedbackCommand', () => {
-    it('exits with error when not authenticated', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(false);
-        await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
-        expect(console.error).toHaveBeenCalled();
-    });
-    it('submits feedback with correct payload using option flags', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockResolvedValue({});
-        await feedbackCommand({
-            to: '42',
-            coins: '2',
-            description: 'Great job on the feature implementation!',
-        });
-        expect(mockClient.feedback.submit).toHaveBeenCalledWith({
-            toUserId: 42,
-            coins: 2,
-            description: 'Great job on the feature implementation!',
-        });
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('Feedback sent'))).toBe(true);
-    });
-    it('displays singular coin text when sending 1 coin', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockResolvedValue({});
-        await feedbackCommand({ to: '1', coins: '1', description: 'Nice work' });
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('1 coin') && !msg.includes('1 coins'))).toBe(true);
-    });
-    it('displays plural coin text when sending multiple coins', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockResolvedValue({});
-        await feedbackCommand({ to: '1', coins: '3', description: 'Excellent work' });
-        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-        expect(logCalls.some((msg) => msg.includes('3 coins'))).toBe(true);
-    });
-    it('exits with error when API returns failure', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockRejectedValue(new Error('Insufficient coins'));
-        await expect(feedbackCommand({ to: '42', coins: '2', description: 'Good work' })).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('Insufficient coins'))).toBe(true);
-    });
-    it('exits with error when API returns failure without error body', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockRejectedValue(new Error('Internal Server Error'));
-        await expect(feedbackCommand({ to: '42', coins: '2', description: 'Good work' })).rejects.toThrow('process.exit(1)');
-        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-        expect(errorCalls.some((msg) => msg.includes('Internal Server Error'))).toBe(true);
-    });
-    it('sends correct numeric types in payload', async () => {
-        ;
-        isAuthenticated.mockResolvedValue(true);
-        mockClient.feedback.submit.mockResolvedValue({});
-        await feedbackCommand({ to: '7', coins: '3', description: 'Awesome' });
-        expect(mockClient.feedback.submit).toHaveBeenCalledWith({
-            toUserId: 7,
-            coins: 3,
-            description: 'Awesome',
-        });
-    });
-    describe('interactive flow', () => {
-        const mockRecipients = [
-            { id: 1, firstName: 'Alice', lastName: 'Smith', email: 'alice@meltstudio.co' },
-            { id: 2, firstName: 'Bob', lastName: 'Jones', email: 'bob@meltstudio.co' },
-        ];
-        function setupInteractiveMocks() {
-            ;
-            isAuthenticated.mockResolvedValue(true);
-        }
-        it('prompts for recipient, coins, and description in interactive mode', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
-            mockClient.feedback.submit.mockResolvedValue({});
-            select.mockResolvedValueOnce(1).mockResolvedValueOnce(2);
-            input.mockResolvedValueOnce('This is a great piece of feedback that is long enough to pass validation easily.');
-            await feedbackCommand({});
-            expect(mockClient.feedback.getRecipients).toHaveBeenCalled();
-            expect(select).toHaveBeenCalledTimes(2);
-            expect(input).toHaveBeenCalledTimes(1);
-            expect(mockClient.feedback.submit).toHaveBeenCalledWith(expect.objectContaining({
-                toUserId: 1,
-            }));
-        });
-        it('shows no recipients message when list is empty', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockResolvedValue([]);
-            await feedbackCommand({});
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('No recipients'))).toBe(true);
-            // Should not call submit
-            expect(mockClient.feedback.submit).not.toHaveBeenCalled();
-        });
-        it('exits with error when recipients API fails', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Not allowed'));
-            await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
-        });
-        it('exits with error when recipients fetch throws network error', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Network error'));
-            await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
-        });
-        it('re-prompts when description is too short', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
-            mockClient.feedback.submit.mockResolvedValue({});
-            select.mockResolvedValueOnce(2).mockResolvedValueOnce(3);
-            input
-                .mockResolvedValueOnce('Too short')
-                .mockResolvedValueOnce('This description is now long enough to pass the fifty character minimum validation check.');
-            await feedbackCommand({});
-            expect(input).toHaveBeenCalledTimes(2);
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('Too short'))).toBe(true);
-        });
-        it('re-prompts when description is too long', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
-            mockClient.feedback.submit.mockResolvedValue({});
-            select.mockResolvedValueOnce(1).mockResolvedValueOnce(1);
-            input
-                .mockResolvedValueOnce('x'.repeat(501))
-                .mockResolvedValueOnce('This description is now exactly the right length to pass all validation checks successfully.');
-            await feedbackCommand({});
-            expect(input).toHaveBeenCalledTimes(2);
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('Too long'))).toBe(true);
-        });
-        it('falls back to recipients error statusText when no error body', async () => {
-            setupInteractiveMocks();
-            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Service Unavailable'));
-            await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
-        });
-    });
-});

package/dist/commands/init.d.ts

@@ -1,8 +0,0 @@
-interface InitOptions {
-    force?: boolean;
-    claude?: boolean;
-    cursor?: boolean;
-    opencode?: boolean;
-}
-export declare function initCommand(options: InitOptions): Promise<void>;
-export {};