@sovovs/bycli 1.8.0 → 2.0.0

package/clis/gemini/utils.test.js

@@ -1,198 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { __test__, collectGeminiTranscriptAdditions, pickGeminiDeepResearchExportUrl, sanitizeGeminiResponseText, sendGeminiMessage, } from './utils.js';
-function createPageMock() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn(),
-        getCookies: vi.fn().mockResolvedValue([]),
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({}),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        screenshot: vi.fn().mockResolvedValue(''),
-        nativeType: vi.fn().mockResolvedValue(undefined),
-        nativeKeyPress: vi.fn().mockResolvedValue(undefined),
-    };
-}
-describe('sanitizeGeminiResponseText', () => {
-    it('strips a prompt echo only when it appears as a prefixed block', () => {
-        const prompt = 'Reply with the word bycli';
-        const value = `Reply with the word bycli\n\nbycli`;
-        expect(sanitizeGeminiResponseText(value, prompt)).toBe('bycli');
-    });
-    it('does not strip prompt text that appears later in a legitimate answer', () => {
-        const prompt = 'bycli';
-        const value = 'You asked about bycli, and bycli is the right keyword here.';
-        expect(sanitizeGeminiResponseText(value, prompt)).toBe(value);
-    });
-    it('removes known Gemini footer noise', () => {
-        const value = 'Answer body\nGemini can make mistakes.\nGoogle Terms';
-        expect(sanitizeGeminiResponseText(value, '')).toBe('Answer body');
-    });
-});
-describe('collectGeminiTranscriptAdditions', () => {
-    it('joins multiple new transcript lines instead of keeping only the last line', () => {
-        const before = ['Older answer'];
-        const current = ['Older answer', 'First new line', 'Second new line'];
-        expect(collectGeminiTranscriptAdditions(before, current, '')).toBe('First new line\nSecond new line');
-    });
-    it('filters prompt echoes out of transcript additions', () => {
-        const prompt = 'Tell me a haiku';
-        const before = ['Previous'];
-        const current = ['Previous', 'Tell me a haiku', 'Tell me a haiku\n\nSoft spring rain arrives'];
-        expect(collectGeminiTranscriptAdditions(before, current, prompt)).toBe('Soft spring rain arrives');
-    });
-    it('keeps a reply line that quotes the prompt inside the answer body', () => {
-        const prompt = '请只回复：OK';
-        const before = ['baseline'];
-        const current = ['baseline', '关于“请只回复：OK”，这里是解释。'];
-        expect(collectGeminiTranscriptAdditions(before, current, prompt)).toBe('关于“请只回复：OK”，这里是解释。');
-    });
-});
-describe('gemini send strategy', () => {
-    it('includes structural composer selectors instead of relying only on english aria labels', () => {
-        expect(__test__.GEMINI_COMPOSER_SELECTORS).toContain('.ql-editor[contenteditable="true"]');
-        expect(__test__.GEMINI_COMPOSER_SELECTORS).toContain('.ql-editor[role="textbox"]');
-    });
-    it('prefers native text insertion before submitting the composer', async () => {
-        const page = createPageMock();
-        const evaluate = vi.mocked(page.evaluate);
-        const nativeType = vi.mocked(page.nativeType);
-        const nativeKeyPress = vi.mocked(page.nativeKeyPress);
-        evaluate
-            .mockResolvedValueOnce('https://gemini.google.com/app')
-            .mockResolvedValueOnce({ ok: true })
-            .mockResolvedValueOnce({ hasText: true })
-            .mockResolvedValueOnce('button');
-        const result = await sendGeminiMessage(page, '你好');
-        expect(nativeType).toHaveBeenCalledWith('你好');
-        expect(nativeKeyPress).not.toHaveBeenCalled();
-        expect(result).toBe('button');
-    });
-    it('falls back when native insertion does not update the composer', async () => {
-        const page = createPageMock();
-        const evaluate = vi.mocked(page.evaluate);
-        const nativeType = vi.mocked(page.nativeType);
-        const nativeKeyPress = vi.mocked(page.nativeKeyPress);
-        evaluate
-            .mockResolvedValueOnce('https://gemini.google.com/app')
-            .mockResolvedValueOnce({ ok: true })
-            .mockResolvedValueOnce({ hasText: false })
-            .mockResolvedValueOnce({ hasText: true })
-            .mockResolvedValueOnce('enter');
-        const result = await sendGeminiMessage(page, '你好');
-        expect(nativeType).toHaveBeenCalledWith('你好');
-        expect(nativeKeyPress).toHaveBeenCalledWith('Enter');
-        expect(evaluate).toHaveBeenCalledTimes(5);
-        expect(result).toBe('enter');
-    });
-    it('falls back when native insertion throws', async () => {
-        const page = createPageMock();
-        const evaluate = vi.mocked(page.evaluate);
-        const nativeType = vi.mocked(page.nativeType);
-        nativeType.mockRejectedValueOnce(new Error('Unknown action: cdp'));
-        evaluate
-            .mockResolvedValueOnce('https://gemini.google.com/app')
-            .mockResolvedValueOnce({ ok: true })
-            .mockResolvedValueOnce({ hasText: true })
-            .mockResolvedValueOnce('button');
-        const result = await sendGeminiMessage(page, '你好');
-        expect(nativeType).toHaveBeenCalledWith('你好');
-        expect(result).toBe('button');
-    });
-    it('retries composer preparation until a slow-loading composer appears', async () => {
-        const page = createPageMock();
-        const evaluate = vi.mocked(page.evaluate);
-        const wait = vi.mocked(page.wait);
-        evaluate
-            .mockResolvedValueOnce('https://gemini.google.com/app')
-            .mockResolvedValueOnce({ ok: false, reason: 'Could not find Gemini composer' })
-            .mockResolvedValueOnce({ ok: false, reason: 'Could not find Gemini composer' })
-            .mockResolvedValueOnce({ ok: true })
-            .mockResolvedValueOnce({ hasText: true })
-            .mockResolvedValueOnce('button');
-        const result = await sendGeminiMessage(page, '你好');
-        expect(result).toBe('button');
-        expect(wait.mock.calls.filter(([value]) => value === 1)).toHaveLength(3);
-    });
-    it('keeps retrying until a composer that appears on the fourth attempt is ready', async () => {
-        const page = createPageMock();
-        const evaluate = vi.mocked(page.evaluate);
-        const wait = vi.mocked(page.wait);
-        evaluate
-            .mockResolvedValueOnce('https://gemini.google.com/app')
-            .mockResolvedValueOnce({ ok: false, reason: 'Could not find Gemini composer' })
-            .mockResolvedValueOnce({ ok: false, reason: 'Could not find Gemini composer' })
-            .mockResolvedValueOnce({ ok: false, reason: 'Could not find Gemini composer' })
-            .mockResolvedValueOnce({ ok: true })
-            .mockResolvedValueOnce({ hasText: true })
-            .mockResolvedValueOnce('button');
-        const result = await sendGeminiMessage(page, '你好');
-        expect(result).toBe('button');
-        expect(wait.mock.calls.filter(([value]) => value === 1)).toHaveLength(4);
-    });
-    it('avoids innerHTML in the fallback insertion path for trusted types pages', () => {
-        expect(__test__.insertComposerTextFallbackScript('你好')).not.toContain('innerHTML');
-        expect(__test__.insertComposerTextFallbackScript('你好')).toContain('replaceChildren');
-    });
-    it('keeps a button submit path in the generated submit script', () => {
-        expect(__test__.submitComposerScript()).toContain('.click()');
-    });
-    it('supports localized new chat labels in the generated new-chat script', () => {
-        expect(__test__.clickNewChatScript()).toContain('发起新对话');
-    });
-});
-describe('gemini turn normalization', () => {
-    it('collapses only adjacent duplicate turns so identical replies across rounds remain visible', () => {
-        const turns = [
-            { Role: 'User', Text: '你说\n\n请只回复：OK' },
-            { Role: 'User', Text: '请只回复：OK' },
-            { Role: 'Assistant', Text: 'OK' },
-            { Role: 'Assistant', Text: 'OK' },
-            { Role: 'User', Text: '你说\n\n请只回复：OK' },
-            { Role: 'User', Text: '请只回复：OK' },
-            { Role: 'Assistant', Text: 'OK' },
-            { Role: 'Assistant', Text: 'OK' },
-        ];
-        expect(__test__.collapseAdjacentGeminiTurns(turns)).toEqual([
-            { Role: 'User', Text: '你说\n\n请只回复：OK' },
-            { Role: 'User', Text: '请只回复：OK' },
-            { Role: 'Assistant', Text: 'OK' },
-            { Role: 'User', Text: '你说\n\n请只回复：OK' },
-            { Role: 'User', Text: '请只回复：OK' },
-            { Role: 'Assistant', Text: 'OK' },
-        ]);
-    });
-});
-describe('pickGeminiDeepResearchExportUrl', () => {
-    it('prefers docs.google.com document url over sheets and noise endpoints', () => {
-        const picked = pickGeminiDeepResearchExportUrl([
-            'xhr::https://gemini.google.com/_/BardChatUi/data/batchexecute?rpcids=ESY5D',
-            'performance::https://docs.google.com/spreadsheets/d/1abc/edit',
-            'open::https://docs.google.com/document/d/1docid/edit',
-        ], 'https://gemini.google.com/app/abc');
-        expect(picked).toEqual({
-            url: 'https://docs.google.com/document/d/1docid/edit',
-            source: 'window-open',
-        });
-    });
-    it('returns none when only non-export telemetry urls are present', () => {
-        const picked = pickGeminiDeepResearchExportUrl([
-            'fetch::https://gemini.google.com/_/BardChatUi/cspreport',
-            'performance::https://www.google-analytics.com/g/collect?v=2',
-        ], 'https://gemini.google.com/app/abc');
-        expect(picked).toEqual({ url: '', source: 'none' });
-    });
-});

