@sovovs/bycli 1.8.0 → 2.0.0

package/clis/claude/commands.test.js

@@ -1,118 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ArgumentError, AuthRequiredError, EmptyResultError } from '@sovovs/bycli/errors';
-
-const {
-    mockEnsureOnClaude,
-    mockEnsureClaudeComposer,
-    mockEnsureClaudeLogin,
-    mockSendMessage,
-    mockParseBoolFlag,
-    mockRequireNonEmptyPrompt,
-    mockGetVisibleMessages,
-    mockGetConversationList,
-    mockRequirePositiveInt,
-    mockRequireConversationId,
-    mockWithRetry,
-} = vi.hoisted(() => ({
-    mockEnsureOnClaude: vi.fn(),
-    mockEnsureClaudeComposer: vi.fn(),
-    mockEnsureClaudeLogin: vi.fn(),
-    mockSendMessage: vi.fn(),
-    mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
-    mockRequireNonEmptyPrompt: vi.fn((v) => String(v ?? '')),
-    mockGetVisibleMessages: vi.fn(),
-    mockGetConversationList: vi.fn(),
-    mockRequirePositiveInt: vi.fn((v) => Number(v)),
-    mockRequireConversationId: vi.fn((v) => String(v ?? '').trim()),
-    mockWithRetry: vi.fn(async (fn) => fn()),
-}));
-
-vi.mock('./utils.js', () => ({
-    CLAUDE_DOMAIN: 'claude.ai',
-    CLAUDE_URL: 'https://claude.ai/new',
-    ensureOnClaude: mockEnsureOnClaude,
-    ensureClaudeComposer: mockEnsureClaudeComposer,
-    ensureClaudeLogin: mockEnsureClaudeLogin,
-    sendMessage: mockSendMessage,
-    parseBoolFlag: mockParseBoolFlag,
-    requireNonEmptyPrompt: mockRequireNonEmptyPrompt,
-    getVisibleMessages: mockGetVisibleMessages,
-    getConversationList: mockGetConversationList,
-    requirePositiveInt: mockRequirePositiveInt,
-    requireConversationId: mockRequireConversationId,
-    withRetry: mockWithRetry,
-}));
-
-import { sendCommand } from './send.js';
-import { newCommand } from './new.js';
-import { readCommand } from './read.js';
-import { historyCommand } from './history.js';
-import { detailCommand } from './detail.js';
-
-describe('claude command-level fail-fast contracts', () => {
-    const page = {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockEnsureOnClaude.mockResolvedValue(false);
-        mockEnsureClaudeComposer.mockResolvedValue({ isLoggedIn: true, hasComposer: true });
-        mockEnsureClaudeLogin.mockResolvedValue({ isLoggedIn: true });
-        mockSendMessage.mockResolvedValue({ ok: true });
-        mockRequireNonEmptyPrompt.mockImplementation((v) => String(v ?? ''));
-        mockGetVisibleMessages.mockResolvedValue([{ Index: 0, Role: 'assistant', Text: 'hi' }]);
-        mockGetConversationList.mockResolvedValue([{ Index: 1, Id: 'abc', Title: 'Hi', Url: 'https://claude.ai/chat/abc' }]);
-        mockRequirePositiveInt.mockImplementation((v) => Number(v));
-        mockRequireConversationId.mockImplementation((v) => String(v ?? '').trim());
-    });
-
-    it('send rejects empty prompt via ArgumentError', async () => {
-        mockRequireNonEmptyPrompt.mockImplementation(() => {
-            throw new ArgumentError('claude send prompt cannot be empty');
-        });
-
-        await expect(sendCommand.func(page, { prompt: '', new: false })).rejects.toThrow(ArgumentError);
-    });
-
-    it('send surfaces auth failure from composer readiness', async () => {
-        mockEnsureClaudeComposer.mockRejectedValue(new AuthRequiredError('claude.ai', 'Claude send requires a logged-in Claude session.'));
-
-        await expect(sendCommand.func(page, { prompt: 'hi', new: false })).rejects.toThrow(AuthRequiredError);
-    });
-
-    it('new no longer false-succeeds on login wall', async () => {
-        mockEnsureClaudeComposer.mockRejectedValue(new AuthRequiredError('claude.ai', 'Claude new requires a logged-in Claude session with a visible composer.'));
-
-        await expect(newCommand.func(page)).rejects.toThrow(AuthRequiredError);
-    });
-
-    it('read throws EmptyResultError instead of a placeholder row', async () => {
-        mockGetVisibleMessages.mockResolvedValue([]);
-
-        await expect(readCommand.func(page)).rejects.toThrow(EmptyResultError);
-    });
-
-    it('history rejects invalid --limit values instead of silently coercing them', async () => {
-        mockRequirePositiveInt.mockImplementation(() => {
-            throw new ArgumentError('claude history --limit must be a positive integer');
-        });
-
-        await expect(historyCommand.func(page, { limit: 0 })).rejects.toThrow(ArgumentError);
-    });
-
-    it('history throws EmptyResultError on an empty /recents page', async () => {
-        mockGetConversationList.mockResolvedValue([]);
-
-        await expect(historyCommand.func(page, { limit: 20 })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('detail rejects a missing conversation id', async () => {
-        mockRequireConversationId.mockImplementation(() => {
-            throw new ArgumentError('claude detail requires a conversation id');
-        });
-
-        await expect(detailCommand.func(page, { id: '' })).rejects.toThrow(ArgumentError);
-    });
-});

package/clis/claude/utils.test.js

@@ -1,148 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { ArgumentError } from '@sovovs/bycli/errors';
-import { parseBoolFlag, sendWithFile, selectModel, requireConversationId, requireNonEmptyPrompt, requirePositiveInt } from './utils.js';
-
-describe('claude parseBoolFlag', () => {
-    it('returns booleans unchanged', () => {
-        expect(parseBoolFlag(true)).toBe(true);
-        expect(parseBoolFlag(false)).toBe(false);
-    });
-
-    it('treats only "true" string (case-insensitive) as true', () => {
-        expect(parseBoolFlag('true')).toBe(true);
-        expect(parseBoolFlag('TRUE')).toBe(true);
-        expect(parseBoolFlag('1')).toBe(false);
-        expect(parseBoolFlag('yes')).toBe(false);
-        expect(parseBoolFlag('')).toBe(false);
-        expect(parseBoolFlag(null)).toBe(false);
-        expect(parseBoolFlag(undefined)).toBe(false);
-    });
-});
-
-describe('claude argument helpers', () => {
-    it('rejects blank prompts', () => {
-        expect(() => requireNonEmptyPrompt('   ', 'claude ask')).toThrow(ArgumentError);
-    });
-
-    it('rejects non-positive integers for numeric flags', () => {
-        expect(() => requirePositiveInt(0, 'claude ask --timeout')).toThrow(ArgumentError);
-        expect(() => requirePositiveInt(-1, 'claude history --limit')).toThrow(ArgumentError);
-    });
-
-    it('rejects missing conversation ids', () => {
-        expect(() => requireConversationId('   ')).toThrow(ArgumentError);
-    });
-});
-
-describe('claude sendWithFile', () => {
-    const tempDirs = [];
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-        while (tempDirs.length) {
-            fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-        }
-    });
-
-    it('prefers page.setFileInput, then sends after preview appears', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-claude-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'cat.png');
-        fs.writeFileSync(filePath, 'fake');
-
-        const page = {
-            nativeType: vi.fn().mockResolvedValue(undefined),
-            setFileInput: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ ok: true, via: 'react' }) // React onChange fired after setFileInput
-                .mockResolvedValueOnce(true)                       // waitForFilePreview hit
-                .mockResolvedValueOnce(true)                       // composer ready
-                .mockResolvedValueOnce({ ok: true }),              // send button click
-        };
-
-        const result = await sendWithFile(page, filePath, 'describe this');
-
-        expect(result).toEqual({ ok: true });
-        expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[data-testid="file-upload"]');
-        expect(page.nativeType).toHaveBeenCalledWith('describe this');
-    });
-
-    it('returns file-not-found when path does not exist', async () => {
-        const page = { setFileInput: vi.fn(), evaluate: vi.fn(), wait: vi.fn() };
-        const result = await sendWithFile(page, '/no/such/file.png', 'hi');
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('File not found');
-    });
-
-    it('rejects oversized files before any upload attempt', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-claude-'));
-        tempDirs.push(dir);
-        const filePath = path.join(dir, 'big.bin');
-        fs.writeFileSync(filePath, Buffer.alloc(31 * 1024 * 1024));
-
-        const page = { setFileInput: vi.fn(), evaluate: vi.fn(), wait: vi.fn() };
-        const result = await sendWithFile(page, filePath, 'hi');
-
-        expect(result.ok).toBe(false);
-        expect(result.reason).toMatch(/too large/);
-        expect(page.setFileInput).not.toHaveBeenCalled();
-    });
-});
-
-describe('claude selectModel', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    it('rejects unknown model keys without touching the page', async () => {
-        const page = { evaluate: vi.fn() };
-
-        const result = await selectModel(page, 'gpt5');
-
-        expect(result).toEqual({ ok: false });
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-
-    it('returns toggled=false when the dropdown already shows the requested model', async () => {
-        const page = {
-            evaluate: vi.fn().mockResolvedValueOnce({ ok: true, toggled: false }),
-            wait: vi.fn(),
-        };
-
-        const result = await selectModel(page, 'sonnet');
-
-        expect(result).toEqual({ ok: true, toggled: false });
-        expect(page.wait).not.toHaveBeenCalled();
-    });
-
-    it('opens the dropdown and clicks the matching radio', async () => {
-        const page = {
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ ok: true, opened: true })
-                .mockResolvedValueOnce({ ok: true, toggled: true }),
-            wait: vi.fn().mockResolvedValue(undefined),
-        };
-
-        const result = await selectModel(page, 'haiku');
-
-        expect(result).toEqual({ ok: true, toggled: true });
-        expect(page.evaluate).toHaveBeenCalledTimes(2);
-    });
-
-    it('flags upgrade-required when picking a paid model on free tier', async () => {
-        const page = {
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({ ok: true, opened: true })
-                .mockResolvedValueOnce({ ok: false, upgrade: true }),
-            wait: vi.fn().mockResolvedValue(undefined),
-        };
-
-        const result = await selectModel(page, 'opus');
-
-        expect(result).toEqual({ ok: false, upgrade: true });
-    });
-});

