@jackwener/opencli 1.7.11 → 1.7.13

package/clis/codex/sidebar.test.js

@@ -0,0 +1,329 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { askCommand } from './ask.js';
+import { historyCommand } from './history.js';
+import { projectsCommand } from './projects.js';
+import {
+    collectCodexProjectsFromDocument,
+    flattenCodexProjects,
+    openCodexConversation,
+    selectCodexConversationInDocument,
+} from './sidebar.js';
+
+class FakeElement {
+    constructor(tagName = 'div', attrs = {}, children = [], text = '') {
+        this.tagName = tagName.toUpperCase();
+        this.attrs = attrs;
+        this.children = children;
+        this.parentElement = null;
+        this.textContent = text;
+        this.innerText = text;
+        this.className = attrs.class || '';
+        this.listeners = new Map();
+        for (const child of children) {
+            child.parentElement = this;
+        }
+    }
+
+    getAttribute(name) {
+        return this.attrs[name] ?? null;
+    }
+
+    addEventListener(name, fn) {
+        const listeners = this.listeners.get(name) || [];
+        listeners.push(fn);
+        this.listeners.set(name, listeners);
+    }
+
+    click() {
+        for (const listener of this.listeners.get('click') || []) {
+            listener();
+        }
+    }
+
+    scrollIntoView() {
+    }
+
+    closest(selector) {
+        let current = this;
+        while (current) {
+            if (matchesSelector(current, selector))
+                return current;
+            current = current.parentElement;
+        }
+        return null;
+    }
+
+    querySelectorAll(selector) {
+        const selectors = selector.split(',').map(part => part.trim());
+        const results = [];
+        const visit = (node) => {
+            if (selectors.some(part => matchesSelector(node, part))) {
+                results.push(node);
+            }
+            for (const child of node.children) {
+                visit(child);
+            }
+        };
+        for (const child of this.children) {
+            visit(child);
+        }
+        return results;
+    }
+}
+
+function matchesSelector(node, selector) {
+    if (selector === '[data-app-action-sidebar-project-row]') {
+        return node.getAttribute('data-app-action-sidebar-project-row') !== null;
+    }
+    if (selector === '[data-app-action-sidebar-thread-row]') {
+        return node.getAttribute('data-app-action-sidebar-thread-row') !== null;
+    }
+    if (selector === '[role="listitem"][aria-label]') {
+        return node.getAttribute('role') === 'listitem' && node.getAttribute('aria-label') !== null;
+    }
+    if (selector === '.tabular-nums') {
+        return String(node.className || '').split(/\s+/).includes('tabular-nums');
+    }
+    if (selector === '[class*="tabular-nums"]') {
+        return String(node.className || '').includes('tabular-nums');
+    }
+    if (selector === '[class*="description"]') {
+        return String(node.className || '').includes('description');
+    }
+    return false;
+}
+
+function el(tagName, attrs, children = [], text = '') {
+    return new FakeElement(tagName, attrs, children, text);
+}
+
+function thread(attrs, title, updated) {
+    return el('div', {
+        role: 'button',
+        'data-app-action-sidebar-thread-row': '',
+        'data-app-action-sidebar-thread-title': title,
+        'data-app-action-sidebar-thread-id': attrs.threadId,
+        'data-app-action-sidebar-thread-host-id': attrs.hostId || '',
+        'data-app-action-sidebar-thread-kind': attrs.kind || '',
+        'data-app-action-sidebar-thread-active': attrs.active ? 'true' : 'false',
+        'data-app-action-sidebar-thread-pinned': attrs.pinned ? 'true' : 'false',
+    }, [
+        el('span', { 'data-thread-title': '' }, [], title),
+        el('span', { class: 'tabular-nums' }, [], updated),
+    ], `${title} ${updated}`);
+}
+
+function project(label, projectPath, children) {
+    return el('div', { role: 'listitem', 'aria-label': label }, [
+        el('div', {
+            role: 'button',
+            'aria-expanded': 'true',
+            'data-app-action-sidebar-project-row': '',
+            'data-app-action-sidebar-project-label': label,
+            'data-app-action-sidebar-project-id': projectPath,
+        }, [], label),
+        ...children,
+    ]);
+}
+
+function fixtureDocument() {
+    return el('document', {}, [
+        project('stock', '/Users/youngcan/stock', [
+            thread({ threadId: 'local:stock-sync', hostId: 'local', kind: 'local', active: true }, '同步各仓库最新代码', '4 小时'),
+            thread({ threadId: 'local:trading-agents' }, '借鉴 TradingAgents', '2 小时'),
+        ]),
+        project('opencli', '/Users/youngcan/opencli', [
+            thread({ threadId: 'local:opencli-groups' }, '统一 opencli 二级命令分组', '1 天'),
+        ]),
+    ]);
+}
+
+describe('codex sidebar helpers', () => {
+    it('collects projects and visible conversations from Codex data attributes', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+
+        expect(projects).toHaveLength(2);
+        expect(projects[0]).toMatchObject({
+            project: 'stock',
+            projectPath: '/Users/youngcan/stock',
+            collapsed: false,
+        });
+        expect(projects[0].conversations[0]).toMatchObject({
+            index: 1,
+            title: '同步各仓库最新代码',
+            updated: '4 小时',
+            active: true,
+            threadId: 'local:stock-sync',
+        });
+    });
+
+    it('flattens project rows with project filters', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+        const rows = flattenCodexProjects(projects, { project: 'opencli' });
+
+        expect(rows).toEqual([
+            expect.objectContaining({
+                Project: 'opencli',
+                Index: 1,
+                Title: '统一 opencli 二级命令分组',
+                Updated: '1 天',
+            }),
+        ]);
+    });
+
+    it('rejects invalid project/history limits instead of silently ignoring them', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+
+        expect(() => flattenCodexProjects(projects, { limit: '0' })).toThrowError(ArgumentError);
+        expect(() => flattenCodexProjects(projects, { limit: '1.5' })).toThrowError(ArgumentError);
+        expect(() => flattenCodexProjects(projects, { limit: 'abc' })).toThrowError(ArgumentError);
+    });
+
+    it('does not match nested project paths when filtering by a parent label', () => {
+        const projects = collectCodexProjectsFromDocument(fixtureDocument());
+        projects.push({
+            index: 3,
+            project: 'nested',
+            projectPath: '/Users/youngcan/opencli/nested',
+            collapsed: false,
+            conversations: [
+                { index: 1, title: 'Nested thread', updated: '', active: false, threadId: 'local:nested' },
+            ],
+        });
+
+        const rows = flattenCodexProjects(projects, { project: 'opencli' });
+
+        expect(rows.map(row => row.Project)).toEqual(['opencli']);
+    });
+
+    it('selects a conversation by project and title', () => {
+        const doc = fixtureDocument();
+        const selected = [];
+        for (const row of doc.querySelectorAll('[data-app-action-sidebar-thread-row]')) {
+            row.addEventListener('click', () => selected.push(row.getAttribute('data-app-action-sidebar-thread-id')));
+        }
+
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            conversation: 'TradingAgents',
+        }, doc);
+
+        expect(result).toMatchObject({
+            ok: true,
+            selected: true,
+            project: 'stock',
+            conversation: '借鉴 TradingAgents',
+            threadId: 'local:trading-agents',
+            index: 2,
+        });
+        expect(selected).toEqual(['local:trading-agents']);
+    });
+
+    it('does not dispatch DOM click when native click is preferred', () => {
+        const doc = fixtureDocument();
+        const selected = [];
+        for (const row of doc.querySelectorAll('[data-app-action-sidebar-thread-row]')) {
+            row.addEventListener('click', () => selected.push(row.getAttribute('data-app-action-sidebar-thread-id')));
+        }
+
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            conversation: 'TradingAgents',
+            preferNativeClick: true,
+        }, doc);
+
+        expect(result).toMatchObject({
+            ok: true,
+            selected: true,
+            threadId: 'local:trading-agents',
+        });
+        expect(selected).toEqual([]);
+    });
+
+    it('selects a conversation by index within a project', () => {
+        const result = selectCodexConversationInDocument({
+            project: '/Users/youngcan/opencli',
+            index: '1',
+        }, fixtureDocument());
+
+        expect(result).toMatchObject({
+            ok: true,
+            project: 'opencli',
+            conversation: '统一 opencli 二级命令分组',
+            threadId: 'local:opencli-groups',
+        });
+    });
+
+    it('reports exact thread-id misses as not found', () => {
+        const result = selectCodexConversationInDocument({
+            project: 'stock',
+            threadId: 'local:missing',
+        }, fixtureDocument());
+
+        expect(result).toMatchObject({
+            ok: false,
+            error: 'Thread not found: local:missing',
+        });
+    });
+
+    it('maps project/conversation misses to EmptyResultError in command selection', async () => {
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ project: 'missing' }, fixtureDocument()),
+        };
+
+        await expect(openCodexConversation(page, { project: 'missing' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('maps missing sidebar DOM to CommandExecutionError instead of empty success', async () => {
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ conversation: 'anything' }, el('document', {}, [])),
+        };
+
+        await expect(openCodexConversation(page, { conversation: 'anything' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps ambiguous conversation selection to ArgumentError', async () => {
+        const duplicateDoc = el('document', {}, [
+            project('alpha', '/tmp/alpha', [
+                thread({ threadId: 'local:one' }, 'Shared title', '1 小时'),
+            ]),
+            project('beta', '/tmp/beta', [
+                thread({ threadId: 'local:two' }, 'Shared title', '2 小时'),
+            ]),
+        ]);
+        const page = {
+            evaluate: async () => selectCodexConversationInDocument({ conversation: 'Shared title' }, duplicateDoc),
+        };
+
+        await expect(openCodexConversation(page, { conversation: 'Shared title' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+});
+
+describe('codex sidebar commands', () => {
+    it('projects fails empty result instead of returning a sentinel row', async () => {
+        const page = {
+            evaluate: async () => [],
+        };
+
+        await expect(projectsCommand.func(page, {})).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('history fails empty result instead of returning a sentinel row', async () => {
+        const page = {
+            evaluate: async () => [],
+        };
+
+        await expect(historyCommand.func(page, {})).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('ask rejects invalid timeout instead of falling back to the default', async () => {
+        const page = {
+            evaluate: async () => 0,
+        };
+
+        await expect(askCommand.func(page, { text: 'hello', timeout: 'bogus' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(askCommand.func(page, { text: 'hello', timeout: '0' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(askCommand.func(page, { text: 'hello', timeout: '1.5' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+});

package/clis/coingecko/categories.js

@@ -0,0 +1,75 @@
+// coingecko categories — top crypto categories by aggregated market cap.
+//
+// Hits the public `/api/v3/coins/categories` endpoint. Useful for spotting
+// which sectors (DeFi, L1, gaming, RWAs, …) are leading the market.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const ORDER_OPTIONS = ['market_cap_desc', 'market_cap_asc', 'name_desc', 'name_asc', 'market_cap_change_24h_desc', 'market_cap_change_24h_asc'];
+
+cli({
+    site: 'coingecko',
+    name: 'categories',
+    access: 'read',
+    description: 'Crypto categories ranked by aggregated market cap',
+    domain: 'api.coingecko.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'sort', default: 'market_cap_desc', help: `Sort order (${ORDER_OPTIONS.join(' / ')})` },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of categories (1-100; CoinGecko returns ~120 max)' },
+    ],
+    columns: ['rank', 'id', 'name', 'marketCap', 'volume24h', 'marketCapChange24hPct', 'top3Coins'],
+    func: async (args) => {
+        const sort = String(args.sort ?? 'market_cap_desc').trim().toLowerCase();
+        if (!ORDER_OPTIONS.includes(sort)) {
+            throw new ArgumentError(
+                `coingecko sort "${args.sort}" is not supported`,
+                `Supported sorts: ${ORDER_OPTIONS.join(', ')}`,
+            );
+        }
+        const limit = Number(args.limit ?? 20);
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new ArgumentError('coingecko limit must be a positive integer');
+        }
+        if (limit > 100) {
+            throw new ArgumentError('coingecko limit must be <= 100');
+        }
+        const url = `https://api.coingecko.com/api/v3/coins/categories?order=${encodeURIComponent(sort)}`;
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+        }
+        catch (err) {
+            throw new CommandExecutionError(`coingecko categories request failed: ${err?.message ?? err}`);
+        }
+        if (resp.status === 429) {
+            throw new CommandExecutionError(
+                'coingecko returned HTTP 429 (rate limited)',
+                'Free tier allows ~30 calls/min. Wait and retry.',
+            );
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`coingecko categories returned HTTP ${resp.status}`);
+        }
+        let data;
+        try {
+            data = await resp.json();
+        }
+        catch (err) {
+            throw new CommandExecutionError(`coingecko categories returned malformed JSON: ${err?.message ?? err}`);
+        }
+        if (!Array.isArray(data) || !data.length) {
+            throw new EmptyResultError('coingecko categories', 'CoinGecko returned no category data.');
+        }
+        return data.slice(0, limit).map((cat, i) => ({
+            rank: i + 1,
+            id: String(cat.id ?? ''),
+            name: String(cat.name ?? ''),
+            marketCap: cat.market_cap != null ? Number(cat.market_cap) : null,
+            volume24h: cat.volume_24h != null ? Number(cat.volume_24h) : null,
+            marketCapChange24hPct: cat.market_cap_change_24h != null ? Number(cat.market_cap_change_24h) : null,
+            top3Coins: Array.isArray(cat.top_3_coins_id) ? cat.top_3_coins_id.join(', ') : '',
+        }));
+    },
+});

package/clis/coingecko/coin.js

@@ -0,0 +1,107 @@
+// coingecko coin — fetch a single cryptocurrency's market detail by id.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    ArgumentError,
+    CommandExecutionError,
+    EmptyResultError,
+} from '@jackwener/opencli/errors';
+
+cli({
+    site: 'coingecko',
+    name: 'coin',
+    access: 'read',
+    description: 'Fetch a single cryptocurrency\'s market data by CoinGecko id (e.g. bitcoin, ethereum).',
+    domain: 'api.coingecko.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, type: 'string', help: 'CoinGecko coin id (lowercase, e.g. bitcoin / ethereum / solana).' },
+        { name: 'currency', type: 'string', default: 'usd', help: 'Quote currency (usd, cny, eur, jpy, ...).' },
+    ],
+    columns: [
+        'id', 'symbol', 'name', 'rank', 'price', 'marketCap', 'volume24h',
+        'change24hPct', 'change7dPct', 'change30dPct', 'ath', 'athDate', 'atl', 'atlDate',
+        'circulatingSupply', 'totalSupply', 'maxSupply', 'genesisDate', 'homepage',
+    ],
+    func: async (args) => {
+        const id = String(args.id ?? '').trim().toLowerCase();
+        if (!id) {
+            throw new ArgumentError('coingecko coin id cannot be empty', 'Example: opencli coingecko coin bitcoin');
+        }
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
+            throw new ArgumentError(`coingecko coin id must look like a CoinGecko slug (got "${args.id}")`);
+        }
+        const currency = String(args.currency ?? 'usd').trim().toLowerCase();
+        if (!/^[a-z0-9-]{2,20}$/.test(currency)) {
+            throw new ArgumentError(`coingecko currency must look like a currency slug (got "${args.currency}")`);
+        }
+
+        const url = new URL(`https://api.coingecko.com/api/v3/coins/${id}`);
+        url.searchParams.set('localization', 'false');
+        url.searchParams.set('tickers', 'false');
+        url.searchParams.set('market_data', 'true');
+        url.searchParams.set('community_data', 'false');
+        url.searchParams.set('developer_data', 'false');
+        url.searchParams.set('sparkline', 'false');
+
+        let resp;
+        try {
+            resp = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+        } catch (error) {
+            throw new CommandExecutionError(`coingecko coin request failed: ${error?.message || error}`);
+        }
+        if (resp.status === 404) {
+            throw new EmptyResultError('coingecko coin', `coingecko has no coin with id "${id}".`);
+        }
+        if (resp.status === 429) {
+            throw new CommandExecutionError('coingecko returned HTTP 429 (rate limited)', 'Free tier allows ~30 calls/min. Wait and retry.');
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`coingecko coin failed: HTTP ${resp.status}`);
+        }
+        let data;
+        try {
+            data = await resp.json();
+        } catch (error) {
+            throw new CommandExecutionError(`coingecko returned malformed JSON: ${error?.message || error}`);
+        }
+        if (data?.error) {
+            throw new CommandExecutionError(`coingecko returned error: ${data.error}`);
+        }
+
+        const md = data.market_data || {};
+        const pick = (obj, key) => (obj && obj[key] != null ? obj[key] : null);
+        const isoFromMaybe = (s) => (s ? String(s).slice(0, 10) : '');
+        const price = pick(md.current_price, currency);
+        const marketCap = pick(md.market_cap, currency);
+        const volume24h = pick(md.total_volume, currency);
+        if (price == null && marketCap == null && volume24h == null) {
+            throw new CommandExecutionError(
+                `coingecko returned no market data for currency "${currency}"`,
+                'Use a CoinGecko-supported quote currency such as usd, cny, eur, or jpy.',
+            );
+        }
+
+        return [{
+            id: data.id || id,
+            symbol: String(data.symbol || '').toUpperCase(),
+            name: data.name || '',
+            rank: data.market_cap_rank ?? null,
+            price,
+            marketCap,
+            volume24h,
+            change24hPct: md.price_change_percentage_24h ?? null,
+            change7dPct: md.price_change_percentage_7d ?? null,
+            change30dPct: md.price_change_percentage_30d ?? null,
+            ath: pick(md.ath, currency),
+            athDate: isoFromMaybe(pick(md.ath_date, currency)),
+            atl: pick(md.atl, currency),
+            atlDate: isoFromMaybe(pick(md.atl_date, currency)),
+            circulatingSupply: md.circulating_supply ?? null,
+            totalSupply: md.total_supply ?? null,
+            maxSupply: md.max_supply ?? null,
+            genesisDate: data.genesis_date || '',
+            homepage: Array.isArray(data.links?.homepage) ? (data.links.homepage.find(Boolean) || '') : '',
+        }];
+    },
+});

package/clis/coingecko/coingecko.test.js

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/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,
+        })]);
+    });
+});