@meltstudio/meltctl 4.27.0 → 4.28.1

package/dist/commands/logout.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../utils/auth.js', () => ({
+    getStoredAuth: vi.fn(),
+    clearAuth: vi.fn(),
+}));
+import { getStoredAuth, clearAuth } from '../utils/auth.js';
+import { logoutCommand } from './logout.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('logoutCommand', () => {
+    it('clears auth and shows logged-out message with email when session exists', async () => {
+        ;
+        getStoredAuth.mockResolvedValue({
+            token: 'jwt-token',
+            email: 'dev@meltstudio.co',
+            expiresAt: '2026-04-01T00:00:00Z',
+        });
+        clearAuth.mockResolvedValue(undefined);
+        await logoutCommand();
+        expect(clearAuth).toHaveBeenCalled();
+        const logCalls = console.log.mock.calls.map((c) => c[0]);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Logged out'))).toBe(true);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('dev@meltstudio.co'))).toBe(true);
+    });
+    it('clears auth and shows "no active session" when no session exists', async () => {
+        ;
+        getStoredAuth.mockResolvedValue(undefined);
+        clearAuth.mockResolvedValue(undefined);
+        await logoutCommand();
+        expect(clearAuth).toHaveBeenCalled();
+        const logCalls = console.log.mock.calls.map((c) => c[0]);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('No active session'))).toBe(true);
+    });
+    it('always calls clearAuth regardless of session state', async () => {
+        ;
+        getStoredAuth.mockResolvedValue(undefined);
+        clearAuth.mockResolvedValue(undefined);
+        await logoutCommand();
+        expect(clearAuth).toHaveBeenCalledTimes(1);
+    });
+    it('calls getStoredAuth before clearAuth', async () => {
+        const callOrder = [];
+        getStoredAuth.mockImplementation(async () => {
+            callOrder.push('getStoredAuth');
+            return { token: 'tok', email: 'a@b.co', expiresAt: '2026-04-01T00:00:00Z' };
+        });
+        clearAuth.mockImplementation(async () => {
+            callOrder.push('clearAuth');
+        });
+        await logoutCommand();
+        expect(callOrder).toEqual(['getStoredAuth', 'clearAuth']);
+    });
+});

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

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

package/dist/commands/plan.test.js

