@sovovs/bycli 1.8.0 → 2.0.0

package/clis/chatwise/composer.test.js

@@ -1,186 +0,0 @@
-import { JSDOM } from 'jsdom';
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, TimeoutError } from '@sovovs/bycli/errors';
-import {
-    buildChatwiseInjectTextJs,
-    buildChatwiseMessageCountJs,
-    buildChatwiseResponseAfterJs,
-    requirePositiveTimeout,
-    scoreChatwiseComposerCandidate,
-    selectBestChatwiseComposer,
-} from './utils.js';
-import { askCommand } from './ask.js';
-
-function candidate(overrides = {}) {
-    return {
-        index: 0,
-        hidden: false,
-        role: 'textbox',
-        classes: 'cm-content cm-lineWrapping',
-        editorClasses: 'cm-editor',
-        ariaLabel: '',
-        placeholder: '',
-        text: '',
-        rect: { y: 0, h: 30 },
-        ...overrides,
-    };
-}
-
-function runBrowserScript(html, script) {
-    const dom = new JSDOM(html, { url: 'app://chatwise.local/', runScripts: 'outside-only' });
-    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetWidth', { configurable: true, get: () => 400 });
-    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetHeight', { configurable: true, get: () => 32 });
-    dom.window.HTMLElement.prototype.getClientRects = () => [{ length: 1 }];
-    dom.window.document.execCommand = () => false;
-    return { dom, result: dom.window.eval(script) };
-}
-
-function makePage(evaluateResults = []) {
-    const evaluate = vi.fn();
-    for (const result of evaluateResults) evaluate.mockResolvedValueOnce(result);
-    evaluate.mockResolvedValue(null);
-    return {
-        evaluate,
-        wait: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-    };
-}
-
-describe('chatwise composer selection', () => {
-    it('prefers the main composer over auxiliary contenteditable editors', () => {
-        const mainComposer = candidate({
-            index: 0,
-            placeholder: 'placeholder Enter a message here, press ⏎ to send',
-            rect: { y: 860, h: 32 },
-        });
-        const optionalDescription = candidate({
-            index: 1,
-            placeholder: 'placeholder Optional description',
-            editorClasses: 'cm-editor simple-editor',
-            rect: { y: 400, h: 32 },
-        });
-        const userContext = candidate({
-            index: 2,
-            text: '# User Context Document',
-            editorClasses: 'cm-editor simple-editor',
-            rect: { y: 460, h: 1200 },
-        });
-
-        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
-            scoreChatwiseComposerCandidate(optionalDescription, 900),
-        );
-        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
-            scoreChatwiseComposerCandidate(userContext, 900),
-        );
-
-        expect(selectBestChatwiseComposer([
-            optionalDescription,
-            userContext,
-            mainComposer,
-        ], 900)?.index).toBe(0);
-    });
-
-    it('rejects hidden or low-confidence candidates instead of injecting into the wrong editor', () => {
-        expect(selectBestChatwiseComposer([
-            candidate({
-                index: 0,
-                hidden: true,
-                placeholder: 'Enter a message here, press ⏎ to send',
-                rect: { y: 860, h: 32 },
-            }),
-        ], 900)).toBeNull();
-
-        expect(selectBestChatwiseComposer([
-            candidate({
-                index: 1,
-                placeholder: 'Optional description',
-                editorClasses: 'cm-editor simple-editor',
-                rect: { y: 860, h: 32 },
-            }),
-            candidate({
-                index: 2,
-                text: '# User Context Document',
-                editorClasses: 'cm-editor simple-editor',
-                rect: { y: 870, h: 32 },
-            }),
-        ], 900)).toBeNull();
-    });
-
-    it('injects text into the scored main composer instead of the last contenteditable', () => {
-        const html = `
-          <div class="cm-editor simple-editor">
-            <div class="cm-placeholder">Optional description</div>
-            <div id="optional" contenteditable="true" role="textbox"></div>
-          </div>
-          <div class="cm-editor">
-            <div class="cm-placeholder">Enter a message here, press ⏎ to send</div>
-            <div id="main" class="cm-content" contenteditable="true" role="textbox"></div>
-          </div>
-          <div class="cm-editor simple-editor">
-            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
-          </div>
-        `;
-
-        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
-
-        expect(result).toBe(true);
-        expect(dom.window.document.querySelector('#main')?.textContent).toBe('hello');
-        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
-        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
-    });
-
-    it('fails injection when only auxiliary editors are present', () => {
-        const html = `
-          <div class="cm-editor simple-editor">
-            <div class="cm-placeholder">Optional description</div>
-            <div id="optional" contenteditable="true" role="textbox"></div>
-          </div>
-          <div class="cm-editor simple-editor">
-            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
-          </div>
-        `;
-
-        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
-
-        expect(result).toBe(false);
-        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
-        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
-    });
-
-    it('reads only real message wrapper content after the previous count', () => {
-        const html = `
-          <div class="group/message">old message</div>
-          <div class="timestamp">12:00</div>
-          <div class="group/message">new assistant answer</div>
-        `;
-
-        expect(runBrowserScript(html, buildChatwiseMessageCountJs()).result).toBe(2);
-        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBe('new assistant answer');
-    });
-
-    it('does not treat the user prompt wrapper as an assistant response', () => {
-        const html = `
-          <div class="group/message">old message</div>
-          <div class="group/message">user prompt</div>
-        `;
-
-        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBeNull();
-    });
-
-    it('validates timeout explicitly', () => {
-        expect(requirePositiveTimeout(30)).toBe(30);
-        expect(() => requirePositiveTimeout('30')).toThrow(ArgumentError);
-        expect(() => requirePositiveTimeout(0)).toThrow(ArgumentError);
-    });
-
-    it('fails fast when ask times out instead of returning a System success row', async () => {
-        const page = makePage([
-            1,
-            true,
-            null,
-        ]);
-
-        await expect(askCommand.func(page, { text: 'hello', timeout: 1 }))
-            .rejects.toBeInstanceOf(TimeoutError);
-    });
-});

