@sovovs/bycli 1.8.0 → 2.0.0

package/clis/coingecko/coingecko.test.js

@@ -1,109 +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 './coin.js';
-import './trending.js';
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-});
-
-describe('coingecko coin adapter', () => {
-    const cmd = getRegistry().get('coingecko/coin');
-
-    it('rejects invalid id and currency before fetching', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-
-        await expect(cmd.func({ id: '../btc', currency: 'usd' }))
-            .rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ id: 'bitcoin', currency: '$$$' }))
-            .rejects.toThrow(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('fails fast when the requested currency has no market fields', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
-            new Response(JSON.stringify({
-                id: 'bitcoin',
-                symbol: 'btc',
-                name: 'Bitcoin',
-                market_data: {
-                    current_price: { usd: 1 },
-                    market_cap: { usd: 2 },
-                    total_volume: { usd: 3 },
-                },
-            }), { status: 200 }),
-        ));
-
-        await expect(cmd.func({ id: 'bitcoin', currency: 'zzz' }))
-            .rejects.toThrow(CommandExecutionError);
-    });
-
-    it('returns selected currency market data', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
-            new Response(JSON.stringify({
-                id: 'bitcoin',
-                symbol: 'btc',
-                name: 'Bitcoin',
-                market_cap_rank: 1,
-                genesis_date: '2009-01-03',
-                links: { homepage: ['https://bitcoin.org', ''] },
-                market_data: {
-                    current_price: { cny: 7 },
-                    market_cap: { cny: 8 },
-                    total_volume: { cny: 9 },
-                    price_change_percentage_24h: 1.23,
-                    ath: { cny: 10 },
-                    ath_date: { cny: '2024-01-02T00:00:00Z' },
-                    atl: { cny: 1 },
-                    atl_date: { cny: '2015-01-14T00:00:00Z' },
-                    circulating_supply: 19,
-                },
-            }), { status: 200 }),
-        ));
-
-        const rows = await cmd.func({ id: 'bitcoin', currency: 'cny' });
-
-        expect(rows).toEqual([expect.objectContaining({
-            id: 'bitcoin',
-            symbol: 'BTC',
-            rank: 1,
-            price: 7,
-            marketCap: 8,
-            volume24h: 9,
-            athDate: '2024-01-02',
-            homepage: 'https://bitcoin.org',
-        })]);
-    });
-
-    it('maps 404 to EmptyResultError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
-            new Response(JSON.stringify({ error: 'not found' }), { status: 404 }),
-        ));
-
-        await expect(cmd.func({ id: 'missing', currency: 'usd' }))
-            .rejects.toThrow(EmptyResultError);
-    });
-});
-
-describe('coingecko trending adapter', () => {
-    const cmd = getRegistry().get('coingecko/trending');
-
-    it('returns ids that round-trip into coingecko coin <id>', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
-            new Response(JSON.stringify({
-                coins: [{ item: { id: 'bitcoin', symbol: 'btc', name: 'Bitcoin', market_cap_rank: 1, price_btc: 1, thumb: 'thumb.png' } }],
-            }), { status: 200 }),
-        ));
-
-        const rows = await cmd.func({});
-
-        expect(rows).toEqual([expect.objectContaining({
-            id: 'bitcoin',
-            symbol: 'BTC',
-            marketCapRank: 1,
-        })]);
-    });
-});

package/clis/confluence/commands.test.js