package/clis/geogebra/geogebra.test.js

@@ -1,175 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ensureApplet, ggbEval, ggbGetProperty, ggbListObjects, ggbWaitForObjectCount } from './utils.js';
-import './add-circle.js';
-import './add-line.js';
-import './add-point.js';
-import './add-polygon.js';
-import './eval.js';
-import './hexagon.js';
-import './info.js';
-import './list.js';
-import './triangle.js';
-
-function createPageMock(url = 'https://www.geogebra.org/geometry') {
-  return {
-    goto: vi.fn().mockResolvedValue(undefined),
-    evaluate: vi.fn(),
-    getCurrentUrl: vi.fn().mockResolvedValue(url),
-    wait: vi.fn().mockResolvedValue(undefined),
-    screenshot: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-describe('ensureApplet', () => {
-  it('skips navigation when already on the geometry page', async () => {
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate.mockResolvedValue(true);
-    await ensureApplet(page);
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('unwraps Browser Bridge evaluate envelopes while checking applet readiness', async () => {
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate.mockResolvedValue({ session: 1, data: true });
-    await ensureApplet(page);
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('navigates when not on the geometry page', async () => {
-    const page = createPageMock('https://example.com');
-    page.evaluate.mockResolvedValue(true);
-    await ensureApplet(page);
-    expect(page.goto).toHaveBeenCalledWith('https://www.geogebra.org/geometry');
-  });
-
-  it('throws when ggbApplet never becomes available', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue(false);
-    await expect(ensureApplet(page)).rejects.toThrow(CommandExecutionError);
-  });
-});
-
-describe('ggbEval', () => {
-  it('calls evalCommandGetLabels and evalCommand', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue({ ok: true, label: 'A', beforeCount: 0, afterCount: 1, error: null });
-    const result = await ggbEval(page, 'A=(1,2)');
-    expect(result).toEqual({ ok: true, label: 'A', beforeCount: 0, afterCount: 1, error: null });
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-  });
-
-  it('throws typed errors for malformed evaluate results', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue({ nope: true });
-    await expect(ggbEval(page, 'A=(1,2)')).rejects.toThrow(CommandExecutionError);
-  });
-});
-
-describe('ggbGetProperty', () => {
-  it('requests a property from the applet', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue('point');
-    const result = await ggbGetProperty(page, 'A', 'type');
-    expect(result).toBe('point');
-  });
-});
-
-describe('ggbListObjects', () => {
-  it('normalizes object rows from the applet', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue([
-      { name: 'A', type: 'point', value: '(0, 0)', visible: true },
-      { name: 't1', type: 'polygon', value: '', visible: true },
-    ]);
-    const result = await ggbListObjects(page);
-    expect(result).toHaveLength(2);
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-  });
-
-  it('unwraps Browser Bridge envelopes for object rows', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue({ session: 1, data: [{ name: 'A', type: 'point', value: '(0, 0)', visible: true }] });
-    const result = await ggbListObjects(page);
-    expect(result).toEqual([{ name: 'A', type: 'point', value: '(0, 0)', visible: true }]);
-  });
-
-  it('throws typed error when object names exist but property extraction fails', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue({ error: 'getObjectType failed', name: 'A' });
-    await expect(ggbListObjects(page)).rejects.toThrow(CommandExecutionError);
-  });
-});
-
-describe('ggbWaitForObjectCount', () => {
-  it('returns the detected object count', async () => {
-    const page = createPageMock();
-    page.evaluate.mockResolvedValue(4);
-    const result = await ggbWaitForObjectCount(page, 4);
-    expect(result).toBe(4);
-  });
-});
-
-describe('geogebra command typed boundaries', () => {
-  it('validates add-point args before navigating', async () => {
-    const command = getRegistry().get('geogebra/add-point');
-    const page = createPageMock('https://example.com');
-    await expect(command.func(page, { name: 'A', coords: 'bad' })).rejects.toThrow(ArgumentError);
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('validates triangle size before navigating instead of silently defaulting', async () => {
-    const command = getRegistry().get('geogebra/triangle');
-    const page = createPageMock('https://example.com');
-    await expect(command.func(page, { size: 'not-a-number' })).rejects.toThrow(ArgumentError);
-    expect(page.goto).not.toHaveBeenCalled();
-  });
-
-  it('fails eval command execution instead of returning a success row for failed commands', async () => {
-    const command = getRegistry().get('geogebra/eval');
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce({ ok: false, label: '', beforeCount: 0, afterCount: 0, error: 'Unknown command' });
-    await expect(command.func(page, { command: 'NotACommand(' })).rejects.toThrow(CommandExecutionError);
-  });
-
-  it('creates add-line rows from validated labels', async () => {
-    const command = getRegistry().get('geogebra/add-line');
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce({ ok: true, label: 'f', beforeCount: 2, afterCount: 3, error: null });
-    await expect(command.func(page, { points: 'A,B', type: 'segment' })).resolves.toEqual([
-      { label: 'f', type: 'segment', points: 'A,B' },
-    ]);
-  });
-
-  it('does not turn object property extraction failures into empty list results', async () => {
-    const command = getRegistry().get('geogebra/list');
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce({ error: 'getObjectType failed', name: 'A' });
-    await expect(command.func(page, {})).rejects.toThrow(CommandExecutionError);
-  });
-
-  it('does not turn malformed info existence probes into not-found results', async () => {
-    const command = getRegistry().get('geogebra/info');
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce({ nope: true });
-    await expect(command.func(page, { name: 'A' })).rejects.toThrow(CommandExecutionError);
-  });
-
-  it('maps explicit false info existence probes to EmptyResultError', async () => {
-    const command = getRegistry().get('geogebra/info');
-    const page = createPageMock('https://www.geogebra.org/geometry');
-    page.evaluate
-      .mockResolvedValueOnce(true)
-      .mockResolvedValueOnce({ ok: true, exists: false });
-    await expect(command.func(page, { name: 'A' })).rejects.toThrow(EmptyResultError);
-  });
-});

package/clis/gitee/search.test.js

@@ -1,65 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './search.js';
-
-function mockGiteeResponse(hits) {
-    return {
-        ok: true,
-        json: () => Promise.resolve({ hits: { hits } }),
-    };
-}
-
-function makePage() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-    };
-}
-
-describe('gitee search', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-
-    it('emits empty-string for missing language / description instead of a sentinel', async () => {
-        const cmd = getRegistry().get('gitee/search');
-        expect(cmd?.func).toBeTypeOf('function');
-        const fetchMock = vi.fn().mockResolvedValue(mockGiteeResponse([
-            {
-                fields: {
-                    title: 'someuser/no-meta-repo',
-                    url: 'https://gitee.com/someuser/no-meta-repo',
-                },
-            },
-        ]));
-        vi.stubGlobal('fetch', fetchMock);
-        const rows = await cmd.func(makePage(), { keyword: 'test', limit: 10 });
-        expect(rows).toHaveLength(1);
-        expect(rows[0].name).toBe('someuser/no-meta-repo');
-        expect(rows[0].language).toBe('');
-        expect(rows[0].description).toBe('');
-    });
-
-    it('passes through populated language / description verbatim', async () => {
-        const cmd = getRegistry().get('gitee/search');
-        const fetchMock = vi.fn().mockResolvedValue(mockGiteeResponse([
-            {
-                fields: {
-                    title: 'org/repo-a',
-                    url: 'https://gitee.com/org/repo-a',
-                    langs: 'TypeScript',
-                    description: 'A test repo',
-                    'count.star': '42',
-                },
-            },
-        ]));
-        vi.stubGlobal('fetch', fetchMock);
-        const rows = await cmd.func(makePage(), { keyword: 'test', limit: 10 });
-        expect(rows[0].language).toBe('TypeScript');
-        expect(rows[0].description).toBe('A test repo');
-        expect(rows[0].stars).toBe('42');
-    });
-});

