@sovovs/bycli 1.8.0 → 2.1.0

package/clis/linkedin-learning/course.test.js

@@ -1,114 +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 './course.js';
-
-const { parseSlug, parseCourse } = await import('./course.js').then((m) => m.__test__);
-
-function makePage({ evaluateResult, cookies = [{ name: 'JSESSIONID', value: '"ajax:abc"' }] } = {}) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        getCookies: vi.fn().mockResolvedValue(cookies),
-        evaluate: vi.fn().mockResolvedValue(evaluateResult),
-    };
-}
-
-describe('linkedin-learning course', () => {
-    it('accepts a bare slug', () => {
-        expect(parseSlug('agentic-ai-build')).toBe('agentic-ai-build');
-    });
-
-    it('extracts a slug from a full /learning/<slug> URL', () => {
-        expect(parseSlug('https://www.linkedin.com/learning/agentic-ai-build/?foo=1'))
-            .toBe('agentic-ai-build');
-    });
-
-    it('rejects non-LinkedIn Learning URLs before navigation', () => {
-        expect(() => parseSlug('https://evil.example/learning/agentic-ai-build')).toThrow(ArgumentError);
-        expect(() => parseSlug('https://www.linkedin.com/feed/update/123')).toThrow(ArgumentError);
-    });
-
-    it('rejects empty or invalid slugs with ArgumentError', () => {
-        expect(() => parseSlug('')).toThrow(ArgumentError);
-        expect(() => parseSlug('   ')).toThrow(ArgumentError);
-        expect(() => parseSlug('not a slug!')).toThrow(ArgumentError);
-    });
-
-    it('maps a course detail element to the canonical row shape', () => {
-        const el = {
-            title: 'Agentic AI: Build Your First Agentic AI System',
-            description: { text: 'Dive into agentic AI...' },
-            duration: { duration: 3932, unit: 'SECOND' },
-            difficultyLevel: 'Intermediate',
-            videosCount: 18,
-            rating: { averageRating: 4.5, ratingCount: 259 },
-            activatedAt: 1774569600000,
-        };
-        const row = parseCourse(el, 'agentic-ai-build-your-first-agentic-ai-system');
-        expect(row.title).toBe('Agentic AI: Build Your First Agentic AI System');
-        expect(row.slug).toBe('agentic-ai-build-your-first-agentic-ai-system');
-        expect(row.description).toBe('Dive into agentic AI...');
-        expect(row.difficulty).toBe('Intermediate');
-        expect(row.duration_sec).toBe('3932');
-        expect(row.videos_count).toBe(18);
-        expect(row.rating).toBe('4.50');
-        expect(row.rating_count).toBe(259);
-        expect(row.released).toBe('2026-03-27');
-        expect(row.url).toBe('https://www.linkedin.com/learning/agentic-ai-build-your-first-agentic-ai-system');
-    });
-
-    it('handles description as a bare string', () => {
-        const row = parseCourse({ title: 't', description: 'plain string' }, 'x');
-        expect(row.description).toBe('plain string');
-    });
-
-    it('preserves the full course description', () => {
-        const text = 'x'.repeat(350);
-        const row = parseCourse({ title: 't', description: { text } }, 'x');
-        expect(row.description).toBe(text);
-    });
-
-    it('returns empty fields when upstream omits them', () => {
-        const row = parseCourse({ title: 't' }, 'x');
-        expect(row.title).toBe('t');
-        expect(row.duration_sec).toBe('');
-        expect(row.rating).toBe('');
-        expect(row.released).toBe('');
-    });
-
-    it('returns null when upstream omits the core title evidence', () => {
-        expect(parseCourse({}, 'x')).toBeNull();
-        expect(parseCourse({ title: '   ' }, 'x')).toBeNull();
-    });
-
-    it('throws AuthRequiredError when JSESSIONID is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/course');
-        const page = makePage({ cookies: [], evaluateResult: { json: { elements: [{}] } } });
-        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws EmptyResultError when no element matches the slug', async () => {
-        const cmd = getRegistry().get('linkedin-learning/course');
-        const page = makePage({ evaluateResult: { json: { elements: [] } } });
-        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when the elements array is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/course');
-        const page = makePage({ evaluateResult: { json: { data: {} } } });
-        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when the first detail element is malformed', async () => {
-        const cmd = getRegistry().get('linkedin-learning/course');
-        const page = makePage({ evaluateResult: { json: { elements: [{}] } } });
-        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError on fetch errors', async () => {
-        const cmd = getRegistry().get('linkedin-learning/course');
-        const page = makePage({ evaluateResult: { error: 'HTTP 500' } });
-        await expect(cmd.func(page, { slug: 'agentic-ai-build' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});

package/clis/linkedin-learning/search.test.js

@@ -1,144 +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 { parseLimit, parseAuthors, durationSeconds, averageRating, parseRow, buildFetchScript } = await import('./search.js').then((m) => m.__test__);
-
-function makePage({ evaluateResult, cookies = [{ name: 'JSESSIONID', value: '"ajax:abc"' }] } = {}) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        getCookies: vi.fn().mockResolvedValue(cookies),
-        evaluate: vi.fn().mockResolvedValue(evaluateResult),
-    };
-}
-
-describe('linkedin-learning search', () => {
-    it('validates --limit without silent clamping', () => {
-        expect(parseLimit(undefined)).toBe(10);
-        expect(parseLimit(1)).toBe(1);
-        expect(parseLimit(50)).toBe(50);
-        expect(() => parseLimit(0)).toThrow(ArgumentError);
-        expect(() => parseLimit(51)).toThrow(ArgumentError);
-        expect(() => parseLimit('abc')).toThrow(ArgumentError);
-        expect(() => parseLimit(1.5)).toThrow(ArgumentError);
-    });
-
-    it('joins author first/last names', () => {
-        expect(parseAuthors([{ firstName: 'Jane', lastName: 'Doe' }])).toBe('Jane Doe');
-        expect(parseAuthors([{ firstName: 'A', lastName: 'B' }, { firstName: 'C', lastName: 'D' }])).toBe('A B, C D');
-        expect(parseAuthors([])).toBe('');
-        expect(parseAuthors(undefined)).toBe('');
-    });
-
-    it('extracts duration from TimeSpan only when unit is SECOND', () => {
-        expect(durationSeconds({ 'com.linkedin.common.TimeSpan': { duration: 600, unit: 'SECOND' } })).toBe('600');
-        expect(durationSeconds({ 'com.linkedin.common.TimeSpan': { duration: 10, unit: 'MINUTE' } })).toBe('');
-        expect(durationSeconds(undefined)).toBe('');
-    });
-
-    it('computes average rating from sum/count when averageRating is missing', () => {
-        expect(averageRating({ ratingSum: 1165, ratingCount: 259 })).toBe('4.50');
-        expect(averageRating({ averageRating: 4.32 })).toBe('4.32');
-        expect(averageRating({ ratingSum: 0, ratingCount: 0 })).toBe('');
-        expect(averageRating(undefined)).toBe('');
-    });
-
-    it('maps a search result element to the canonical row shape', () => {
-        const el = {
-            entityType: 'COURSE',
-            slug: 'agentic-ai-build-your-first-agentic-ai-system',
-            headline: { title: { text: 'Agentic AI: Build Your First Agentic AI System' } },
-            authors: [{ firstName: 'Aishwarya', lastName: 'Naresh Reganti' }],
-            difficultyLevel: 'INTERMEDIATE',
-            length: { 'com.linkedin.common.TimeSpan': { duration: 3932, unit: 'SECOND' } },
-            rating: { ratingSum: 1165, ratingCount: 259 },
-            viewerCount: 25323,
-        };
-        expect(parseRow(el, 1)).toEqual({
-            rank: 1,
-            type: 'COURSE',
-            title: 'Agentic AI: Build Your First Agentic AI System',
-            instructor: 'Aishwarya Naresh Reganti',
-            difficulty: 'INTERMEDIATE',
-            duration_sec: '3932',
-            rating: '4.50',
-            rating_count: 259,
-            viewers: 25323,
-            url: 'https://www.linkedin.com/learning/agentic-ai-build-your-first-agentic-ai-system',
-        });
-    });
-
-    it('drops rows without slug identity', () => {
-        const row = parseRow({ entityType: 'COURSE', headline: { title: { text: 't' } } }, 2);
-        expect(row).toBeNull();
-    });
-
-    it('escapes the URL and csrf into the fetch script as literal strings', () => {
-        const s = buildFetchScript('https://www.linkedin.com/learning-api/searchV2?keywords=AI', 'csrf-token-value');
-        expect(s).toContain('"https://www.linkedin.com/learning-api/searchV2?keywords=AI"');
-        expect(s).toContain('"csrf-token-value"');
-        expect(s).toContain("'x-restli-protocol-version': '2.0.0'");
-        expect(s).toContain('authRequired: true');
-    });
-
-    it('throws AuthRequiredError when JSESSIONID cookie is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ cookies: [], evaluateResult: { json: { elements: [] } } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws AuthRequiredError when the fetch returns 403', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { authRequired: true, status: 403 } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws CommandExecutionError when the upstream payload is empty', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { error: 'fetch failed: socket' } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws EmptyResultError when zero elements come back', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { json: { elements: [] } } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when the elements array is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { json: { data: {} } } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when elements lack slug identity', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { json: { elements: [{ headline: { title: { text: 'No slug' } } }] } } });
-        await expect(cmd.func(page, { keywords: 'x', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('rejects empty keywords with ArgumentError before navigation', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const page = makePage({ evaluateResult: { json: { elements: [] } } });
-        await expect(cmd.func(page, { keywords: '   ', limit: 5 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('returns ranked rows when the API responds normally', async () => {
-        const cmd = getRegistry().get('linkedin-learning/search');
-        const elements = [
-            { entityType: 'COURSE', slug: 'a', headline: { title: { text: 'Course A' } }, authors: [{ firstName: 'Inst', lastName: 'A' }], difficultyLevel: 'BEGINNER', length: { 'com.linkedin.common.TimeSpan': { duration: 100, unit: 'SECOND' } } },
-            { entityType: 'COURSE', headline: { title: { text: 'No slug' } } },
-            { entityType: 'VIDEO', slug: 'b', headline: { title: { text: 'Video B' } } },
-        ];
-        const page = makePage({ evaluateResult: { json: { elements } } });
-        const rows = await cmd.func(page, { keywords: 'test', limit: 5 });
-        expect(rows).toHaveLength(2);
-        expect(rows[0].rank).toBe(1);
-        expect(rows[0].title).toBe('Course A');
-        expect(rows[1].title).toBe('Video B');
-        expect(rows[1].url).toBe('https://www.linkedin.com/learning/b');
-    });
-});

package/clis/linkedin-learning/trending.test.js

@@ -1,123 +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 './trending.js';
-
-const { parseLimit, parseCard } = await import('./trending.js').then((m) => m.__test__);
-
-function makePage({ evaluateResult, cookies = [{ name: 'JSESSIONID', value: '"ajax:abc"' }] } = {}) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        getCookies: vi.fn().mockResolvedValue(cookies),
-        evaluate: vi.fn().mockResolvedValue(evaluateResult),
-    };
-}
-
-describe('linkedin-learning trending', () => {
-    it('validates --limit without silent clamping', () => {
-        expect(parseLimit(undefined)).toBe(10);
-        expect(parseLimit(50)).toBe(50);
-        expect(() => parseLimit(0)).toThrow(ArgumentError);
-        expect(() => parseLimit(51)).toThrow(ArgumentError);
-    });
-
-    it('maps a carousel card to the canonical row shape', () => {
-        const card = {
-            entityType: 'COURSE',
-            slug: 'storytelling-editing',
-            difficultyLevel: 'BEGINNER_INTERMEDIATE',
-            description: { text: 'Go beyond basic video editing.' },
-            viewerCount: 12345,
-            headline: { title: { text: 'The Art of Storytelling through Editing' } },
-        };
-        const group = { annotation: 'TOP_PICKS', title: { text: 'Top picks for you' } };
-        expect(parseCard(card, group, 1)).toEqual({
-            rank: 1,
-            group: 'Top picks for you',
-            type: 'COURSE',
-            title: 'The Art of Storytelling through Editing',
-            difficulty: 'BEGINNER_INTERMEDIATE',
-            viewers: 12345,
-            url: 'https://www.linkedin.com/learning/storytelling-editing',
-        });
-    });
-
-    it('drops cards without slug identity', () => {
-        expect(parseCard({ title: { text: 'No slug' } }, { title: { text: 'G' } }, 1)).toBeNull();
-    });
-
-    it('flattens carousels and dedups cards across them', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const page = makePage({
-            evaluateResult: {
-                json: {
-                    elements: [{
-                        carousels: [
-                            {
-                                title: { text: 'Top picks' },
-                                cards: [
-                                    { slug: 'a', headline: { title: { text: 'Course A' } } },
-                                    { headline: { title: { text: 'No slug' } } },
-                                    { slug: 'b', headline: { title: { text: 'Course B' } } },
-                                ],
-                            },
-                            {
-                                title: { text: 'Trending in your network' },
-                                cards: [
-                                    { slug: 'a', headline: { title: { text: 'Dup of A' } } },
-                                    { slug: 'c', headline: { title: { text: 'Course C' } } },
-                                ],
-                            },
-                        ],
-                    }],
-                },
-            },
-        });
-        const rows = await cmd.func(page, { limit: 5 });
-        expect(rows.map((r) => r.title)).toEqual(['Course A', 'Course B', 'Course C']);
-        expect(rows.map((r) => r.rank)).toEqual([1, 2, 3]);
-        expect(rows[0].group).toBe('Top picks');
-        expect(rows[2].group).toBe('Trending in your network');
-    });
-
-    it('respects --limit', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const cards = Array.from({ length: 6 }, (_, i) => ({ slug: `s${i}`, headline: { title: { text: `T${i}` } } }));
-        const page = makePage({
-            evaluateResult: {
-                json: { elements: [{ carousels: [{ title: { text: 'G' }, cards }] }] },
-            },
-        });
-        const rows = await cmd.func(page, { limit: 3 });
-        expect(rows).toHaveLength(3);
-    });
-
-    it('throws AuthRequiredError when JSESSIONID is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const page = makePage({ cookies: [], evaluateResult: { json: { elements: [] } } });
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws EmptyResultError when no carousels yield cards', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const page = makePage({ evaluateResult: { json: { elements: [{ carousels: [] }] } } });
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError when the elements array is missing', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const page = makePage({ evaluateResult: { json: { data: {} } } });
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError when cards lack slug identity', async () => {
-        const cmd = getRegistry().get('linkedin-learning/trending');
-        const page = makePage({
-            evaluateResult: {
-                json: { elements: [{ carousels: [{ title: { text: 'G' }, cards: [{ headline: { title: { text: 'No slug' } } }] }] }] },
-            },
-        });
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});

package/clis/linux-do/feed.test.js

@@ -1,153 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { __test__ } from './feed.js';
-describe('linux-do feed metadata resolution', () => {
-    afterEach(() => {
-        __test__.resetMetadataCaches();
-    });
-    it('builds the replacement URL for legacy latest', async () => {
-        const request = await __test__.resolveFeedRequest(null, {
-            view: 'latest',
-            limit: 20,
-        });
-        expect(request.url).toBe('/latest.json?per_page=20');
-    });
-    it('builds the replacement URL for legacy hot weekly', async () => {
-        const request = await __test__.resolveFeedRequest(null, {
-            view: 'top',
-            period: 'weekly',
-            limit: 20,
-        });
-        expect(request.url).toBe('/top.json?per_page=20&period=weekly');
-    });
-    it('prefers live tag metadata over the bundled snapshot', async () => {
-        __test__.setLiveMetadataForTests({
-            tags: [{ id: 9999, slug: 'fresh-tag', name: 'Fresh Tag' }],
-        });
-        const request = await __test__.resolveFeedRequest(null, {
-            tag: 'Fresh Tag',
-            view: 'latest',
-            limit: 20,
-        });
-        expect(request.url).toBe('/tag/fresh-tag/9999.json?per_page=20');
-    });
-    it('uses live category metadata with parent paths for subcategories', async () => {
-        __test__.setLiveMetadataForTests({
-            categories: [
-                {
-                    id: 10,
-                    name: 'Parent',
-                    description: '',
-                    slug: 'parent',
-                    parentCategoryId: null,
-                    parent: null,
-                },
-                {
-                    id: 11,
-                    name: 'Fresh Child',
-                    description: '',
-                    slug: 'fresh-child',
-                    parentCategoryId: 10,
-                    parent: {
-                        id: 10,
-                        name: 'Parent',
-                        description: '',
-                        slug: 'parent',
-                        parentCategoryId: null,
-                    },
-                },
-            ],
-        });
-        const request = await __test__.resolveFeedRequest(null, {
-            category: 'Fresh Child',
-            view: 'hot',
-            limit: 20,
-        });
-        expect(request.url).toBe('/c/parent/fresh-child/11/l/hot.json?per_page=20');
-    });
-    it('accepts parent/name category paths for subcategories', async () => {
-        __test__.setLiveMetadataForTests({
-            categories: [
-                {
-                    id: 10,
-                    name: 'Parent',
-                    description: '',
-                    slug: 'parent',
-                    parentCategoryId: null,
-                    parent: null,
-                },
-                {
-                    id: 11,
-                    name: 'Fresh Child',
-                    description: '',
-                    slug: 'fresh-child',
-                    parentCategoryId: 10,
-                    parent: {
-                        id: 10,
-                        name: 'Parent',
-                        description: '',
-                        slug: 'parent',
-                        parentCategoryId: null,
-                    },
-                },
-            ],
-        });
-        const request = await __test__.resolveFeedRequest(null, {
-            category: 'Parent / Fresh Child',
-            view: 'latest',
-            limit: 20,
-        });
-        expect(request.url).toBe('/c/parent/fresh-child/11.json?per_page=20');
-    });
-    it('builds the replacement URL for legacy category id', async () => {
-        __test__.setLiveMetadataForTests({
-            categories: [
-                {
-                    id: 4,
-                    name: '开发调优',
-                    description: '',
-                    slug: 'develop',
-                    parentCategoryId: null,
-                    parent: null,
-                },
-            ],
-        });
-        const request = await __test__.resolveFeedRequest(null, {
-            category: '4',
-            view: 'latest',
-            limit: 20,
-        });
-        expect(request.url).toBe('/c/develop/4.json?per_page=20');
-    });
-    it('falls back to cached metadata when live metadata is unavailable', async () => {
-        const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-linux-do-cache-'));
-        __test__.setCacheDirForTests(cacheDir);
-        fs.writeFileSync(path.join(cacheDir, 'tags.json'), JSON.stringify({
-            fetchedAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
-            data: [{ id: 3, slug: 'chatgpt', name: 'ChatGPT' }],
-        }));
-        fs.writeFileSync(path.join(cacheDir, 'categories.json'), JSON.stringify({
-            fetchedAt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
-            data: [{
-                    id: 4,
-                    name: '开发调优',
-                    description: '',
-                    slug: 'develop',
-                    parentCategoryId: null,
-                    parent: null,
-                }],
-        }));
-        const request = await __test__.resolveFeedRequest(null, {
-            tag: 'ChatGPT',
-            category: '开发调优',
-            view: 'top',
-            period: 'monthly',
-            limit: 20,
-        });
-        expect(request.url).toContain('/tags/c/develop/4/chatgpt/3/l/top.json');
-        expect(request.url).toContain('per_page=20');
-        expect(request.url).toContain('period=monthly');
-    });
-});

package/clis/linux-do/topic-content.test.js

@@ -1,59 +0,0 @@
-import { getRegistry } from '@sovovs/bycli/registry';
-import fs from 'node:fs';
-import { describe, expect, it } from 'vitest';
-import { __test__ } from './topic-content.js';
-describe('linux-do topic-content', () => {
-    it('prefers raw markdown when the topic payload includes it', () => {
-        const result = __test__.extractTopicContent({
-            title: 'Hello Linux.do',
-            post_stream: {
-                posts: [
-                    {
-                        post_number: 1,
-                        username: 'neo',
-                        raw: '## Heading\n\n- one\n- two',
-                        cooked: '<h2>Heading</h2><ul><li>one</li><li>two</li></ul>',
-                        like_count: 7,
-                        created_at: '2025-04-05T10:00:00.000Z',
-                    },
-                ],
-            },
-        }, 1234);
-        expect(result.content).toContain('---');
-        expect(result.content).toContain('title: Hello Linux.do');
-        expect(result.content).toContain('author: neo');
-        expect(result.content).toContain('likes: 7');
-        expect(result.content).toContain('url: https://linux.do/t/1234');
-        expect(result.content).toContain('## Heading');
-        expect(result.content).toContain('- one');
-    });
-    it('falls back to cooked html and converts it to markdown', () => {
-        const result = __test__.extractTopicContent({
-            title: 'Converted Topic',
-            post_stream: {
-                posts: [
-                    {
-                        post_number: 1,
-                        username: 'trinity',
-                        cooked: '<p>Hello <strong>world</strong></p><blockquote><p>quoted</p></blockquote>',
-                        like_count: 3,
-                        created_at: '2025-04-05T10:00:00.000Z',
-                    },
-                ],
-            },
-        }, 42);
-        expect(result.content).toContain('Hello **world**');
-        expect(result.content).toContain('> quoted');
-    });
-    it('registers topic-content with plain default output for markdown body rendering', () => {
-        const command = getRegistry().get('linux-do/topic-content');
-        expect(command?.defaultFormat).toBe('plain');
-        expect(command?.columns).toEqual(['content']);
-    });
-    it('keeps topic adapter as a summarized first-page reader after the split', () => {
-        const topicTs = fs.readFileSync(new URL('./topic.js', import.meta.url), 'utf8');
-        expect(topicTs).not.toContain('main_only');
-        expect(topicTs).toContain('slice(0, 200)');
-        expect(topicTs).toContain('帖子首页摘要和回复');
-    });
-});