@@ -1,195 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { describe, expect, it, afterEach, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './page.js';
-import './search.js';
-import './create.js';
-import './update.js';
-
-const ENV_KEYS = [
-    'ATLASSIAN_CONFLUENCE_BASE_URL',
-    'ATLASSIAN_DEPLOYMENT',
-    'ATLASSIAN_EMAIL',
-    'ATLASSIAN_API_TOKEN',
-    'ATLASSIAN_USERNAME',
-    'ATLASSIAN_PASSWORD',
-    'ATLASSIAN_PAT',
-];
-
-function clearEnv() {
-    for (const key of ENV_KEYS) delete process.env[key];
-}
-
-function setCloudEnv() {
-    clearEnv();
-    process.env.ATLASSIAN_CONFLUENCE_BASE_URL = 'https://team.atlassian.net/wiki';
-    process.env.ATLASSIAN_DEPLOYMENT = 'cloud';
-    process.env.ATLASSIAN_EMAIL = 'bot@example.com';
-    process.env.ATLASSIAN_API_TOKEN = 'secret';
-}
-
-function jsonResponse(body) {
-    return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
-}
-
-async function withTempMarkdown(markdown, fn) {
-    const dir = await mkdtemp(join(tmpdir(), 'bycli-confluence-'));
-    const file = join(dir, 'doc.md');
-    await writeFile(file, markdown);
-    try {
-        return await fn(file);
-    } finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}
-
-afterEach(() => {
-    clearEnv();
-    vi.unstubAllGlobals();
-});
-
-describe('confluence commands', () => {
-    it('registers expected REST commands', () => {
-        for (const name of ['page', 'search', 'create', 'update']) {
-            const cmd = getRegistry().get(`confluence/${name}`);
-            expect(cmd).toBeDefined();
-            expect(cmd.browser).toBe(false);
-            expect(cmd.strategy).toBe('public');
-        }
-    });
-
-    it('requires --execute before create performs remote writes', async () => {
-        const cmd = getRegistry().get('confluence/create');
-        await expect(cmd.func({ space: '123', title: 'Doc', file: 'doc.md' })).rejects.toThrow(/--execute/);
-    });
-
-    it('creates a Cloud page from Markdown storage', async () => {
-        setCloudEnv();
-        await withTempMarkdown('# RCA\n\n- Payment failed', async (file) => {
-            const fetchMock = vi.fn(async (url, init) => {
-                expect(String(url)).toBe('https://team.atlassian.net/wiki/api/v2/pages');
-                const payload = JSON.parse(init.body);
-                expect(payload).toMatchObject({ spaceId: '987', title: 'PROJ-1 RCA' });
-                expect(payload.body.value).toContain('<h1>RCA</h1>');
-                expect(payload.body.value.replace(/\s*\n\s*/g, '')).toContain('<li>Payment failed</li>');
-                return jsonResponse({
-                    id: '555',
-                    title: 'PROJ-1 RCA',
-                    status: 'current',
-                    spaceId: '987',
-                    version: { number: 1, createdAt: '2026-05-01T00:00:00Z' },
-                    body: { storage: { value: '<h1>RCA</h1>' } },
-                    _links: { webui: '/spaces/ENG/pages/555' },
-                });
-            });
-            vi.stubGlobal('fetch', fetchMock);
-            const cmd = getRegistry().get('confluence/create');
-            const rows = await cmd.func({ space: '987', title: 'PROJ-1 RCA', file, representation: 'markdown', execute: true });
-            expect(rows[0]).toMatchObject({ status: 'created', id: '555', title: 'PROJ-1 RCA', version: 1 });
-            expect(rows[0].url).toBe('https://team.atlassian.net/wiki/spaces/ENG/pages/555');
-        });
-    });
-
-    it('updates a page by incrementing the current version', async () => {
-        setCloudEnv();
-        await withTempMarkdown('Updated body', async (file) => {
-            const fetchMock = vi.fn(async (url, init) => {
-                if (init.method === 'GET') {
-                    expect(String(url)).toBe('https://team.atlassian.net/wiki/api/v2/pages/555?body-format=storage');
-                    return jsonResponse({
-                        id: '555',
-                        title: 'Existing',
-                        status: 'current',
-                        version: { number: 7 },
-                        body: { storage: { value: '<p>Old</p>' } },
-                    });
-                }
-                expect(init.method).toBe('PUT');
-                const payload = JSON.parse(init.body);
-                expect(payload.version).toMatchObject({ number: 8, message: 'Sync from Jira' });
-                expect(payload.title).toBe('Existing');
-                return jsonResponse({
-                    id: '555',
-                    title: 'Existing',
-                    status: 'current',
-                    version: { number: 8 },
-                    body: { storage: { value: '<p>Updated body</p>' } },
-                });
-            });
-            vi.stubGlobal('fetch', fetchMock);
-            const cmd = getRegistry().get('confluence/update');
-            const rows = await cmd.func({ id: '555', file, representation: 'markdown', 'version-message': 'Sync from Jira', execute: true });
-            expect(rows[0]).toMatchObject({ status: 'updated', id: '555', version: 8 });
-            expect(fetchMock).toHaveBeenCalledTimes(2);
-        });
-    });
-
-    it('does not update a Confluence page when the current version is malformed', async () => {
-        setCloudEnv();
-        await withTempMarkdown('Updated body', async (file) => {
-            const fetchMock = vi.fn(async (url, init) => {
-                expect(init.method).toBe('GET');
-                return jsonResponse({
-                    id: '555',
-                    title: 'Existing',
-                    status: 'current',
-                    body: { storage: { value: '<p>Old</p>' } },
-                });
-            });
-            vi.stubGlobal('fetch', fetchMock);
-            const cmd = getRegistry().get('confluence/update');
-            await expect(cmd.func({ id: '555', file, representation: 'markdown', execute: true }))
-                .rejects.toBeInstanceOf(CommandExecutionError);
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    it('searches with CQL scoped to a Data Center space', async () => {
-        clearEnv();
-        process.env.ATLASSIAN_CONFLUENCE_BASE_URL = 'https://conf.example.com/confluence';
-        process.env.ATLASSIAN_DEPLOYMENT = 'datacenter';
-        process.env.ATLASSIAN_PAT = 'pat';
-        const fetchMock = vi.fn(async (url) => {
-            const parsed = new URL(String(url));
-            expect(parsed.searchParams.get('cql')).toBe('space = "ENG" and (type = page)');
-            return jsonResponse({
-                results: [{
-                    content: {
-                        id: '123',
-                        type: 'page',
-                        status: 'current',
-                        title: 'Runbook',
-                        space: { key: 'ENG' },
-                        _links: { webui: '/display/ENG/Runbook' },
-                    },
-                    lastModified: '2026-05-02T00:00:00Z',
-                }],
-            });
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const cmd = getRegistry().get('confluence/search');
-        const rows = await cmd.func({ cql: 'type = page', space: 'ENG', limit: 10 });
-        expect(rows[0]).toMatchObject({ id: '123', title: 'Runbook', spaceKey: 'ENG' });
-        expect(rows[0].url).toBe('https://conf.example.com/confluence/display/ENG/Runbook');
-    });
-
-    it('separates Confluence search empty results from malformed search payloads', async () => {
-        setCloudEnv();
-        const cmd = getRegistry().get('confluence/search');
-        vi.stubGlobal('fetch', vi.fn(async () => jsonResponse({ results: [] })));
-        await expect(cmd.func({ cql: 'type = page', limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
-
-        vi.stubGlobal('fetch', vi.fn(async () => jsonResponse({ items: [] })));
-        await expect(cmd.func({ cql: 'type = page', limit: 10 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('fails typed when Confluence page payload lacks stable page identity', async () => {
-        setCloudEnv();
-        vi.stubGlobal('fetch', vi.fn(async () => jsonResponse({ title: 'Missing id', version: { number: 1 } })));
-        const cmd = getRegistry().get('confluence/page');
-        await expect(cmd.func({ id: '555' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});

package/clis/coupang/coupang.test.js

@@ -1,159 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './search.js';
-import './product.js';
-import './add-to-cart.js';
-import { parseLimitArg, parsePageArg, requireProductIdArg } from './utils.js';
-
-describe('coupang utils — parseLimitArg / parsePageArg (no silent clamp)', () => {
-    it('parseLimitArg returns fallback for empty / undefined', () => {
-        expect(parseLimitArg(undefined, 20, 50)).toBe(20);
-        expect(parseLimitArg(null, 20, 50)).toBe(20);
-        expect(parseLimitArg('', 20, 50)).toBe(20);
-    });
-
-    it('parseLimitArg accepts integers in range', () => {
-        expect(parseLimitArg(1, 20, 50)).toBe(1);
-        expect(parseLimitArg(50, 20, 50)).toBe(50);
-        expect(parseLimitArg('25', 20, 50)).toBe(25);
-    });
-
-    it('parseLimitArg throws ArgumentError on out-of-range / non-integer (no silent clamp)', () => {
-        expect(() => parseLimitArg(0, 20, 50)).toThrow(ArgumentError);
-        expect(() => parseLimitArg(-1, 20, 50)).toThrow(ArgumentError);
-        expect(() => parseLimitArg(51, 20, 50)).toThrow(ArgumentError);
-        expect(() => parseLimitArg(999, 20, 50)).toThrow(ArgumentError);
-        expect(() => parseLimitArg('abc', 20, 50)).toThrow(ArgumentError);
-        expect(() => parseLimitArg(1.5, 20, 50)).toThrow(ArgumentError);
-    });
-
-    it('parsePageArg returns fallback for empty', () => {
-        expect(parsePageArg(undefined, 1)).toBe(1);
-        expect(parsePageArg('', 1)).toBe(1);
-    });
-
-    it('parsePageArg accepts positive integers', () => {
-        expect(parsePageArg(1, 1)).toBe(1);
-        expect(parsePageArg('5', 1)).toBe(5);
-    });
-
-    it('parsePageArg throws ArgumentError on non-positive (no silent lift to 1)', () => {
-        expect(() => parsePageArg(0, 1)).toThrow(ArgumentError);
-        expect(() => parsePageArg(-1, 1)).toThrow(ArgumentError);
-        expect(() => parsePageArg('abc', 1)).toThrow(ArgumentError);
-    });
-});
-
-describe('coupang utils — product id validation', () => {
-    it('extracts numeric ids from ids and URLs', () => {
-        expect(requireProductIdArg('123456789')).toBe('123456789');
-        expect(requireProductIdArg('https://www.coupang.com/vp/products/123456789?itemId=1', '--url')).toBe('123456789');
-    });
-
-    it('rejects malformed product ids instead of building fake URLs', () => {
-        expect(() => requireProductIdArg('abc')).toThrow(ArgumentError);
-        expect(() => requireProductIdArg('abc 123456789')).toThrow(ArgumentError);
-        expect(() => requireProductIdArg('https://www.coupang.com/not-a-product', '--url')).toThrow(ArgumentError);
-        expect(() => requireProductIdArg('https://www.coupang.com/not-a-product/123456789', '--url')).toThrow(ArgumentError);
-        expect(() => requireProductIdArg('https://notcoupang.com/vp/products/123456789', '--url')).toThrow(ArgumentError);
-        expect(() => requireProductIdArg('https://example.com/vp/products/123456789', '--url')).toThrow(ArgumentError);
-    });
-});
-
-describe('coupang adapter registry shape', () => {
-    it('search has product_id column for round-trip into product', () => {
-        const search = getRegistry().get('coupang/search');
-        expect(search).toBeDefined();
-        expect(search.access).toBe('read');
-        expect(search.columns).toContain('product_id');
-        // Listing pairs with detail: id-shaped column present.
-        const idShaped = search.columns.find((c) => /_id$|^id$/.test(c));
-        expect(idShaped).toBe('product_id');
-    });
-
-    it('product cmd is a registered read adapter that pairs with search', () => {
-        const product = getRegistry().get('coupang/product');
-        expect(product).toBeDefined();
-        expect(product.access).toBe('read');
-        expect(product.columns).toContain('product_id');
-        expect(product.columns).toContain('title');
-        expect(product.columns).toContain('price');
-        expect(product.columns).toContain('seller');
-        expect(product.columns).toContain('rating');
-    });
-
-    it('add-to-cart remains write-class', () => {
-        const cart = getRegistry().get('coupang/add-to-cart');
-        expect(cart).toBeDefined();
-        expect(cart.access).toBe('write');
-    });
-});
-
-describe('coupang search — typed errors (no silent fallback)', () => {
-    it('rejects empty query with ArgumentError', async () => {
-        const search = getRegistry().get('coupang/search');
-        // page object is irrelevant — we expect to fail before any browser call.
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(search.func(fakePage, { query: '   ' })).rejects.toThrow(ArgumentError);
-        await expect(search.func(fakePage, { query: '' })).rejects.toThrow(ArgumentError);
-    });
-
-    it('rejects unsupported --filter with ArgumentError', async () => {
-        const search = getRegistry().get('coupang/search');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(search.func(fakePage, { query: 'mouse', filter: 'eco' })).rejects.toThrow(ArgumentError);
-    });
-
-    it('rejects out-of-range --limit with ArgumentError (no silent clamp to 50)', async () => {
-        const search = getRegistry().get('coupang/search');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(search.func(fakePage, { query: 'mouse', limit: 999 })).rejects.toThrow(ArgumentError);
-    });
-
-    it('rejects out-of-range --page with ArgumentError', async () => {
-        const search = getRegistry().get('coupang/search');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(search.func(fakePage, { query: 'mouse', page: 0 })).rejects.toThrow(ArgumentError);
-    });
-});
-
-describe('coupang product — typed errors', () => {
-    it('rejects missing --product-id and --url with ArgumentError', async () => {
-        const product = getRegistry().get('coupang/product');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(product.func(fakePage, {})).rejects.toThrow(ArgumentError);
-    });
-
-    it('rejects malformed product id before navigation', async () => {
-        const product = getRegistry().get('coupang/product');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(product.func(fakePage, { 'product-id': 'abc' })).rejects.toThrow(ArgumentError);
-    });
-
-    it('wraps browser failures as CommandExecutionError', async () => {
-        const product = getRegistry().get('coupang/product');
-        const fakePage = { goto: () => Promise.reject(new Error('browser down')) };
-        await expect(product.func(fakePage, { 'product-id': '123456789' })).rejects.toThrow(CommandExecutionError);
-    });
-});
-
-describe('coupang add-to-cart — typed errors', () => {
-    it('rejects missing --product-id and --url with ArgumentError', async () => {
-        const cart = getRegistry().get('coupang/add-to-cart');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(cart.func(fakePage, {})).rejects.toThrow(ArgumentError);
-    });
-
-    it('rejects malformed product id before navigation', async () => {
-        const cart = getRegistry().get('coupang/add-to-cart');
-        const fakePage = { goto: () => { throw new Error('should not navigate'); } };
-        await expect(cart.func(fakePage, { 'product-id': 'abc' })).rejects.toThrow(ArgumentError);
-    });
-
-    it('wraps browser failures as CommandExecutionError', async () => {
-        const cart = getRegistry().get('coupang/add-to-cart');
-        const fakePage = { goto: () => Promise.reject(new Error('browser down')) };
-        await expect(cart.func(fakePage, { 'product-id': '123456789' })).rejects.toThrow(CommandExecutionError);
-    });
-});

package/clis/coupang/utils.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { canonicalizeProductUrl, dedupeSearchItems, normalizeProductId, normalizeSearchItem, sanitizeSearchItems, } from './utils.js';
-describe('normalizeProductId', () => {
-    it('extracts product id from canonical path', () => {
-        expect(normalizeProductId('https://www.coupang.com/vp/products/123456789')).toBe('123456789');
-    });
-    it('preserves numeric ids', () => {
-        expect(normalizeProductId('987654321')).toBe('987654321');
-    });
-});
-describe('canonicalizeProductUrl', () => {
-    it('normalizes relative Coupang paths', () => {
-        expect(canonicalizeProductUrl('/vp/products/123456789?itemId=1', '')).toBe('https://www.coupang.com/vp/products/123456789');
-    });
-    it('builds url from product id', () => {
-        expect(canonicalizeProductUrl('', '123456789')).toBe('https://www.coupang.com/vp/products/123456789');
-    });
-});
-describe('normalizeSearchItem', () => {
-    it('maps raw fields into compare-ready shape', () => {
-        const item = normalizeSearchItem({
-            productId: '123456789',
-            productName: '무선 마우스',
-            salePrice: '29,900원',
-            originalPrice: '39,900원',
-            rating: '4.8',
-            reviewCount: '1,234',
-            sellerName: '쿠팡',
-            badge: ['ROCKET', 'TOMORROW', '무료배송'],
-            categoryName: 'PC',
-            url: '/vp/products/123456789?itemId=1',
-        }, 0);
-        expect(item).toMatchObject({
-            rank: 1,
-            product_id: '123456789',
-            title: '무선 마우스',
-            price: 29900,
-            original_price: 39900,
-            rating: 4.8,
-            review_count: 1234,
-            rocket: '로켓배송',
-            delivery_type: '무료배송',
-            delivery_promise: '내일도착',
-            seller: '쿠팡',
-            category: 'PC',
-            url: 'https://www.coupang.com/vp/products/123456789',
-        });
-    });
-});
-describe('sanitizeSearchItems', () => {
-    it('drops duplicates and invalid rows', () => {
-        const rows = [
-            normalizeSearchItem({ productId: '1', productName: 'A', price: '1000', url: '/vp/products/1' }, 0),
-            normalizeSearchItem({ productId: '1', productName: 'A', price: '1000', url: '/vp/products/1' }, 1),
-            normalizeSearchItem({ productId: '', productName: '', price: '1000' }, 2),
-            normalizeSearchItem({ productId: '2', productName: 'B', price: '2000', url: '/vp/products/2' }, 3),
-        ];
-        expect(dedupeSearchItems(rows)).toHaveLength(3);
-        expect(sanitizeSearchItems(rows, 10)).toHaveLength(2);
-        expect(sanitizeSearchItems(rows, 10).map(item => item.rank)).toEqual([1, 2]);
-    });
-});