@sovovs/bycli 1.8.0 → 2.0.0

package/clis/zhihu/search.test.js

@@ -1,198 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './search.js';
-
-const {
-    normalizeSearchUrl,
-    requireSearchPayload,
-    normalizeResultItem,
-} = await import('./search.js').then((m) => m.__test__);
-
-describe('zhihu search', () => {
-    it('returns search_result entries from the Zhihu search API', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        expect(cmd?.func).toBeTypeOf('function');
-        const goto = vi.fn().mockResolvedValue(undefined);
-        const evaluate = vi.fn().mockImplementation(async (js) => {
-            expect(js).toContain('/api/v4/search_v3');
-            expect(js).toContain('limit=20');
-            expect(js).toContain("credentials: 'include'");
-            return {
-                data: [
-                    {
-                        type: 'hot_timing',
-                        object: {
-                            type: 'hot_timing',
-                            content_items: [
-                                { object: { id: 'discussion-1', type: 'article', title: 'discussion' } },
-                            ],
-                        },
-                    },
-                    {
-                        type: 'search_result',
-                        object: {
-                            id: 'a1',
-                            type: 'answer',
-                            author: { name: 'alice' },
-                            voteup_count: 12,
-                            question: { id: 'q1', name: '<em>Codex</em> &#34;question&#34;' },
-                        },
-                    },
-                    {
-                        type: 'search_result',
-                        object: {
-                            id: 'p1',
-                            type: 'article',
-                            title: '<em>Codex</em> article',
-                            author: { name: 'bob' },
-                            voteup_count: 7,
-                        },
-                    },
-                ],
-                paging: { is_end: true },
-            };
-        });
-        const page = { goto, evaluate };
-        await expect(cmd.func(page, { query: 'codex', limit: 2 })).resolves.toEqual([
-            {
-                rank: 1,
-                title: 'Codex "question"',
-                type: 'answer',
-                author: 'alice',
-                votes: 12,
-                url: 'https://www.zhihu.com/question/q1/answer/a1',
-            },
-            {
-                rank: 2,
-                title: 'Codex article',
-                type: 'article',
-                author: 'bob',
-                votes: 7,
-                url: 'https://zhuanlan.zhihu.com/p/p1',
-            },
-        ]);
-        expect(goto).toHaveBeenCalledWith('https://www.zhihu.com');
-        expect(evaluate).toHaveBeenCalledTimes(1);
-    });
-
-    it('follows paging.next until the requested limit is reached', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({
-                    data: [
-                        { type: 'search_result', object: { id: 'a1', type: 'answer', question: { id: 'q1', name: 'first' } } },
-                        { type: 'search_result', object: { id: 'a2', type: 'answer', question: { id: 'q2', name: 'second' } } },
-                    ],
-                    paging: {
-                        is_end: false,
-                        next: 'https://api.zhihu.com/search_v3?offset=20&q=codex',
-                    },
-                })
-                .mockResolvedValueOnce({
-                    data: [
-                        { type: 'search_result', object: { id: 'a2', type: 'answer', question: { id: 'q2', name: 'duplicate' } } },
-                        { type: 'search_result', object: { id: 'q3', type: 'question', title: 'third' } },
-                    ],
-                    paging: { is_end: true },
-                }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 })).resolves.toEqual([
-            { rank: 1, title: 'first', type: 'answer', author: '', votes: 0, url: 'https://www.zhihu.com/question/q1/answer/a1' },
-            { rank: 2, title: 'second', type: 'answer', author: '', votes: 0, url: 'https://www.zhihu.com/question/q2/answer/a2' },
-            { rank: 3, title: 'third', type: 'question', author: '', votes: 0, url: 'https://www.zhihu.com/question/q3' },
-        ]);
-        expect(page.evaluate).toHaveBeenCalledTimes(2);
-        expect(page.evaluate.mock.calls[1][0]).toContain('https://www.zhihu.com/api/v4/search_v3?offset=20&q=codex');
-    });
-
-    it('filters by result type', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({
-                data: [
-                    { type: 'search_result', object: { id: 'a1', type: 'answer' } },
-                    { type: 'search_result', object: { id: 'p1', type: 'article', title: 'article' } },
-                ],
-                paging: { is_end: true },
-            }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 2, type: 'article' })).resolves.toEqual([
-            { rank: 1, title: 'article', type: 'article', author: '', votes: 0, url: 'https://zhuanlan.zhihu.com/p/p1' },
-        ]);
-    });
-
-    it('maps auth-like failures to AuthRequiredError', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ __httpError: 403 }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('preserves non-auth fetch failures as typed execution errors', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ __httpError: 500 }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('rejects invalid input before navigation', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = { goto: vi.fn(), evaluate: vi.fn() };
-        await expect(cmd.func(page, { query: '', limit: 1 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 1001 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 1, type: 'video' })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-
-    it('unwraps Browser Bridge envelopes and fails typed on malformed payloads', () => {
-        const payload = { data: [], paging: { is_end: true } };
-        expect(requireSearchPayload({ session: {}, data: payload }, 'https://www.zhihu.com/api/v4/search_v3')).toBe(payload);
-        expect(() => requireSearchPayload(null, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ data: null, paging: { is_end: true } }, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ data: [], paging: null }, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ __fetchError: 'network down' }, 'url')).toThrow(CommandExecutionError);
-    });
-
-    it('fails typed on malformed supported result rows instead of emitting blank identity rows', () => {
-        expect(() => normalizeResultItem({ type: 'search_result', object: { type: 'answer', id: 'a1', question: { name: 'missing question id' } } }))
-            .toThrow(CommandExecutionError);
-        expect(() => normalizeResultItem({ type: 'search_result', object: { type: 'article', id: 'p1' } }))
-            .toThrow(CommandExecutionError);
-        expect(normalizeResultItem({ type: 'hot_timing', object: { type: 'article', id: 'p1' } })).toBe(null);
-    });
-
-    it('rejects malformed pagination next URLs and reports valid empty result separately', async () => {
-        expect(normalizeSearchUrl('https://api.zhihu.com/search_v3?offset=20&q=codex'))
-            .toBe('https://www.zhihu.com/api/v4/search_v3?offset=20&q=codex');
-        expect(normalizeSearchUrl('https://evil.example/search_v3?offset=20')).toBe('');
-
-        const cmd = getRegistry().get('zhihu/search');
-        const malformedNextPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({
-                data: [],
-                paging: { is_end: false, next: 'https://evil.example/search_v3?offset=20' },
-            }),
-        };
-        await expect(cmd.func(malformedNextPage, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-
-        const emptyPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ data: [], paging: { is_end: true } }),
-        };
-        await expect(cmd.func(emptyPage, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(EmptyResultError);
-    });
-});