@@ -0,0 +1,283 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs-extra', () => ({
+    default: {
+        pathExists: vi.fn(),
+        readFile: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getToken: vi.fn(),
+    tokenFetch: vi.fn(),
+}));
+vi.mock('../utils/git.js', () => ({
+    getGitBranch: vi.fn(),
+    getGitCommit: vi.fn(),
+    getGitRepository: vi.fn(),
+    getProjectName: vi.fn(),
+    extractTicketId: vi.fn(),
+    findMdFiles: vi.fn(),
+}));
+import fs from 'fs-extra';
+import { getToken, tokenFetch } from '../utils/api.js';
+import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from '../utils/git.js';
+import { planSubmitCommand, planListCommand } from './plan.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('planSubmitCommand', () => {
+    function setupGitMocks() {
+        ;
+        getToken.mockResolvedValue('test-token');
+        getGitBranch.mockReturnValue('feature/PROJ-123-add-feature');
+        getGitCommit.mockReturnValue('def5678');
+        getGitRepository.mockReturnValue({
+            slug: 'Org/Repo',
+            url: 'https://github.com/Org/Repo.git',
+        });
+        getProjectName.mockReturnValue('test-project');
+        extractTicketId.mockReturnValue('PROJ-123');
+    }
+    it('submits a plan with correct payload fields', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('# Plan\nSome plan content.');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-100', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('PROJ-123-plan.md');
+        const call = tokenFetch.mock.calls[0];
+        const body = JSON.parse(call[2].body);
+        expect(body).toEqual({
+            project: 'test-project',
+            repository: 'Org/Repo',
+            repositoryUrl: 'https://github.com/Org/Repo.git',
+            branch: 'feature/PROJ-123-add-feature',
+            commit: 'def5678',
+            content: '# Plan\nSome plan content.',
+            metadata: { filename: 'PROJ-123-plan.md' },
+            ticket: 'PROJ-123',
+        });
+    });
+    it('logs "Plan submitted" when API returns created: true', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('plan content');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-new', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('plan.md');
+        const logCalls = console.log.mock.calls.map((c) => c[0]);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Plan submitted'))).toBe(true);
+    });
+    it('logs "Plan updated" when API returns created: false', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('updated plan content');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-upd', created: false }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('plan.md');
+        const logCalls = console.log.mock.calls.map((c) => c[0]);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('Plan updated'))).toBe(true);
+    });
+    it('exits with error when file not found', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(false);
+        await expect(planSubmitCommand('nonexistent.md')).rejects.toThrow('process.exit(1)');
+        expect(console.error).toHaveBeenCalled();
+    });
+    it('exits with error when API returns failure', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('content');
+        const mockResponse = {
+            ok: false,
+            statusText: 'Bad Request',
+            json: vi.fn().mockResolvedValue({ error: 'Invalid content' }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await expect(planSubmitCommand('plan.md')).rejects.toThrow('process.exit(1)');
+    });
+    it('auto-detects plan file from .plans/ directory when no file provided', async () => {
+        setupGitMocks();
+        findMdFiles.mockResolvedValue(['/project/.plans/PROJ-123-plan.md']);
+        extractTicketId.mockReturnValue('PROJ-123');
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('auto-detected plan');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-auto', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand();
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/plans', expect.objectContaining({
+            method: 'POST',
+        }));
+    });
+    it('exits with error when no file provided and none auto-detected', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        findMdFiles.mockResolvedValue([]);
+        getGitBranch.mockReturnValue('main');
+        extractTicketId.mockReturnValue(null);
+        await expect(planSubmitCommand()).rejects.toThrow('process.exit(1)');
+        expect(console.error).toHaveBeenCalled();
+    });
+    it('does not include ticket in payload when extractTicketId returns null', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        getGitBranch.mockReturnValue('main');
+        getGitCommit.mockReturnValue('abc1234');
+        getGitRepository.mockReturnValue({
+            slug: 'Org/Repo',
+            url: 'https://github.com/Org/Repo.git',
+        });
+        getProjectName.mockReturnValue('test-project');
+        extractTicketId.mockReturnValue(null);
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('plan without ticket');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-no-ticket', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('plan.md');
+        const call = tokenFetch.mock.calls[0];
+        const body = JSON.parse(call[2].body);
+        expect(body.ticket).toBeUndefined();
+    });
+    it('includes status from frontmatter when present', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('---\nstatus: approved\n---\n# Plan');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-status', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('plan.md');
+        const call = tokenFetch.mock.calls[0];
+        const body = JSON.parse(call[2].body);
+        expect(body.status).toBe('approved');
+    });
+    it('does not include status when no frontmatter present', async () => {
+        setupGitMocks();
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('# Plan\nNo frontmatter here.');
+        const mockResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({ id: 'plan-no-status', created: true }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planSubmitCommand('plan.md');
+        const call = tokenFetch.mock.calls[0];
+        const body = JSON.parse(call[2].body);
+        expect(body.status).toBeUndefined();
+    });
+});
+describe('planListCommand', () => {
+    it('calls API with correct query params', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: true,
+            status: 200,
+            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planListCommand({ repository: 'Org/Repo', author: 'dev@meltstudio.co', limit: '5' });
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', expect.stringContaining('/plans?'));
+        const url = tokenFetch.mock.calls[0][1];
+        expect(url).toContain('repository=Org%2FRepo');
+        expect(url).toContain('author=dev%40meltstudio.co');
+        expect(url).toContain('limit=5');
+    });
+    it('exits with error on 403 response', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: false,
+            status: 403,
+            statusText: 'Forbidden',
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await expect(planListCommand({})).rejects.toThrow('process.exit(1)');
+        expect(console.error).toHaveBeenCalled();
+    });
+    it('displays plan list when plans exist', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: true,
+            status: 200,
+            json: vi.fn().mockResolvedValue({
+                plans: [
+                    {
+                        id: '1',
+                        project: 'my-project',
+                        repository: 'Org/Repo',
+                        author: 'dev@meltstudio.co',
+                        branch: 'feature/PROJ-123',
+                        commit: 'abc1234',
+                        ticket: 'PROJ-123',
+                        status: 'submitted',
+                        createdAt: '2026-03-25T10:00:00Z',
+                        updatedAt: '2026-03-25T12:00:00Z',
+                    },
+                ],
+                count: 1,
+            }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planListCommand({});
+        expect(console.log).toHaveBeenCalled();
+    });
+    it('shows "No plans found" when list is empty', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: true,
+            status: 200,
+            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planListCommand({});
+        const logCalls = console.log.mock.calls.map((c) => c[0]);
+        expect(logCalls.some((msg) => typeof msg === 'string' && msg.includes('No plans found'))).toBe(true);
+    });
+    it('calls API without query params when no options provided', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: true,
+            status: 200,
+            json: vi.fn().mockResolvedValue({ plans: [], count: 0 }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await planListCommand({});
+        expect(tokenFetch).toHaveBeenCalledWith('test-token', '/plans');
+    });
+    it('exits with error on non-403 failure response', async () => {
+        ;
+        getToken.mockResolvedValue('test-token');
+        const mockResponse = {
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+            json: vi.fn().mockResolvedValue({ error: 'Server error' }),
+        };
+        tokenFetch.mockResolvedValue(mockResponse);
+        await expect(planListCommand({})).rejects.toThrow('process.exit(1)');
+    });
+});

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

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