package/clis/chess/analyze.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import './analyze.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const manifestPath = resolve(__dirname, '../../cli-manifest.json');
-
-function loadManifestCommand(name) {
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    return manifest.find(cmd => cmd.site === 'chess' && cmd.name === name);
-}
-
-function makePage() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-    };
-}
-
-describe('chess analyze command', () => {
-    it('navigates to /analysis/game/<kind>/<id> and reports the URL', async () => {
-        const cmd = getRegistry().get('chess/analyze');
-        const page = makePage();
-        const rows = await cmd.func(page, { 'game-url': 'https://www.chess.com/game/live/42' });
-        expect(rows).toEqual([{ kind: 'live', game_id: '42', analysis_url: 'https://www.chess.com/analysis/game/live/42' }]);
-        expect(page.goto).toHaveBeenCalledWith('https://www.chess.com/analysis/game/live/42');
-    });
-
-    it('preserves daily kind in the analysis URL', async () => {
-        const cmd = getRegistry().get('chess/analyze');
-        const page = makePage();
-        const rows = await cmd.func(page, { 'game-url': 'https://www.chess.com/game/daily/123' });
-        expect(rows[0].analysis_url).toBe('https://www.chess.com/analysis/game/daily/123');
-    });
-
-    it('rejects invalid URL with ArgumentError before navigation', async () => {
-        const cmd = getRegistry().get('chess/analyze');
-        const page = makePage();
-        await expect(cmd.func(page, { 'game-url': 'not-a-url' })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('throws CommandExecutionError without a browser page', async () => {
-        const cmd = getRegistry().get('chess/analyze');
-        await expect(cmd.func(null, { 'game-url': 'https://www.chess.com/game/live/42' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when browser navigation fails', async () => {
-        const cmd = getRegistry().get('chess/analyze');
-        const page = makePage();
-        page.goto.mockRejectedValue(new Error('navigation failed'));
-        await expect(cmd.func(page, { 'game-url': 'https://www.chess.com/game/live/42' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('registers with the expected columns + browser flag', () => {
-        const cmd = getRegistry().get('chess/analyze');
-        expect(cmd?.columns).toEqual(['kind', 'game_id', 'analysis_url']);
-        expect(cmd?.browser).toBe(true);
-        expect(cmd?.navigateBefore).toBe(false);
-    });
-
-    it('build manifest keeps analyze pre-navigation disabled and game source attribution stable', () => {
-        expect(loadManifestCommand('analyze')).toMatchObject({
-            navigateBefore: false,
-            modulePath: 'chess/analyze.js',
-            sourceFile: 'chess/analyze.js',
-        });
-        expect(loadManifestCommand('game')).toMatchObject({
-            modulePath: 'chess/game.js',
-            sourceFile: 'chess/game.js',
-        });
-    });
-});

package/clis/chess/game.test.js

@@ -1,178 +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 './game.js';
-
-const { summarizeGame } = await import('./game.js').then((m) => m.__test__);
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-
-function mockFetch(payload, status = 200) {
-    return vi.fn().mockResolvedValue({
-        ok: status === 200,
-        status,
-        json: () => Promise.resolve(payload),
-    });
-}
-
-describe('chess game command', () => {
-    it('summarizeGame maps the callback payload to the canonical row shape', () => {
-        const row = summarizeGame({
-            kind: 'live',
-            id: '999',
-            payload: {
-                game: {
-                    pgnHeaders: {
-                        Date: '2026.05.17',
-                        White: 'Hikaru',
-                        Black: 'tactic',
-                        Result: '1-0',
-                        ECO: 'A01',
-                        WhiteElo: 3454,
-                        BlackElo: 2869,
-                        TimeControl: '180',
-                        Termination: 'Hikaru won by resignation',
-                    },
-                    colorOfWinner: 'white',
-                    isRated: true,
-                    plyCount: 111,
-                    endTime: 1747584400,
-                },
-                players: {
-                    top: { username: 'tactic', color: 'black', rating: 2869 },
-                    bottom: { username: 'Hikaru', color: 'white', rating: 3454 },
-                },
-            },
-        });
-        expect(row).toMatchObject({
-            kind: 'live',
-            game_id: '999',
-            date: '2026-05-17',
-            white: 'Hikaru',
-            white_rating: 3454,
-            black: 'tactic',
-            black_rating: 2869,
-            result: '1-0',
-            winner_color: 'white',
-            termination: 'Hikaru won by resignation',
-            eco: 'A01',
-            time_control: '180',
-            rated: true,
-            ply_count: 111,
-            url: 'https://www.chess.com/game/live/999',
-        });
-    });
-
-    it('summarizeGame falls back to pgnHeaders when players are missing', () => {
-        const row = summarizeGame({
-            kind: 'daily',
-            id: '1',
-            payload: {
-                game: {
-                    pgnHeaders: { White: 'A', Black: 'B', Result: '1/2-1/2', WhiteElo: 1200, BlackElo: 1300 },
-                    colorOfWinner: '',
-                    isRated: false,
-                    daysPerTurn: 3,
-                },
-                players: {},
-            },
-        });
-        expect(row.white).toBe('A');
-        expect(row.black_rating).toBe(1300);
-        expect(row.time_control).toBe('3d/turn');
-        expect(row.rated).toBe(false);
-    });
-
-    it('summarizeGame throws CommandExecutionError on missing game payload', () => {
-        expect(() => summarizeGame({ kind: 'live', id: '1', payload: {} })).toThrow(CommandExecutionError);
-        expect(() => summarizeGame({ kind: 'live', id: '1', payload: null })).toThrow(CommandExecutionError);
-    });
-
-    it('summarizeGame throws CommandExecutionError on malformed nested payloads', () => {
-        expect(() => summarizeGame({
-            kind: 'live',
-            id: '1',
-            payload: { game: { pgnHeaders: [] } },
-        })).toThrow(CommandExecutionError);
-        expect(() => summarizeGame({
-            kind: 'live',
-            id: '1',
-            payload: { game: { pgnHeaders: { White: 'A', Black: 'B' } }, players: [] },
-        })).toThrow(CommandExecutionError);
-    });
-
-    it('summarizeGame requires stable players and result evidence', () => {
-        expect(() => summarizeGame({
-            kind: 'live',
-            id: '1',
-            payload: { game: { pgnHeaders: { White: 'A', Black: 'B' } }, players: {} },
-        })).toThrow(CommandExecutionError);
-        expect(() => summarizeGame({
-            kind: 'live',
-            id: '1',
-            payload: { game: { pgnHeaders: { White: 'A', Result: '1-0' } }, players: {} },
-        })).toThrow(CommandExecutionError);
-    });
-
-    it('command fetches the callback URL and returns a single row', async () => {
-        const fetchMock = mockFetch({
-            game: { pgnHeaders: { White: 'A', Black: 'B', Result: '1-0', WhiteElo: 100, BlackElo: 90 } },
-            players: {},
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('chess/game');
-        const rows = await cmd.func({ 'game-url': 'https://www.chess.com/game/live/42' });
-        expect(rows).toHaveLength(1);
-        expect(rows[0].url).toBe('https://www.chess.com/game/live/42');
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://www.chess.com/callback/live/game/42',
-            expect.objectContaining({ headers: expect.any(Object) }),
-        );
-    });
-
-    it('command surfaces 404 as EmptyResultError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 404 }));
-        const cmd = getRegistry().get('chess/game');
-        await expect(cmd.func({ 'game-url': 'https://www.chess.com/game/live/1' }))
-            .rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('command surfaces non-2xx as CommandExecutionError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 500 }));
-        const cmd = getRegistry().get('chess/game');
-        await expect(cmd.func({ 'game-url': 'https://www.chess.com/game/live/1' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('command maps fetch and JSON failures to CommandExecutionError', async () => {
-        const cmd = getRegistry().get('chess/game');
-        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new TypeError('network down')));
-        await expect(cmd.func({ 'game-url': 'https://www.chess.com/game/live/1' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: () => Promise.reject(new SyntaxError('bad json')),
-        }));
-        await expect(cmd.func({ 'game-url': 'https://www.chess.com/game/live/1' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('command maps wrong-shape callback JSON to CommandExecutionError', async () => {
-        vi.stubGlobal('fetch', mockFetch([]));
-        const cmd = getRegistry().get('chess/game');
-        await expect(cmd.func({ 'game-url': 'https://www.chess.com/game/live/1' }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('rejects invalid URL with ArgumentError before any fetch', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('chess/game');
-        await expect(cmd.func({ 'game-url': 'not-a-url' })).rejects.toBeInstanceOf(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-});

package/clis/chess/games.test.js

@@ -1,164 +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 './games.js';
-
-const { parseLimit } = await import('./games.js').then((m) => m.__test__);
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-
-function fetchFor(map) {
-    return vi.fn().mockImplementation((url) => {
-        if (map.has(url)) {
-            return Promise.resolve({ ok: true, status: 200, json: () => Promise.resolve(map.get(url)) });
-        }
-        return Promise.resolve({ ok: false, status: 404 });
-    });
-}
-
-function game(white, whiteRating, black, blackRating, endTime, extra = {}) {
-    return {
-        url: `https://www.chess.com/game/live/${endTime}`,
-        end_time: endTime,
-        time_class: 'blitz',
-        rated: true,
-        eco: 'C50',
-        white: { username: white, rating: whiteRating, result: 'win' },
-        black: { username: black, rating: blackRating, result: 'resigned' },
-        ...extra,
-    };
-}
-
-describe('chess games command', () => {
-    it('parseLimit accepts 1-100, rejects everything else', () => {
-        expect(parseLimit(undefined)).toBe(10);
-        expect(parseLimit(1)).toBe(1);
-        expect(parseLimit(100)).toBe(100);
-        expect(() => parseLimit(0)).toThrow(ArgumentError);
-        expect(() => parseLimit(101)).toThrow(ArgumentError);
-        expect(() => parseLimit(1.5)).toThrow(ArgumentError);
-        expect(() => parseLimit('abc')).toThrow(ArgumentError);
-    });
-
-    it('returns recent games newest-first sliced to --limit', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/hikaru/games/archives', {
-                archives: ['https://api.chess.com/pub/player/hikaru/games/2026/04', 'https://api.chess.com/pub/player/hikaru/games/2026/05'],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/05', {
-                games: [
-                    game('Hikaru', 3286, 'A', 2900, 1777737000),
-                    game('Hikaru', 3286, 'B', 2950, 1777737500),
-                    game('Hikaru', 3286, 'C', 3000, 1777737900),
-                ],
-            }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        const rows = await cmd.func({ username: 'Hikaru', limit: 2 });
-        expect(rows).toHaveLength(2);
-        // archive is reversed (newest month first), games within are reversed
-        // so the first row corresponds to the LAST game in the JSON array.
-        expect(rows[0].opponent).toBe('C');
-        expect(rows[1].opponent).toBe('B');
-    });
-
-    it('walks multiple months until --limit is filled', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/hikaru/games/archives', {
-                archives: ['https://api.chess.com/pub/player/hikaru/games/2026/03', 'https://api.chess.com/pub/player/hikaru/games/2026/04'],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/04', {
-                games: [game('Hikaru', 3286, 'A', 2900, 1777737000)],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/03', {
-                games: [game('Hikaru', 3286, 'B', 2950, 1774000000)],
-            }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        const rows = await cmd.func({ username: 'Hikaru', limit: 2 });
-        expect(rows.map((r) => r.opponent)).toEqual(['A', 'B']);
-    });
-
-    it('throws EmptyResultError when archives list is empty', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/someuser/games/archives', { archives: [] }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'someuser', limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when archives payload is wrong-shape', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/someuser/games/archives', { archives: {} }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'someuser', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when monthly archive games payload is wrong-shape', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/hikaru/games/archives', {
-                archives: ['https://api.chess.com/pub/player/hikaru/games/2026/05'],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/05', { games: null }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'Hikaru', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when a game row lacks stable identity', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/hikaru/games/archives', {
-                archives: ['https://api.chess.com/pub/player/hikaru/games/2026/05'],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/05', {
-                games: [{
-                    end_time: 1777737000,
-                    white: { username: 'Hikaru', rating: 3286, result: 'win' },
-                    black: { username: 'A', rating: 2900, result: 'resigned' },
-                }],
-            }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'Hikaru', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when a game row does not include the requested player', async () => {
-        const map = new Map([
-            ['https://api.chess.com/pub/player/hikaru/games/archives', {
-                archives: ['https://api.chess.com/pub/player/hikaru/games/2026/05'],
-            }],
-            ['https://api.chess.com/pub/player/hikaru/games/2026/05', {
-                games: [game('A', 2900, 'B', 2800, 1777737000)],
-            }],
-        ]);
-        vi.stubGlobal('fetch', fetchFor(map));
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'Hikaru', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws ArgumentError on invalid username before any fetch', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('chess/games');
-        await expect(cmd.func({ username: 'a b', limit: 5 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('registers with the expected columns', () => {
-        const cmd = getRegistry().get('chess/games');
-        expect(cmd?.columns).toEqual([
-            'date', 'time_class', 'rated', 'my_color', 'my_rating', 'my_result',
-            'opponent', 'opponent_rating', 'accuracy_white', 'accuracy_black',
-            'eco', 'opening_name', 'url',
-        ]);
-    });
-});