package/clis/cnki/search.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './search.js';
-describe('cnki search command', () => {
-    const command = getRegistry().get('cnki/search');
-    it('registers the command', () => {
-        expect(command).toBeDefined();
-        expect(command.site).toBe('cnki');
-        expect(command.name).toBe('search');
-    });
-    it('rejects empty queries before browser navigation', async () => {
-        const page = { goto: async () => undefined };
-        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
-            name: 'ArgumentError',
-            code: 'ARGUMENT',
-        });
-    });
-});

package/clis/codex/sidebar.test.js

@@ -1,329 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/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('bycli', '/Users/youngcan/bycli', [
-            thread({ threadId: 'local:bycli-groups' }, '统一 bycli 二级命令分组', '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: 'bycli' });
-
-        expect(rows).toEqual([
-            expect.objectContaining({
-                Project: 'bycli',
-                Index: 1,
-                Title: '统一 bycli 二级命令分组',
-                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/bycli/nested',
-            collapsed: false,
-            conversations: [
-                { index: 1, title: 'Nested thread', updated: '', active: false, threadId: 'local:nested' },
-            ],
-        });
-
-        const rows = flattenCodexProjects(projects, { project: 'bycli' });
-
-        expect(rows.map(row => row.Project)).toEqual(['bycli']);
-    });
-
-    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/bycli',
-            index: '1',
-        }, fixtureDocument());
-
-        expect(result).toMatchObject({
-            ok: true,
-            project: 'bycli',
-            conversation: '统一 bycli 二级命令分组',
-            threadId: 'local:bycli-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);
-    });
-});