@sovovs/bycli 1.8.0 → 2.0.0

package/clis/chess/stats.test.js

@@ -1,79 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './stats.js';
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-
-function mockFetch(body) {
-    return vi.fn().mockResolvedValue({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(body),
-    });
-}
-
-describe('chess stats command', () => {
-    it('rejects empty username via validateUsername', async () => {
-        const cmd = getRegistry().get('chess/stats');
-        await expect(cmd.func({ username: '' })).rejects.toBeInstanceOf(ArgumentError);
-    });
-
-    it('rejects invalid username characters', async () => {
-        const cmd = getRegistry().get('chess/stats');
-        await expect(cmd.func({ username: 'user name' })).rejects.toBeInstanceOf(ArgumentError);
-    });
-
-    it('returns one row per known game kind populated in the stats response', async () => {
-        const fetchMock = mockFetch({
-            chess_rapid: { last: { rating: 1700 }, best: { rating: 1800 }, record: { win: 50, loss: 20, draw: 5 } },
-            chess_blitz: { last: { rating: 1500 }, best: { rating: 1600 }, record: { win: 100, loss: 80, draw: 10 } },
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('chess/stats');
-        const rows = await cmd.func({ username: 'someuser' });
-        expect(rows).toHaveLength(2);
-        expect(rows[0].kind).toBe('rapid');
-        expect(rows[1].kind).toBe('blitz');
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://api.chess.com/pub/player/someuser/stats',
-            expect.objectContaining({ headers: expect.any(Object) }),
-        );
-    });
-
-    it('lowercases username in the URL', async () => {
-        const fetchMock = mockFetch({ chess_rapid: { last: { rating: 1 }, best: {}, record: {} } });
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('chess/stats');
-        await cmd.func({ username: 'MixedCase' });
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://api.chess.com/pub/player/mixedcase/stats',
-            expect.any(Object),
-        );
-    });
-
-    it('throws EmptyResultError when the stats response has no known kinds', async () => {
-        vi.stubGlobal('fetch', mockFetch({}));
-        const cmd = getRegistry().get('chess/stats');
-        await expect(cmd.func({ username: 'someuser' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when a populated stats kind is malformed', async () => {
-        vi.stubGlobal('fetch', mockFetch({ chess_rapid: 'bad' }));
-        const cmd = getRegistry().get('chess/stats');
-        await expect(cmd.func({ username: 'someuser' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws EmptyResultError on HTTP 404', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 404 }));
-        const cmd = getRegistry().get('chess/stats');
-        await expect(cmd.func({ username: 'someuser' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('registers with the expected columns', () => {
-        const cmd = getRegistry().get('chess/stats');
-        expect(cmd?.columns).toEqual(['kind', 'rating_current', 'rating_best', 'wins', 'losses', 'draws']);
-    });
-});

package/clis/chess/utils.test.js

@@ -1,230 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import { __test__ } from './utils.js';
-
-const { validateUsername, parseGameUrl, chessApi, summarizeStats, formatDate, mapGameRow, openingName } = __test__;
-
-describe('chess utils', () => {
-    it('validateUsername lowercases and accepts 3-25 char usernames', () => {
-        expect(validateUsername('Hikaru')).toBe('hikaru');
-        expect(validateUsername('MagnusCarlsen')).toBe('magnuscarlsen');
-        expect(validateUsername('a-b_c')).toBe('a-b_c');
-    });
-
-    it('validateUsername rejects empty / too-short / invalid chars', () => {
-        expect(() => validateUsername('')).toThrow(ArgumentError);
-        expect(() => validateUsername('ab')).toThrow(ArgumentError);
-        expect(() => validateUsername('user name')).toThrow(ArgumentError);
-        expect(() => validateUsername('a'.repeat(30))).toThrow(ArgumentError);
-    });
-
-    it('parseGameUrl parses both live and daily game URL forms', () => {
-        expect(parseGameUrl('https://www.chess.com/game/live/168842570216'))
-            .toEqual({ kind: 'live', id: '168842570216' });
-        expect(parseGameUrl('https://www.chess.com/game/daily/947761777'))
-            .toEqual({ kind: 'daily', id: '947761777' });
-        expect(parseGameUrl('https://www.chess.com/game/LIVE/1'))
-            .toEqual({ kind: 'live', id: '1' });
-    });
-
-    it('parseGameUrl strips trailing path / query off the URL', () => {
-        expect(parseGameUrl('https://www.chess.com/game/live/123/something?ref=share'))
-            .toEqual({ kind: 'live', id: '123' });
-    });
-
-    it('parseGameUrl rejects empty / non-URL / unsupported-kind inputs', () => {
-        expect(() => parseGameUrl('')).toThrow(ArgumentError);
-        expect(() => parseGameUrl('   ')).toThrow(ArgumentError);
-        expect(() => parseGameUrl('123')).toThrow(ArgumentError);
-        expect(() => parseGameUrl('https://www.chess.com/club/123')).toThrow(ArgumentError);
-        expect(() => parseGameUrl('https://lichess.org/abc')).toThrow(ArgumentError);
-    });
-
-    it('summarizeStats projects rating + record fields', () => {
-        const stats = {
-            chess_rapid: {
-                last: { rating: 1600 },
-                best: { rating: 1800 },
-                record: { win: 100, loss: 50, draw: 10 },
-            },
-        };
-        expect(summarizeStats(stats, 'chess_rapid')).toEqual({
-            kind: 'rapid',
-            rating_current: 1600,
-            rating_best: 1800,
-            wins: 100,
-            losses: 50,
-            draws: 10,
-        });
-    });
-
-    it('summarizeStats returns null for missing kind', () => {
-        expect(summarizeStats({}, 'chess_rapid')).toBeNull();
-        expect(summarizeStats({ chess_blitz: {} }, 'chess_rapid')).toBeNull();
-    });
-
-    it('summarizeStats typed-fails malformed populated kind objects', () => {
-        expect(() => summarizeStats({ chess_rapid: 'bad' }, 'chess_rapid')).toThrow(CommandExecutionError);
-        expect(() => summarizeStats({ chess_rapid: { record: [] } }, 'chess_rapid')).toThrow(CommandExecutionError);
-    });
-
-    it('summarizeStats coerces missing numeric fields to empty string', () => {
-        const row = summarizeStats({ chess_daily: { last: {}, record: {} } }, 'chess_daily');
-        expect(row).toEqual({
-            kind: 'daily',
-            rating_current: '',
-            rating_best: '',
-            wins: '',
-            losses: '',
-            draws: '',
-        });
-    });
-
-    it('formatDate converts epoch seconds to YYYY-MM-DD', () => {
-        expect(formatDate(1777737679)).toBe('2026-05-02');
-        expect(formatDate(0)).toBe('');
-        expect(formatDate(null)).toBe('');
-        expect(formatDate('not-a-number')).toBe('');
-    });
-
-    it('mapGameRow returns rows from the viewer perspective when viewer is white', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            end_time: 1777737679,
-            time_class: 'blitz',
-            rated: true,
-            eco: 'C50',
-            accuracies: { white: 87.73, black: 80.23 },
-            white: { username: 'Hikaru', rating: 3286, result: 'win' },
-            black: { username: 'Magnus', rating: 2900, result: 'resigned' },
-        };
-        expect(mapGameRow(game, 'Hikaru')).toEqual({
-            date: '2026-05-02',
-            time_class: 'blitz',
-            rated: true,
-            my_color: 'white',
-            my_rating: 3286,
-            my_result: 'win',
-            opponent: 'Magnus',
-            opponent_rating: 2900,
-            accuracy_white: 87.73,
-            accuracy_black: 80.23,
-            eco: 'C50',
-            opening_name: '',
-            url: 'https://www.chess.com/game/live/123',
-        });
-    });
-
-    it('mapGameRow leaves accuracy fields empty when chess.com did not compute them', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'A', rating: 1, result: 'win' },
-            black: { username: 'B', rating: 1, result: 'resigned' },
-        };
-        const row = mapGameRow(game, 'A');
-        expect(row.accuracy_white).toBe('');
-        expect(row.accuracy_black).toBe('');
-    });
-
-    it('mapGameRow parses opening_name from the chess.com eco URL', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            eco: 'https://www.chess.com/openings/Reti-Opening-Nimzo-Larsen-Variation-2...g6-3.Bb2-Bg7-4.d4',
-            white: { username: 'A', rating: 1, result: 'win' },
-            black: { username: 'B', rating: 1, result: 'resigned' },
-        };
-        const row = mapGameRow(game, 'A');
-        expect(row.opening_name).toBe('Reti Opening Nimzo Larsen Variation');
-    });
-
-    it('openingName helper returns clean human-readable name from URL form', () => {
-        expect(openingName('https://www.chess.com/openings/Sicilian-Defense')).toBe('Sicilian Defense');
-        expect(openingName('https://www.chess.com/openings/Kings-Indian-Defense-Semi-Classical-Variation...7.O-O'))
-            .toBe('Kings Indian Defense Semi Classical Variation');
-        expect(openingName('https://www.chess.com/openings/French-Defense-Advance-Variation-3...c5-4.c3'))
-            .toBe('French Defense Advance Variation');
-    });
-
-    it('openingName returns empty for short-code eco or missing input', () => {
-        expect(openingName('A01')).toBe('');
-        expect(openingName('')).toBe('');
-        expect(openingName(undefined)).toBe('');
-        expect(openingName(null)).toBe('');
-    });
-
-    it('mapGameRow flips perspective when viewer is black', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'Hikaru', rating: 3286, result: 'win' },
-            black: { username: 'Magnus', rating: 2900, result: 'resigned' },
-        };
-        const row = mapGameRow(game, 'Magnus');
-        expect(row.my_color).toBe('black');
-        expect(row.my_result).toBe('resigned');
-        expect(row.opponent).toBe('Hikaru');
-    });
-
-    it('mapGameRow matches viewer case-insensitively', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'Hikaru', rating: 3286, result: 'win' },
-            black: { username: 'Magnus', rating: 2900, result: 'resigned' },
-        };
-        expect(mapGameRow(game, 'hikaru').my_color).toBe('white');
-        expect(mapGameRow(game, 'MAGNUS').my_color).toBe('black');
-    });
-
-    it('mapGameRow typed-fails when viewer is neither player', () => {
-        const game = {
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'A', rating: 1000, result: 'win' },
-            black: { username: 'B', rating: 1100, result: 'resigned' },
-        };
-        expect(() => mapGameRow(game, 'C')).toThrow(CommandExecutionError);
-    });
-
-    it('mapGameRow handles missing optional fields without throwing', () => {
-        const row = mapGameRow({
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'x' },
-            black: { username: 'y' },
-        }, 'x');
-        expect(row.date).toBe('');
-        expect(row.url).toBe('https://www.chess.com/game/live/123');
-        expect(row.eco).toBe('');
-    });
-
-    it('mapGameRow typed-fails missing stable URL or player identity', () => {
-        expect(() => mapGameRow({
-            white: { username: 'x' },
-            black: { username: 'y' },
-        }, 'x')).toThrow(CommandExecutionError);
-        expect(() => mapGameRow({
-            url: 'https://www.chess.com/game/live/123',
-            white: { username: 'x' },
-            black: {},
-        }, 'x')).toThrow(CommandExecutionError);
-    });
-
-    it('chessApi maps network, malformed JSON, and wrong-shape payloads to typed errors', async () => {
-        await expect(chessApi('/x', async () => { throw new TypeError('network down'); }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(chessApi('/x', async () => ({
-            ok: true,
-            status: 200,
-            json: async () => { throw new SyntaxError('bad json'); },
-        }))).rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(chessApi('/x', async () => ({
-            ok: true,
-            status: 200,
-            json: async () => [],
-        }))).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('chessApi preserves 404 as empty and non-2xx as command execution errors', async () => {
-        await expect(chessApi('/x', async () => ({ ok: false, status: 404 })))
-            .rejects.toBeInstanceOf(EmptyResultError);
-        await expect(chessApi('/x', async () => ({ ok: false, status: 500 })))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});

package/clis/claude/ask.test.js

@@ -1,338 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-
-const {
-    mockEnsureOnClaude,
-    mockEnsureClaudeComposer,
-    mockSelectModel,
-    mockSetAdaptiveThinking,
-    mockSendMessage,
-    mockSendWithFile,
-    mockGetBubbleCount,
-    mockWaitForResponse,
-    mockParseBoolFlag,
-    mockRequireNonEmptyPrompt,
-    mockRequirePositiveInt,
-    mockWithRetry,
-} = vi.hoisted(() => ({
-    mockEnsureOnClaude: vi.fn(),
-    mockEnsureClaudeComposer: vi.fn(),
-    mockSelectModel: vi.fn(),
-    mockSetAdaptiveThinking: vi.fn(),
-    mockSendMessage: vi.fn(),
-    mockSendWithFile: vi.fn(),
-    mockGetBubbleCount: vi.fn(),
-    mockWaitForResponse: vi.fn(),
-    mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
-    mockRequireNonEmptyPrompt: vi.fn((v) => String(v ?? '')),
-    mockRequirePositiveInt: vi.fn((v) => Number(v)),
-    mockWithRetry: vi.fn(async (fn) => fn()),
-}));
-
-vi.mock('./utils.js', () => ({
-    CLAUDE_DOMAIN: 'claude.ai',
-    CLAUDE_URL: 'https://claude.ai/new',
-    ensureOnClaude: mockEnsureOnClaude,
-    ensureClaudeComposer: mockEnsureClaudeComposer,
-    selectModel: mockSelectModel,
-    setAdaptiveThinking: mockSetAdaptiveThinking,
-    sendMessage: mockSendMessage,
-    sendWithFile: mockSendWithFile,
-    getBubbleCount: mockGetBubbleCount,
-    waitForResponse: mockWaitForResponse,
-    parseBoolFlag: mockParseBoolFlag,
-    requireNonEmptyPrompt: mockRequireNonEmptyPrompt,
-    requirePositiveInt: mockRequirePositiveInt,
-    withRetry: mockWithRetry,
-}));
-
-import { askCommand } from './ask.js';
-
-describe('claude ask basic flow', () => {
-    const page = {
-        wait: vi.fn().mockResolvedValue(undefined),
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        page.evaluate.mockResolvedValue('https://claude.ai/new');
-        mockEnsureOnClaude.mockResolvedValue(false);
-        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
-        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
-        mockSendMessage.mockResolvedValue({ ok: true });
-        mockSendWithFile.mockResolvedValue({ ok: true });
-        mockGetBubbleCount.mockResolvedValue(0);
-        mockWaitForResponse.mockResolvedValue('hello there');
-        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
-        mockRequirePositiveInt.mockImplementation((v) => Number(v));
-    });
-
-    it('returns the assistant response on a fresh chat', async () => {
-        const rows = await askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        });
-
-        expect(rows).toEqual([{ response: 'hello there' }]);
-        expect(mockSendMessage).toHaveBeenCalledWith(page, 'hi');
-        expect(mockWaitForResponse).toHaveBeenCalledWith(page, 0, 'hi', 120000);
-    });
-
-    it('navigates to /new when --new is set', async () => {
-        await askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 120,
-            new: true,
-            model: 'sonnet',
-            think: false,
-        });
-
-        expect(page.goto).toHaveBeenCalledWith('https://claude.ai/new');
-        expect(mockEnsureOnClaude).not.toHaveBeenCalled();
-    });
-
-    it('throws EmptyResultError when waitForResponse yields nothing', async () => {
-        mockWaitForResponse.mockResolvedValue(null);
-
-        await expect(askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 60,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when send fails', async () => {
-        mockSendMessage.mockResolvedValue({ ok: false, reason: 'composer not found' });
-
-        await expect(askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        })).rejects.toThrow(/composer not found/);
-    });
-});
-
-describe('claude ask --model handling', () => {
-    const page = {
-        wait: vi.fn().mockResolvedValue(undefined),
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn(),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockEnsureOnClaude.mockResolvedValue(false);
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
-        mockSendMessage.mockResolvedValue({ ok: true });
-        mockGetBubbleCount.mockResolvedValue(0);
-        mockWaitForResponse.mockResolvedValue('reply');
-    });
-
-    it('rejects --model opus on free tier with usage-error guidance', async () => {
-        page.evaluate.mockResolvedValue('https://claude.ai/new');
-        mockSelectModel.mockResolvedValue({ ok: false, upgrade: true });
-
-        await expect(askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 120,
-            new: false,
-            model: 'opus',
-            think: false,
-        })).rejects.toMatchObject(new ArgumentError(
-            'opus model requires a paid Claude plan.',
-            'Pick --model sonnet or --model haiku, or upgrade your account.',
-        ));
-    });
-
-    it('skips model selection inside an existing conversation', async () => {
-        page.evaluate.mockResolvedValue('https://claude.ai/chat/abc-123');
-
-        const rows = await askCommand.func(page, {
-            prompt: 'continue',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        });
-
-        expect(rows).toEqual([{ response: 'reply' }]);
-        expect(mockSelectModel).not.toHaveBeenCalled();
-    });
-
-    it('fails fast when --model is explicit inside an existing conversation', async () => {
-        page.evaluate.mockResolvedValue('https://claude.ai/chat/abc-123');
-
-        await expect(askCommand.func(page, {
-            prompt: 'continue',
-            timeout: 120,
-            new: false,
-            model: 'opus',
-            think: false,
-            __bycliOptionSources: { model: 'cli' },
-        })).rejects.toMatchObject(new ArgumentError(
-            'Cannot switch to opus model inside an existing conversation.',
-            'Re-run with --new to start a fresh chat before selecting a model.',
-        ));
-
-        expect(mockSelectModel).not.toHaveBeenCalled();
-    });
-});
-
-describe('claude ask --think', () => {
-    const page = {
-        wait: vi.fn().mockResolvedValue(undefined),
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockEnsureOnClaude.mockResolvedValue(false);
-        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
-        mockSendMessage.mockResolvedValue({ ok: true });
-        mockGetBubbleCount.mockResolvedValue(0);
-        mockWaitForResponse.mockResolvedValue('reply');
-    });
-
-    it('toggles Adaptive thinking when --think is set', async () => {
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: true });
-
-        await askCommand.func(page, {
-            prompt: 'reason carefully',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: true,
-        });
-
-        expect(mockSetAdaptiveThinking).toHaveBeenCalledWith(page, true);
-    });
-
-    it('throws when --think requested but toggle fails', async () => {
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: false });
-
-        await expect(askCommand.func(page, {
-            prompt: 'reason carefully',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: true,
-        })).rejects.toThrow(/Adaptive thinking/);
-    });
-
-    it('does not throw when --think is false and toggle returns ok=false', async () => {
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: false });
-
-        await expect(askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        })).resolves.toEqual([{ response: 'reply' }]);
-    });
-
-    it('fails fast when prompt validation rejects an empty prompt', async () => {
-        mockRequireNonEmptyPrompt.mockImplementation(() => {
-            throw new ArgumentError('claude ask prompt cannot be empty');
-        });
-
-        await expect(askCommand.func(page, {
-            prompt: '',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        })).rejects.toThrow(ArgumentError);
-    });
-
-    it('fails fast when timeout validation rejects a non-positive value', async () => {
-        mockRequirePositiveInt.mockImplementation(() => {
-            throw new ArgumentError('claude ask --timeout must be a positive integer');
-        });
-
-        await expect(askCommand.func(page, {
-            prompt: 'hi',
-            timeout: 0,
-            new: false,
-            model: 'sonnet',
-            think: false,
-        })).rejects.toThrow(ArgumentError);
-    });
-});
-
-describe('claude ask --file', () => {
-    const page = {
-        wait: vi.fn().mockResolvedValue(undefined),
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue('https://claude.ai/new'),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockEnsureOnClaude.mockResolvedValue(false);
-        mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
-        mockSetAdaptiveThinking.mockResolvedValue({ ok: true, toggled: false });
-        mockSendWithFile.mockResolvedValue({ ok: true });
-        mockGetBubbleCount.mockResolvedValue(3);
-        mockWaitForResponse.mockResolvedValue('the image shows a cat');
-        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
-        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
-        mockRequirePositiveInt.mockImplementation((v) => Number(v));
-    });
-
-    it('routes through sendWithFile and captures baseline before sending', async () => {
-        const rows = await askCommand.func(page, {
-            prompt: 'describe this',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-            file: '/tmp/cat.png',
-        });
-
-        expect(rows).toEqual([{ response: 'the image shows a cat' }]);
-        expect(mockGetBubbleCount).toHaveBeenCalledTimes(1);
-        expect(mockSendWithFile).toHaveBeenCalledWith(page, '/tmp/cat.png', 'describe this');
-        expect(mockSendMessage).not.toHaveBeenCalled();
-        expect(mockWaitForResponse).toHaveBeenCalledWith(page, 3, 'describe this', 120000);
-    });
-
-    it('surfaces file upload failure as CommandExecutionError', async () => {
-        mockSendWithFile.mockResolvedValue({ ok: false, reason: 'file preview did not appear' });
-
-        await expect(askCommand.func(page, {
-            prompt: 'describe this',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-            file: '/tmp/cat.png',
-        })).rejects.toThrow(/file preview did not appear/);
-    });
-
-    it('absorbs "Promise was collected" SPA navigation error after send', async () => {
-        mockSendWithFile.mockRejectedValue(new Error('Promise was collected'));
-
-        const rows = await askCommand.func(page, {
-            prompt: 'describe this',
-            timeout: 120,
-            new: false,
-            model: 'sonnet',
-            think: false,
-            file: '/tmp/cat.png',
-        });
-
-        expect(rows).toEqual([{ response: 'the image shows a cat' }]);
-    });
-});