package/clis/zhihu/target.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CliError } from '@sovovs/bycli/errors';
-import { __test__ } from './target.js';
-describe('zhihu target parser', () => {
-    it('parses typed answer IDs into canonical targets', () => {
-        expect(__test__.parseTarget('answer:123:456')).toEqual({
-            kind: 'answer',
-            questionId: '123',
-            id: '456',
-            url: 'https://www.zhihu.com/question/123/answer/456',
-        });
-    });
-    it('parses question URLs into canonical targets', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456')).toEqual({
-            kind: 'question',
-            id: '123456',
-            url: 'https://www.zhihu.com/question/123456',
-        });
-    });
-    it('canonicalizes question URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/?utm_source=share#answer-1')).toEqual({
-            kind: 'question',
-            id: '123456',
-            url: 'https://www.zhihu.com/question/123456',
-        });
-    });
-    it('canonicalizes answer URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/answer/7890/?utm_psn=1#comment')).toEqual({
-            kind: 'answer',
-            questionId: '123456',
-            id: '7890',
-            url: 'https://www.zhihu.com/question/123456/answer/7890',
-        });
-    });
-    it('canonicalizes article URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://zhuanlan.zhihu.com/p/98765/?utm_id=1#heading')).toEqual({
-            kind: 'article',
-            id: '98765',
-            url: 'https://zhuanlan.zhihu.com/p/98765',
-        });
-    });
-    it('canonicalizes user URLs with trailing slash, query strings, and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/people/example-user/?utm_term=share#about')).toEqual({
-            kind: 'user',
-            slug: 'example-user',
-            url: 'https://www.zhihu.com/people/example-user',
-        });
-    });
-    it('rejects non-https Zhihu URLs', () => {
-        expect(() => __test__.parseTarget('http://www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with embedded credentials', () => {
-        expect(() => __test__.parseTarget('https://user@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with explicit ports', () => {
-        expect(() => __test__.parseTarget('https://www.zhihu.com:8443/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with empty authority usernames', () => {
-        expect(() => __test__.parseTarget('https://@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with empty authority username and password markers', () => {
-        expect(() => __test__.parseTarget('https://:@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects ambiguous bare numeric IDs', () => {
-        expect(() => __test__.parseTarget('123456')).toThrowError(CliError);
-    });
-    it('rejects malformed typed IDs', () => {
-        expect(() => __test__.parseTarget('answer:123')).toThrowError(/answer:<questionId>:<answerId>/);
-    });
-    it('rejects unsupported target kinds per command', () => {
-        expect(() => __test__.assertAllowedKinds('follow', {
-            kind: 'article',
-            id: '1',
-            url: 'https://zhuanlan.zhihu.com/p/1',
-        })).toThrowError(/follow/);
-    });
-});

package/clis/zhihu/text.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { stripHtml } from './text.js';
-
-describe('zhihu text helpers', () => {
-    it('strips tags and decodes named entities in flat mode', () => {
-        expect(stripHtml('<em>Codex</em>&nbsp;&amp;&nbsp;&lt;CLI&gt;')).toBe('Codex & <CLI>');
-    });
-
-    it('decodes decimal and hexadecimal numeric entities', () => {
-        expect(stripHtml('&#34;中文&#34; &#x26; &#39;test&#39;')).toBe('"中文" & \'test\'');
-    });
-
-    it('keeps invalid numeric entities unchanged', () => {
-        expect(stripHtml('bad &#9999999999; entity')).toBe('bad &#9999999999; entity');
-    });
-
-    it('keeps list excerpts flat by default', () => {
-        expect(stripHtml('<p>first</p><br><p>second</p>')).toBe('firstsecond');
-    });
-
-    it('preserves block breaks when requested', () => {
-        expect(stripHtml('<p>first</p><br><p>second</p>', { preserveBlocks: true })).toBe('first\n\nsecond');
-    });
-});

package/clis/zhihu/write-shared.test.js

@@ -1,176 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { describe, expect, it, vi } from 'vitest';
-import { CliError } from '@sovovs/bycli/errors';
-import { __test__ } from './write-shared.js';
-class FakeNode {
-    attrs;
-    textContent;
-    hasAvatar;
-    constructor(attrs, textContent = null, hasAvatar = false) {
-        this.attrs = attrs;
-        this.textContent = textContent;
-        this.hasAvatar = hasAvatar;
-    }
-    getAttribute(name) {
-        return this.attrs[name] ?? null;
-    }
-    querySelector(selector) {
-        if (this.hasAvatar && selector.includes('img'))
-            return {};
-        return null;
-    }
-}
-class FakeRoot {
-    selectors;
-    constructor(selectors) {
-        this.selectors = selectors;
-    }
-    querySelectorAll(selector) {
-        return this.selectors[selector] ?? [];
-    }
-}
-function createPageForDom(documentRoot, state = undefined) {
-    return {
-        evaluate: vi.fn().mockImplementation(async (js) => {
-            const previousDocument = globalThis.document;
-            const previousWindow = globalThis.window;
-            const previousState = globalThis.__INITIAL_STATE__;
-            const windowObject = { __INITIAL_STATE__: state };
-            try {
-                Object.assign(globalThis, {
-                    document: documentRoot,
-                    window: windowObject,
-                    __INITIAL_STATE__: state,
-                });
-                return globalThis.eval(js);
-            }
-            finally {
-                Object.assign(globalThis, {
-                    document: previousDocument,
-                    window: previousWindow,
-                    __INITIAL_STATE__: previousState,
-                });
-            }
-        }),
-    };
-}
-describe('zhihu write shared helpers', () => {
-    it('rejects missing --execute', () => {
-        expect(() => __test__.requireExecute({})).toThrowError(CliError);
-    });
-    it('accepts a non-empty text payload', async () => {
-        await expect(__test__.resolvePayload({ text: 'hello' })).resolves.toBe('hello');
-    });
-    it('rejects whitespace-only payloads', async () => {
-        await expect(__test__.resolvePayload({ text: '   ' })).rejects.toMatchObject({ code: 'INVALID_INPUT' });
-    });
-    it('rejects missing file payloads as INVALID_INPUT', async () => {
-        await expect(__test__.resolvePayload({ file: join(tmpdir(), 'zhihu-write-shared-missing.txt') })).rejects.toMatchObject({
-            code: 'INVALID_INPUT',
-            message: expect.stringContaining('File not found'),
-        });
-    });
-    it('rejects invalid UTF-8 file payloads as INVALID_INPUT', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'zhihu-write-shared-'));
-        const file = join(dir, 'payload.txt');
-        await writeFile(file, Buffer.from([0xc3, 0x28]));
-        try {
-            await expect(__test__.resolvePayload({ file })).rejects.toMatchObject({
-                code: 'INVALID_INPUT',
-                message: expect.stringContaining('decoded as UTF-8'),
-            });
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('rejects generic file read failures as INVALID_INPUT', async () => {
-        const dir = await mkdtemp(join(tmpdir(), 'zhihu-write-shared-'));
-        const file = join(dir, 'payload.txt');
-        await writeFile(file, 'hello');
-        try {
-            await expect(__test__.resolvePayload({ file }, {
-                stat: async () => ({ isFile: () => true }),
-                readFile: async () => {
-                    throw new Error('boom');
-                },
-                decodeUtf8: (raw) => new TextDecoder('utf-8', { fatal: true }).decode(raw),
-            })).rejects.toMatchObject({
-                code: 'INVALID_INPUT',
-                message: expect.stringContaining('could not be read'),
-            });
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('prefers the state slug before DOM fallback', async () => {
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [],
-            'a[href^="/people/"]': [new FakeNode({ href: '/people/not-used', 'data-testid': 'profile-link' }, null, true)],
-        });
-        expect(__test__.resolveCurrentUserSlugFromDom({ me: { slug: 'alice' } }, documentRoot)).toBe('alice');
-    });
-    it('accepts nav avatar links as a conservative fallback', async () => {
-        const navRoot = new FakeRoot({
-            'a[href^="/people/"]': [new FakeNode({ href: '/people/alice' }, null, true)],
-        });
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [navRoot],
-            'a[href^="/people/"]': [],
-        });
-        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBe('alice');
-    });
-    it('accepts document-wide fallback only for explicit account/profile signals', async () => {
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [],
-            'a[href^="/people/"]': [
-                new FakeNode({ href: '/people/alice', 'data-testid': 'account-profile-link' }),
-            ],
-        });
-        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBe('alice');
-    });
-    it('does not accept a document-wide author avatar link as current-user fallback', async () => {
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [],
-            'a[href^="/people/"]': [new FakeNode({ href: '/people/author-1' }, 'Author', true)],
-        });
-        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBeNull();
-    });
-    it('does not accept generic document metadata like user or dropdown alone', async () => {
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [],
-            'a[href^="/people/"]': [
-                new FakeNode({ href: '/people/author-1', 'data-testid': 'user-menu-dropdown' }, 'Author'),
-            ],
-        });
-        expect(__test__.resolveCurrentUserSlugFromDom(undefined, documentRoot)).toBeNull();
-    });
-    it('freezes a stable current-user identity before write', async () => {
-        const navRoot = new FakeRoot({
-            'a[href^="/people/"]': [new FakeNode({ href: '/people/alice' }, null, true)],
-        });
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [navRoot],
-            'a[href^="/people/"]': [],
-        });
-        const page = createPageForDom(documentRoot);
-        await expect(__test__.resolveCurrentUserIdentity(page)).resolves.toBe('alice');
-    });
-    it('rejects when current-user identity cannot be resolved', async () => {
-        const documentRoot = new FakeRoot({
-            'header, nav, [role="banner"], [role="navigation"]': [],
-            'a[href^="/people/"]': [],
-            'header img[alt*="\u4e3b\u9875"]': [],
-        });
-        const page = createPageForDom(documentRoot);
-        await expect(__test__.resolveCurrentUserIdentity(page)).rejects.toMatchObject({
-            code: 'ACTION_NOT_AVAILABLE',
-        });
-    });
-    it('rejects reserved buildResultRow extra keys', () => {
-        expect(() => __test__.buildResultRow('done', 'question', '123', 'applied', { status: 'oops' })).toThrowError(CliError);
-    });
-});

package/clis/zlibrary/commands.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import {
-  buildSearchUrl,
-  normalizeZlibraryBookUrl,
-} from './utils.js';
-import './search.js';
-import './info.js';
-import { createPageMock } from '../test-utils.js';
-
-
-describe('zlibrary commands', () => {
-  it('registers search and info commands', () => {
-    expect(getRegistry().get('zlibrary/search')).toBeDefined();
-    expect(getRegistry().get('zlibrary/info')).toBeDefined();
-  });
-
-  it('normalizes search query and rejects empty searches', () => {
-    expect(buildSearchUrl('  test book  ')).toBe('https://z-library.im/s/test%20book');
-    expect(() => buildSearchUrl('   ')).toThrow(ArgumentError);
-  });
-
-  it('restricts info URLs to the configured zlibrary host', () => {
-    expect(normalizeZlibraryBookUrl('https://z-library.im/book/demo')).toBe('https://z-library.im/book/demo');
-    expect(normalizeZlibraryBookUrl('https://www.z-library.im/book/demo')).toBe('https://www.z-library.im/book/demo');
-    expect(() => normalizeZlibraryBookUrl('https://example.com/book/demo')).toThrow(ArgumentError);
-  });
-
-  it('search fails fast on empty extraction results', async () => {
-    const command = getRegistry().get('zlibrary/search');
-    const page = createPageMock(['[]']);
-
-    await expect(command.func(page, { query: 'missing', limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
-  });
-
-  it('info waits seconds, not milliseconds-as-seconds, before extracting formats', async () => {
-    const command = getRegistry().get('zlibrary/info');
-    const page = createPageMock([
-      'Demo Book',
-      undefined,
-      JSON.stringify({ pdf: 'https://z-library.im/dl/pdf', epub: '' }),
-    ]);
-
-    await expect(command.func(page, { url: 'https://z-library.im/book/demo' })).resolves.toEqual([{
-      title: 'Demo Book',
-      pdf: 'https://z-library.im/dl/pdf',
-      epub: '',
-      url: 'https://z-library.im/book/demo',
-    }]);
-    expect(page.wait).toHaveBeenCalledWith({ time: 5 });
-    expect(page.wait).toHaveBeenCalledWith({ time: 3 });
-  });
-
-  it('info fails fast when formats are missing', async () => {
-    const command = getRegistry().get('zlibrary/info');
-    const page = createPageMock([
-      'Login Required',
-      undefined,
-      JSON.stringify({ pdf: '', epub: '' }),
-    ]);
-
-    await expect(command.func(page, { url: 'https://z-library.im/book/demo' })).rejects.toBeInstanceOf(EmptyResultError);
-  });
-});

package/clis/zsxq/search.test.js

@@ -1,24 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './search.js';
-describe('zsxq search command', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('requires an explicit group_id when there is no active group context', async () => {
-        const command = getRegistry().get('zsxq/search');
-        expect(command?.func).toBeTypeOf('function');
-        const mockPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce(true)
-                .mockResolvedValueOnce(null),
-        };
-        await expect(command.func(mockPage, { keyword: 'bycli', limit: 20 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: 'Cannot determine active group_id',
-        });
-        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
-        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
-    });
-});

package/clis/zsxq/topic.test.js

@@ -1,30 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './topic.js';
-describe('zsxq topic command', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('maps topic detail 404 responses to NOT_FOUND before fetching comments', async () => {
-        const command = getRegistry().get('zsxq/topic');
-        expect(command?.func).toBeTypeOf('function');
-        const mockPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce(true) // ensureZsxqAuth
-                .mockResolvedValueOnce('12345') // getActiveGroupId
-                .mockResolvedValueOnce({
-                ok: true,
-                status: 404,
-                url: 'https://api.zsxq.com/v2/groups/12345/topics/404',
-                data: null,
-            }),
-        };
-        await expect(command.func(mockPage, { id: '404', comment_limit: 20 })).rejects.toMatchObject({
-            code: 'NOT_FOUND',
-            message: 'Topic 404 not found',
-        });
-        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
-        expect(mockPage.evaluate).toHaveBeenCalledTimes(3);
-    });
-});

package/clis/zsxq/topics.test.js

@@ -1,24 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './topics.js';
-describe('zsxq topics command', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('requires an explicit group_id when there is no active group context', async () => {
-        const command = getRegistry().get('zsxq/topics');
-        expect(command?.func).toBeTypeOf('function');
-        const mockPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce(true)
-                .mockResolvedValueOnce(null),
-        };
-        await expect(command.func(mockPage, { limit: 20 })).rejects.toMatchObject({
-            code: 'ARGUMENT',
-            message: 'Cannot determine active group_id',
-        });
-        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
-        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
-    });
-});

package/clis/zsxq/utils.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getTopicText, toTopicRow } from './utils.js';
-
-describe('zsxq utils', () => {
-    it('keeps title and content separate when both fields exist', () => {
-        const topic = {
-            topic_id: '123',
-            title: 'A full title that should not be truncated',
-            talk: { text: 'This is the full body text.' },
-        };
-
-        expect(getTopicText(topic)).toBe('A full title that should not be truncated');
-        expect(toTopicRow(topic)).toMatchObject({
-            title: 'A full title that should not be truncated',
-            content: 'This is the full body text.',
-        });
-    });
-
-    it('falls back to body text for title when explicit title is absent', () => {
-        const topic = {
-            topic_id: '456',
-            talk: { text: 'Body-only topic text should still appear as the title preview.' },
-        };
-
-        expect(getTopicText(topic)).toBe('Body-only topic text should still appear as the title preview.');
-        expect(toTopicRow(topic)).toMatchObject({
-            title: 'Body-only topic text should still appear as the title preview.',
-            content: 'Body-only topic text should still appear as the title preview.',
-        });
-    });
-});