@zhive/cli 0.5.5 → 0.6.0

package/dist/commands/megathread/commands/create-comment.test.js

@@ -0,0 +1,480 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = path.join(__dirname, '../../../../__fixtures__/mock-hive');
+vi.mock('../../../shared/config/constant.js', () => ({
+    getHiveDir: vi.fn(() => FIXTURES_DIR),
+    HIVE_API_URL: 'http://localhost:6969',
+}));
+vi.mock('../../../shared/config/ai-providers.js', () => ({
+    AI_PROVIDERS: [
+        { label: 'OpenAI', package: '@ai-sdk/openai', envVar: 'OPENAI_API_KEY' },
+    ],
+}));
+vi.mock('@zhive/sdk', async () => {
+    const actual = await vi.importActual('@zhive/sdk');
+    return {
+        ...actual,
+        HiveClient: vi.fn().mockImplementation(() => ({
+            postMegathreadComment: vi.fn(),
+        })),
+        loadCredentials: vi.fn(),
+    };
+});
+vi.mock('../../shared/theme.js', () => ({
+    styled: {
+        red: (text) => text,
+        gray: (text) => text,
+        green: (text) => text,
+    },
+    symbols: {
+        cross: '✗',
+        check: '✓',
+    },
+}));
+import { HiveClient, loadCredentials } from '@zhive/sdk';
+import { createMegathreadCreateCommentCommand } from './create-comment.js';
+const MockHiveClient = HiveClient;
+const mockLoadCredentials = loadCredentials;
+describe('createMegathreadCreateCommentCommand', () => {
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let processExitSpy;
+    let consoleOutput;
+    let consoleErrorOutput;
+    let mockPostMegathreadComment;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        consoleOutput = [];
+        consoleErrorOutput = [];
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+            consoleOutput.push(args.join(' '));
+        });
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation((...args) => {
+            consoleErrorOutput.push(args.join(' '));
+        });
+        processExitSpy = vi
+            .spyOn(process, 'exit')
+            .mockImplementation((code) => {
+            throw new Error(`process.exit(${code})`);
+        });
+        mockPostMegathreadComment = vi.fn();
+        MockHiveClient.mockImplementation(() => ({
+            postMegathreadComment: mockPostMegathreadComment,
+        }));
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('conviction validation', () => {
+        it('shows error when conviction is too high', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '150',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: 150');
+        });
+        it('shows error when conviction is too low', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '-150',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be between -100 and 100');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: -150');
+        });
+        it('shows error when conviction is not a number', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                'abc',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('conviction: Must be a number');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+        });
+        it('accepts valid conviction at upper boundary', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '100',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 100,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
+        });
+        it('accepts valid conviction at lower boundary', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '-100',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: -100,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
+        });
+        it('accepts decimal conviction values', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '25.5',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Test comment',
+                conviction: 25.5,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
+        });
+    });
+    describe('duration validation', () => {
+        it('shows error when duration is negative', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '-1',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: -1');
+        });
+        it('shows error when duration is zero', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '0',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: 0');
+        });
+        it('shows error when duration is not a number', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                'abc',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('duration: Must be a positive number');
+            expect(consoleErrorOutput.join('\n')).toContain('Got: abc');
+        });
+    });
+    describe('agent validation', () => {
+        it('shows error when agent not found and lists available agents', async () => {
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'non-existent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('Agent "non-existent" not found');
+            expect(consoleErrorOutput.join('\n')).toContain('Available agents:');
+            expect(consoleErrorOutput.join('\n')).toContain('test-agent');
+            expect(consoleErrorOutput.join('\n')).toContain('empty-agent');
+            expect(consoleErrorOutput.join('\n')).toContain('agent-no-skills');
+        });
+    });
+    describe('credentials validation', () => {
+        it('shows error when credentials are missing', async () => {
+            mockLoadCredentials.mockResolvedValue(null);
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('No credentials found for agent "test-agent"');
+        });
+        it('shows error when credentials have no API key', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: null });
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
+        });
+    });
+    describe('successful comment posting', () => {
+        it('posts comment and shows success message', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Bullish on Bitcoin!',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: 'Bullish on Bitcoin!',
+                conviction: 50,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('Comment posted successfully');
+            expect(output).toContain('round-123');
+            expect(output).toContain('bitcoin');
+            expect(output).toContain('+50.0%');
+            expect(output).toContain('Bullish on Bitcoin!');
+        });
+        it('formats negative conviction correctly', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '-30',
+                '--text',
+                'Bearish outlook',
+                '--token',
+                'ethereum',
+                '--duration',
+                '14400000',
+            ], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('-30.0%');
+        });
+        it('truncates long text in success message', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const longText = 'A'.repeat(100);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '25',
+                '--text',
+                longText,
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            // Verify full text was sent to API
+            expect(mockPostMegathreadComment).toHaveBeenCalledWith('round-123', {
+                text: longText,
+                conviction: 25,
+                tokenId: 'bitcoin',
+                roundDuration: 3600000,
+            });
+            // Verify truncated display
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('A'.repeat(50) + '...');
+        });
+    });
+    describe('API error handling', () => {
+        it('shows error when API call fails', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockRejectedValue(new Error('Network error'));
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
+            expect(consoleErrorOutput.join('\n')).toContain('Network error');
+        });
+        it('handles non-Error exceptions', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockRejectedValue('String error');
+            const command = createMegathreadCreateCommentCommand();
+            await expect(command.parseAsync([
+                '--agent',
+                'test-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' })).rejects.toThrow('process.exit(1)');
+            expect(consoleErrorOutput.join('\n')).toContain('Failed to post comment');
+            expect(consoleErrorOutput.join('\n')).toContain('String error');
+        });
+    });
+    describe('works with different fixture agents', () => {
+        it('works with empty-agent', async () => {
+            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockPostMegathreadComment.mockResolvedValue(undefined);
+            const command = createMegathreadCreateCommentCommand();
+            await command.parseAsync([
+                '--agent',
+                'empty-agent',
+                '--round',
+                'round-123',
+                '--conviction',
+                '50',
+                '--text',
+                'Test comment',
+                '--token',
+                'bitcoin',
+                '--duration',
+                '3600000',
+            ], { from: 'user' });
+            const output = consoleOutput.join('\n');
+            expect(output).toContain('Comment posted successfully');
+        });
+    });
+});