package/clis/gitee/user.test.js

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './user.js';
-const command = getRegistry().get('gitee/user');
-function createPage(snapshot) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(snapshot),
-    };
-}
-describe('gitee user', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-    it('registers the gitee user command', () => {
-        expect(command).toMatchObject({
-            site: 'gitee',
-            name: 'user',
-        });
-    });
-    it('does not mislabel contribution totals as Gitee Index when the real index is unavailable', async () => {
-        const page = createPage({
-            notFound: false,
-            blocked: false,
-            nickname: 'Alice',
-            followers: '12',
-            publicRepos: '7',
-            giteeIndex: '',
-            contributionTotal: 321,
-        });
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
-            login: 'alice',
-            name: 'Alice',
-            followers: 12,
-            public_repos: 7,
-        }), { status: 200 })));
-        const rows = await command.func(page, { username: 'alice' });
-        expect(rows).toContainEqual({ field: 'Gitee Index', value: '-' });
-    });
-    it('uses an API-provided Gitee Index when available', async () => {
-        const page = createPage({
-            notFound: false,
-            blocked: false,
-            nickname: '',
-            followers: '',
-            publicRepos: '',
-            giteeIndex: '',
-        });
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
-            login: 'alice',
-            followers: 9,
-            public_repos: 3,
-            gitee_index: 88,
-        }), { status: 200 })));
-        const rows = await command.func(page, { username: 'alice' });
-        expect(rows).toContainEqual({ field: 'Gitee Index', value: '88' });
-    });
-});