package/dist/commands/standup.test.js

@@ -0,0 +1,252 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../utils/auth.js', () => ({
+    isAuthenticated: vi.fn(),
+    authenticatedFetch: vi.fn(),
+}));
+vi.mock('@inquirer/prompts', () => ({
+    input: vi.fn(),
+    editor: vi.fn(),
+}));
+import { isAuthenticated, authenticatedFetch } 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);
+        const statusResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({
+                yesterday: 'Did stuff',
+                today: 'More stuff',
+                blockers: null,
+            }),
+        };
+        authenticatedFetch.mockResolvedValue(statusResponse);
+        await standupCommand({});
+        expect(authenticatedFetch).toHaveBeenCalledWith('/standups/status');
+        // Should not call POST /standups
+        expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+        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 not found (no existing standup)
+        const statusResponse = { ok: false };
+        const submitResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({}),
+        };
+        authenticatedFetch
+            .mockResolvedValueOnce(statusResponse)
+            .mockResolvedValueOnce(submitResponse);
+        await standupCommand({
+            yesterday: 'Fixed bugs',
+            today: 'Write tests',
+            blockers: 'None',
+        });
+        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                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);
+        const statusResponse = { ok: false };
+        const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+        authenticatedFetch
+            .mockResolvedValueOnce(statusResponse)
+            .mockResolvedValueOnce(submitResponse);
+        await standupCommand({
+            yesterday: 'Did things',
+            today: 'More things',
+        });
+        const call = authenticatedFetch.mock.calls[1];
+        const body = JSON.parse(call[1].body);
+        expect(body.blockers).toBeUndefined();
+    });
+    it('exits with error when API returns failure', async () => {
+        ;
+        isAuthenticated.mockResolvedValue(true);
+        const statusResponse = { ok: false };
+        const submitResponse = {
+            ok: false,
+            statusText: 'Bad Request',
+            json: vi.fn().mockResolvedValue({ error: 'Invalid standup' }),
+        };
+        authenticatedFetch
+            .mockResolvedValueOnce(statusResponse)
+            .mockResolvedValueOnce(submitResponse);
+        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);
+        authenticatedFetch
+            .mockRejectedValueOnce(new Error('Network error'))
+            .mockResolvedValueOnce({ ok: true, json: vi.fn().mockResolvedValue({}) });
+        await standupCommand({ yesterday: 'a', today: 'b' });
+        expect(authenticatedFetch).toHaveBeenCalledTimes(2);
+        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
+            method: 'POST',
+        }));
+    });
+    it('displays existing standup with blockers', async () => {
+        ;
+        isAuthenticated.mockResolvedValue(true);
+        const statusResponse = {
+            ok: true,
+            json: vi.fn().mockResolvedValue({
+                yesterday: 'Bug fixes',
+                today: 'Feature work',
+                blockers: 'Waiting on review',
+            }),
+        };
+        authenticatedFetch.mockResolvedValue(statusResponse);
+        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);
+            authenticatedFetch.mockResolvedValueOnce({ ok: false });
+        }
+        it('prompts for yesterday, today, and blockers in interactive mode', async () => {
+            setupInteractiveAuth();
+            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            input
+                .mockResolvedValueOnce('Worked on feature X')
+                .mockResolvedValueOnce('Working on feature Y')
+                .mockResolvedValueOnce('No blockers');
+            await standupCommand({});
+            expect(input).toHaveBeenCalledTimes(3);
+            expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify({
+                    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();
+            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            input
+                .mockResolvedValueOnce('Did code review')
+                .mockResolvedValueOnce('Deploy to staging')
+                .mockResolvedValueOnce('');
+            await standupCommand({});
+            const call = authenticatedFetch.mock.calls[1];
+            const body = JSON.parse(call[1].body);
+            expect(body.blockers).toBeUndefined();
+        });
+        it('re-prompts when required field is empty', async () => {
+            setupInteractiveAuth();
+            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            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();
+            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            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);
+            const call = authenticatedFetch.mock.calls[1];
+            const body = JSON.parse(call[1].body);
+            expect(body.yesterday).toBe('Detailed yesterday notes from editor');
+        });
+        it('falls back to inline input when editor fails', async () => {
+            setupInteractiveAuth();
+            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            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();
+            const submitResponse = {
+                ok: false,
+                statusText: 'Unprocessable Entity',
+                json: vi.fn().mockResolvedValue({ error: 'Missing fields' }),
+            };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            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();
+            const submitResponse = {
+                ok: false,
+                statusText: 'Bad Gateway',
+                json: vi.fn().mockResolvedValue({}),
+            };
+            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            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.test.d.ts

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