package/dist/commands/megathread/commands/index.js

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import { createMegathreadListCommand } from './list.js';
+import { createMegathreadCreateCommentCommand } from './create-comment.js';
+export function createMegathreadCommand() {
+    const megathreadCommand = new Command('megathread').description('Megathread operations');
+    megathreadCommand.addCommand(createMegathreadListCommand());
+    megathreadCommand.addCommand(createMegathreadCreateCommentCommand());
+    return megathreadCommand;
+}

package/dist/commands/megathread/commands/list.js

@@ -0,0 +1,102 @@
+import { Command } from 'commander';
+import { HiveClient, TIMEFRAME_DURATION_MS, Timeframe } from '@zhive/sdk';
+import { styled, symbols, border } from '../../shared/theme.js';
+import { HIVE_API_URL } from '../../../shared/config/constant.js';
+import { findAgentByName, loadAgentCredentials, scanAgents } from '../../../shared/config/agent.js';
+const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
+const DURATION_MS_TO_TIMEFRAME = {
+    [TIMEFRAME_DURATION_MS[Timeframe.H1]]: Timeframe.H1,
+    [TIMEFRAME_DURATION_MS[Timeframe.H4]]: Timeframe.H4,
+    [TIMEFRAME_DURATION_MS[Timeframe.H24]]: Timeframe.H24,
+};
+function durationMsToTimeframe(durationMs) {
+    const result = DURATION_MS_TO_TIMEFRAME[durationMs];
+    return result;
+}
+function parseTimeframes(raw) {
+    const parts = raw.split(',').map((t) => t.trim());
+    const invalid = parts.filter((t) => !VALID_TIMEFRAMES.includes(t));
+    if (invalid.length > 0) {
+        return null;
+    }
+    const parsed = parts;
+    return parsed;
+}
+export function createMegathreadListCommand() {
+    const program = new Command('list')
+        .description('List unpredicted megathread rounds of an agent')
+        .requiredOption('--agent <name>', 'Agent name')
+        .option('--timeframe <timeframes>', 'Filter by timeframes (comma-separated: 1h,4h,24h)')
+        .action(async (options) => {
+        const { agent: agentName, timeframe: timeframeOption } = options;
+        let timeframes;
+        if (timeframeOption) {
+            const parsed = parseTimeframes(timeframeOption);
+            if (parsed === null) {
+                const invalidParts = timeframeOption
+                    .split(',')
+                    .map((t) => t.trim())
+                    .filter((t) => !VALID_TIMEFRAMES.includes(t));
+                console.error(styled.red(`${symbols.cross} Invalid timeframes: ${invalidParts.join(', ')}. Valid values: 1h, 4h, 24h`));
+                process.exit(1);
+            }
+            timeframes = parsed;
+        }
+        const agentConfig = await findAgentByName(agentName);
+        if (!agentConfig) {
+            const agents = await scanAgents();
+            if (agents.length === 0) {
+                console.error(styled.red(`${symbols.cross} No agents found. Create one with: npx @zhive/cli@latest create`));
+            }
+            else {
+                const availableNames = agents.map((a) => a.name).join(', ');
+                console.error(styled.red(`${symbols.cross} Agent "${agentName}" not found. Available agents: ${availableNames}`));
+            }
+            process.exit(1);
+        }
+        const credentials = await loadAgentCredentials(agentConfig.dir, agentConfig.name);
+        if (!credentials?.apiKey) {
+            console.error(styled.red(`${symbols.cross} No credentials found for agent "${agentName}". The agent may need to be registered first.`));
+            process.exit(1);
+        }
+        const client = new HiveClient(HIVE_API_URL, credentials.apiKey);
+        try {
+            const rounds = await client.getUnpredictedRounds(timeframes);
+            console.log('');
+            console.log(styled.honeyBold(`${symbols.hive} Unpredicted Rounds for ${agentName}`));
+            console.log('');
+            if (rounds.length === 0) {
+                console.log(styled.gray('  No unpredicted rounds available.'));
+                console.log('');
+                return;
+            }
+            const headers = ['Round ID', 'Token', 'Timeframe'];
+            const rows = rounds.map((r) => {
+                const tf = durationMsToTimeframe(r.durationMs);
+                const timeframeStr = tf ?? `${r.durationMs}ms`;
+                return [r.roundId, r.projectId, timeframeStr];
+            });
+            const colWidths = headers.map((h, i) => {
+                const dataMax = Math.max(...rows.map((row) => String(row[i]).length));
+                const width = Math.max(h.length, dataMax);
+                return width;
+            });
+            const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+            console.log(`  ${styled.gray(headerLine)}`);
+            console.log(`  ${styled.gray(border.horizontal.repeat(headerLine.length))}`);
+            for (const row of rows) {
+                const line = row.map((cell, i) => String(cell).padEnd(colWidths[i])).join('  ');
+                console.log(`  ${line}`);
+            }
+            console.log('');
+            console.log(styled.gray(`  Total: ${rounds.length} round(s)`));
+            console.log('');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(styled.red(`${symbols.cross} Failed to fetch unpredicted rounds: ${message}`));
+            process.exit(1);
+        }
+    });
+    return program;
+}