package/clis/google/utils.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseRssItems } from './utils.js';
-describe('parseRssItems', () => {
-    it('extracts plain text fields', () => {
-        const xml = `
-      <channel>
-        <item><title>Hello</title><link>https://example.com</link></item>
-        <item><title>World</title><link>https://test.com</link></item>
-      </channel>
-    `;
-        const items = parseRssItems(xml, ['title', 'link']);
-        expect(items).toEqual([
-            { title: 'Hello', link: 'https://example.com' },
-            { title: 'World', link: 'https://test.com' },
-        ]);
-    });
-    it('handles CDATA-wrapped content', () => {
-        const xml = `
-      <item><title><![CDATA[Breaking News]]></title><link>https://news.com</link></item>
-    `;
-        const items = parseRssItems(xml, ['title', 'link']);
-        expect(items).toEqual([
-            { title: 'Breaking News', link: 'https://news.com' },
-        ]);
-    });
-    it('handles namespaced fields like ht:approx_traffic', () => {
-        const xml = `
-      <item>
-        <title>AI</title>
-        <ht:approx_traffic>500,000+</ht:approx_traffic>
-        <pubDate>Mon, 20 Mar 2026</pubDate>
-      </item>
-    `;
-        const items = parseRssItems(xml, ['title', 'ht:approx_traffic', 'pubDate']);
-        expect(items).toEqual([
-            { title: 'AI', 'ht:approx_traffic': '500,000+', pubDate: 'Mon, 20 Mar 2026' },
-        ]);
-    });
-    it('returns empty string for missing fields', () => {
-        const xml = `<item><title>Test</title></item>`;
-        const items = parseRssItems(xml, ['title', 'missing']);
-        expect(items).toEqual([{ title: 'Test', missing: '' }]);
-    });
-    it('handles tags with attributes (e.g. <source url="...">)', () => {
-        const xml = `
-      <item>
-        <title><![CDATA[AI reshapes everything - Reuters]]></title>
-        <source url="https://reuters.com">Reuters</source>
-        <link>https://news.google.com/123</link>
-      </item>
-    `;
-        const items = parseRssItems(xml, ['title', 'source', 'link']);
-        expect(items).toEqual([
-            { title: 'AI reshapes everything - Reuters', source: 'Reuters', link: 'https://news.google.com/123' },
-        ]);
-    });
-    it('handles mixed CDATA and plain text in the same item', () => {
-        const xml = `
-      <item>
-        <title><![CDATA[Breaking: Major event]]></title>
-        <link>https://example.com/article</link>
-        <pubDate>Fri, 21 Mar 2026</pubDate>
-      </item>
-    `;
-        const items = parseRssItems(xml, ['title', 'link', 'pubDate']);
-        expect(items).toEqual([
-            { title: 'Breaking: Major event', link: 'https://example.com/article', pubDate: 'Fri, 21 Mar 2026' },
-        ]);
-    });
-    it('returns empty array for no items', () => {
-        const xml = `<channel><title>Empty</title></channel>`;
-        const items = parseRssItems(xml, ['title']);
-        expect(items).toEqual([]);
-    });
-});

package/clis/google-scholar/cite.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './cite.js';
-
-describe('google-scholar cite command', () => {
-    const command = getRegistry().get('google-scholar/cite');
-
-    it('registers as a public browser command', () => {
-        expect(command).toBeDefined();
-        expect(command.site).toBe('google-scholar');
-        expect(command.strategy).toBe('public');
-        expect(command.browser).toBe(true);
-    });
-
-    it('rejects empty queries before browser navigation', async () => {
-        const page = { goto: vi.fn() };
-        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
-            name: 'ArgumentError',
-            code: 'ARGUMENT',
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('throws when the requested search result index does not exist', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValueOnce({ ok: false, reason: 'result not found at index 2' }),
-        };
-        await expect(command.func(page, { query: 'test', index: 2 })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('looks up the requested citation style instead of only locking BibTeX', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ ok: true, title: 'Paper Title' })
-                .mockResolvedValueOnce('https://example.com/refworks')
-                .mockResolvedValueOnce('RefWorks citation body'),
-        };
-        const result = await command.func(page, { query: 'test', style: 'refworks' });
-        expect(result).toEqual([{ title: 'Paper Title', format: 'refworks', citation: 'RefWorks citation body' }]);
-        expect(page.evaluate.mock.calls[1][0]).toContain('RefWorks');
-    });
-});

package/clis/google-scholar/profile.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './profile.js';
-
-describe('google-scholar profile command', () => {
-    const command = getRegistry().get('google-scholar/profile');
-
-    it('registers as a public browser command', () => {
-        expect(command).toBeDefined();
-        expect(command.site).toBe('google-scholar');
-        expect(command.strategy).toBe('public');
-        expect(command.browser).toBe(true);
-    });
-
-    it('rejects empty author before browser navigation', async () => {
-        const page = { goto: vi.fn() };
-        await expect(command.func(page, { author: '   ' })).rejects.toMatchObject({
-            name: 'ArgumentError',
-            code: 'ARGUMENT',
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('throws when author search does not resolve to a profile', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValueOnce(false),
-        };
-        await expect(command.func(page, { author: 'missing author' })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws when the loaded profile has no papers', async () => {
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValueOnce({
-                name: 'Author Name',
-                affiliation: 'Org',
-                citations: '0',
-                hIndex: '0',
-                i10Index: '0',
-                papers: [],
-            }),
-        };
-        await expect(command.func(page, { author: 'JicYPdAAAAAJ' })).rejects.toThrow(CommandExecutionError);
-    });
-});