@zhive/cli 0.6.3 → 0.6.5

package/dist/commands/megathread/commands/create-comments.js

@@ -0,0 +1,83 @@
+import { Command } from 'commander';
+import { z } from 'zod';
+import { HiveClient, loadConfig, } from '@zhive/sdk';
+import { styled, symbols } from '../../shared/theme.js';
+import { HIVE_API_URL } from '../../../shared/config/constant.js';
+import { findAgentByName, scanAgents } from '../../../shared/config/agent.js';
+import { printZodError } from '../../shared/ validation.js';
+const convictionSchema = z
+    .object({
+    round: z.string().min(1),
+    conviction: z.coerce.number().min(-100).max(100),
+    text: z.string().min(1),
+})
+    .array();
+const CreateCommentsOptionsSchema = z.object({
+    agent: z.string().min(1),
+    json: z.string().transform((val, ctx) => {
+        try {
+            const parsed = convictionSchema.parse(JSON.parse(val));
+            return parsed;
+        }
+        catch (e) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'Invalid input',
+            });
+            return z.NEVER;
+        }
+    }),
+});
+export function createMegathreadCreateCommentsCommand() {
+    return new Command('create-comments')
+        .description('Batch create megathread comment')
+        .requiredOption('--agent <name>', 'Agent name')
+        .requiredOption('--json <object>', 'comment array')
+        .action(async (options) => {
+        const parseResult = CreateCommentsOptionsSchema.safeParse(options);
+        if (!parseResult.success) {
+            printZodError(parseResult);
+            process.exit(1);
+        }
+        const { agent: agentName, json } = parseResult.data;
+        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 loadConfig(agentConfig.dir);
+        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);
+        const payload = {
+            comments: [],
+        };
+        for (const item of json) {
+            payload.comments.push({
+                roundId: item.round,
+                conviction: item.conviction,
+                text: item.text,
+            });
+        }
+        try {
+            await client.postBatchMegathreadComments(payload);
+            console.log('');
+            console.log(styled.green(`${symbols.check} ${payload.comments.length} Comments posted successfully!`));
+            console.log('');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(styled.red(`${symbols.cross} Failed to post comment: ${message}`));
+            process.exit(1);
+        }
+    });
+}

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

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

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

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { HiveClient, durationMsToTimeframe } from '@zhive/sdk';
+import { HiveClient, durationMsToTimeframe, loadConfig } 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';
+import { findAgentByName, scanAgents } from '../../../shared/config/agent.js';
 import z from 'zod';
 import { printZodError } from '../../shared/ validation.js';
 const VALID_TIMEFRAMES = ['1h', '4h', '24h'];
@@ -50,12 +50,12 @@ export function createMegathreadListCommand() {
             }
             process.exit(1);
         }
-        const credentials = await loadAgentCredentials(agentConfig.dir, agentConfig.name);
-        if (!credentials?.apiKey) {
+        const config = await loadConfig(agentConfig.dir);
+        if (!config?.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);
+        const client = new HiveClient(HIVE_API_URL, config.apiKey);
         try {
             const rounds = await client.getUnpredictedRounds(timeframes);
             console.log('');

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

@@ -17,7 +17,7 @@ vi.mock('@zhive/sdk', async () => {
         HiveClient: vi.fn().mockImplementation(() => ({
             getUnpredictedRounds: vi.fn(),
         })),
-        loadCredentials: vi.fn(),
+        loadConfig: vi.fn(),
         TIMEFRAME_DURATION_MS: {
             H1: 3600000,
             H4: 14400000,
@@ -30,10 +30,10 @@ vi.mock('@zhive/sdk', async () => {
         },
     };
 });
-import { HiveClient, loadCredentials } from '@zhive/sdk';
+import { HiveClient, loadConfig } from '@zhive/sdk';
 import { createMegathreadListCommand } from './list.js';
 const MockHiveClient = HiveClient;
-const mockLoadCredentials = loadCredentials;
+const mockLoadConfig = loadConfig;
 function createMockActiveRound(overrides = {}) {
     return {
         roundId: 'round-123',
@@ -88,21 +88,21 @@ describe('createMegathreadListCommand', () => {
             expect(consoleErrorOutput.length).toBeGreaterThan(0);
         });
         it('accepts valid timeframe values', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent', '--timeframe', '1h,4h'], { from: 'user' });
             expect(mockGetUnpredictedRounds).toHaveBeenCalledWith(['1h', '4h']);
         });
         it('accepts single valid timeframe', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent', '--timeframe', '24h'], { from: 'user' });
             expect(mockGetUnpredictedRounds).toHaveBeenCalledWith(['24h']);
         });
         it('passes undefined when no timeframe filter specified', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -122,13 +122,13 @@ describe('createMegathreadListCommand', () => {
     });
     describe('credentials validation', () => {
         it('shows error when credentials are missing', async () => {
-            mockLoadCredentials.mockResolvedValue(null);
+            mockLoadConfig.mockResolvedValue(null);
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { 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 });
+            mockLoadConfig.mockResolvedValue({ apiKey: null });
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
             expect(consoleErrorOutput.join('\n')).toContain('No credentials found');
@@ -136,7 +136,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('rounds display', () => {
         it('shows message when no unpredicted rounds available', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -149,7 +149,7 @@ describe('createMegathreadListCommand', () => {
                 createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 3600000 }),
                 createMockActiveRound({ roundId: 'round-2', projectId: 'ethereum', durationMs: 14400000 }),
             ];
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -168,7 +168,7 @@ describe('createMegathreadListCommand', () => {
             const mockRounds = [
                 createMockActiveRound({ roundId: 'round-1', projectId: 'bitcoin', durationMs: 7200000 }),
             ];
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue(mockRounds);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'test-agent'], { from: 'user' });
@@ -178,7 +178,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('API error handling', () => {
         it('shows error when API call fails', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockRejectedValue(new Error('Network error'));
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
@@ -186,7 +186,7 @@ describe('createMegathreadListCommand', () => {
             expect(consoleErrorOutput.join('\n')).toContain('Network error');
         });
         it('handles non-Error exceptions', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockRejectedValue('String error');
             const command = createMegathreadListCommand();
             await expect(command.parseAsync(['--agent', 'test-agent'], { from: 'user' })).rejects.toThrow('process.exit(1)');
@@ -196,7 +196,7 @@ describe('createMegathreadListCommand', () => {
     });
     describe('works with different fixture agents', () => {
         it('works with empty-agent', async () => {
-            mockLoadCredentials.mockResolvedValue({ apiKey: 'test-api-key' });
+            mockLoadConfig.mockResolvedValue({ apiKey: 'test-api-key' });
             mockGetUnpredictedRounds.mockResolvedValue([]);
             const command = createMegathreadListCommand();
             await command.parseAsync(['--agent', 'empty-agent'], { from: 'user' });

package/dist/commands/start/commands/prediction.js

@@ -1,4 +1,4 @@
-import { credentialsPath, loadCredentials } from '@zhive/sdk';
+import { loadConfig } from '@zhive/sdk';
 import { HIVE_API_URL } from '../../../shared/config/constant.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { styled } from '../../shared/theme.js';
@@ -50,13 +50,12 @@ function getOutcomeStr(pred) {
         return `[WIN] +${pred.honey.toFixed(2)} Honey`;
     }
     if (pred.wax > 0) {
-        return `[WIN] +${pred.wax.toFixed(2)} Wax`;
+        return `[LOSS] +${pred.wax.toFixed(2)} Wax`;
     }
     return '[LOSS]';
 }
 export async function predictionSlashCommand(agentName, callbacks) {
-    const filePath = credentialsPath(agentName);
-    const credentials = await loadCredentials(filePath);
+    const credentials = await loadConfig();
     if (!credentials?.apiKey) {
         callbacks.onError?.('Agent not registered yet. Wait for agent to start.');
         return;

package/dist/commands/start/hooks/useChat.js

@@ -7,7 +7,6 @@ import { fetchRulesTool } from '../../../shared/agent/tools/fetch-rules.js';
 import { extractErrorMessage } from '../../../shared/agent/utils.js';
 import { loadAgentConfig } from '../../../shared/config/agent.js';
 import { getModel } from '../../../shared/config/ai-providers.js';
-import { backtestSlashCommand } from '../commands/backtest.js';
 import { predictionSlashCommand } from '../commands/prediction.js';
 import { skillsSlashCommand } from '../commands/skills.js';
 import { SLASH_COMMANDS } from '../services/command-registry.js';
@@ -73,46 +72,46 @@ export function useChat(agentName) {
                     const memoryOutput = memoryRef.current || 'No memory stored yet.';
                     addChatActivity({ type: 'chat-agent', text: memoryOutput });
                 },
-                '/backtest': async () => {
-                    const config = {
-                        agentPath: process.cwd(),
-                        soulContent: soulContentRef.current,
-                        strategyContent: strategyContentRef.current,
-                        agentName: agentName,
-                    };
-                    await backtestSlashCommand(parts.slice(1), config, {
-                        onFetchStart: (numThreads) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `Fetching ${numThreads} resolved threads...`,
-                            });
-                        },
-                        onFetchError: (error) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `API fetch failed (${error}), falling back to default dataset...`,
-                            });
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: 'Starting backtest against default dataset...',
-                            });
-                        },
-                        onThreadStart: (index, total, thread) => {
-                            addChatActivity({
-                                type: 'chat-agent',
-                                text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
-                            });
-                        },
-                        onBacktestSuccess: (report) => {
-                            addChatActivity({ type: 'chat-agent', text: report });
-                            sessionMessagesRef.current.push({ role: 'assistant', content: report });
-                        },
-                        onBacktestError: (err) => {
-                            const errMessage = extractErrorMessage(err);
-                            addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
-                        },
-                    });
-                },
+                // '/backtest': async () => {
+                //   const config: RunnerConfig = {
+                //     agentPath: process.cwd(),
+                //     soulContent: soulContentRef.current,
+                //     strategyContent: strategyContentRef.current,
+                //     agentName: agentName,
+                //   };
+                //   await backtestSlashCommand(parts.slice(1), config, {
+                //     onFetchStart: (numThreads) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `Fetching ${numThreads} resolved threads...`,
+                //       });
+                //     },
+                //     onFetchError: (error: string) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `API fetch failed (${error}), falling back to default dataset...`,
+                //       });
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: 'Starting backtest against default dataset...',
+                //       });
+                //     },
+                //     onThreadStart: (index, total, thread) => {
+                //       addChatActivity({
+                //         type: 'chat-agent',
+                //         text: `Processing ${index + 1}/${total}: ${thread.project_name}...`,
+                //       });
+                //     },
+                //     onBacktestSuccess: (report: string) => {
+                //       addChatActivity({ type: 'chat-agent', text: report });
+                //       sessionMessagesRef.current.push({ role: 'assistant', content: report });
+                //     },
+                //     onBacktestError: (err: unknown) => {
+                //       const errMessage = extractErrorMessage(err);
+                //       addChatActivity({ type: 'chat-error', text: `Backtest failed: ${errMessage}` });
+                //     },
+                //   });
+                // },
                 '/prediction': async () => {
                     await predictionSlashCommand(agentName, {
                         onFetchStart: () => {

package/dist/commands/start/services/command-registry.js

@@ -3,7 +3,7 @@ export const SLASH_COMMANDS = [
     { name: '/help', description: 'Show available commands' },
     { name: '/clear', description: 'Clear chat history' },
     { name: '/memory', description: 'Show current memory state' },
-    { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
+    // { name: '/backtest', description: 'Run agent against test set (/backtest <num> fetches from API)' },
     { name: '/prediction', description: 'Show your last 10 resolved predictions' },
 ];
 export function filterCommands(prefix) {

package/dist/index.js

@@ -9,6 +9,7 @@ import { createStartCommand } from './commands/start/commands/index.js';
 import { createStartAllCommand } from './commands/start-all/commands/index.js';
 import { createRunCommand } from './commands/run/commands/index.js';
 import { createMigrateTemplatesCommand } from './commands/migrate-templates/commands/index.js';
+import { createDoctorCommand } from './commands/doctor/commands/index.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 const program = new Command();
@@ -21,6 +22,7 @@ program.addCommand(createStartCommand());
 program.addCommand(createStartAllCommand());
 program.addCommand(createRunCommand());
 program.addCommand(createMigrateTemplatesCommand());
+program.addCommand(createDoctorCommand());
 // Show help with exit code 0 when no arguments provided
 const args = process.argv.slice(2);
 if (args.length === 0) {

package/dist/{agent → services/agent}/analysis.js

@@ -1,10 +1,10 @@
 import { generateText, Output, ToolLoopAgent } from 'ai';
 import { z } from 'zod';
-import { buildAnalystPrompt, buildMegathreadPrompt } from './prompt.js';
-import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT } from '@hive-org/sdk';
-import { buildMemoryExtractionPrompt } from './memory-prompt.js';
+import { buildAnalystPrompt, buildMegathreadPrompt } from './prompts/prompt.js';
+import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT, } from '@hive-org/sdk';
+import { buildMemoryExtractionPrompt } from './prompts/memory-prompt.js';
 import { stripCodeFences } from './helpers.js';
-import { getModel } from './model.js';
+import { getModel } from './helpers/model.js';
 // ─── Cache Helpers ─────────────────────────────────
 function cacheableSystem(content) {
     const message = {
@@ -146,7 +146,7 @@ export async function extractAndSaveMemory(sessionMessages) {
         const model = await getModel();
         const { text } = await generateText({
             model,
-            messages: [cacheableSystem(prompt.system), { role: 'user', content: prompt.prompt }],
+            prompt,
         });
         const cleaned = stripCodeFences(text);
         await saveMemory(cleaned);

package/dist/{load-agent-env.js → services/agent/env.js}

@@ -1,5 +1,5 @@
 import { readFileSync } from 'fs';
-import { AI_PROVIDER_ENV_VARS } from './ai-providers.js';
+import { AI_PROVIDER_ENV_VARS } from '../ai-providers.js';
 let _agentProviderKeys = new Set();
 /**
  * Provider env-var names declared in the agent's .env file.

package/dist/{agent → services/agent/helpers}/model.js

@@ -1,5 +1,5 @@
-import { AI_PROVIDERS } from '../ai-providers.js';
-import { getAgentProviderKeys } from '../load-agent-env.js';
+import { AI_PROVIDERS } from '../../ai-providers.js';
+import { getAgentProviderKeys } from '../env.js';
 const PROVIDERS = [
     {
         label: 'Anthropic',

package/dist/{agent → services/agent/prompts}/memory-prompt.js

@@ -1,9 +1,25 @@
 export function buildMemoryExtractionPrompt(context) {
     const { currentMemory, sessionMessages, lineCount } = context;
-    // ── System (static — cached by providers) ──
-    const system = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
+    let sessionSection = '';
+    if (sessionMessages.length > 0) {
+        const listed = sessionMessages
+            .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
+            .join('\n');
+        sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
+    }
+    const currentMemorySection = currentMemory.trim().length > 0
+        ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
+        : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
+    const consolidationNote = lineCount > 200
+        ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
+        : '';
+    const prompt = `You are an AI trading agent's memory system. Your job is to maintain conversational continuity between sessions with the agent's operator.
+${currentMemorySection}${consolidationNote}
+## Session Activity
+${sessionSection}
+## Instructions
 
-Review the session data and update the agent's MEMORY.md file. This memory is about **conversational continuity** — making the agent feel like it remembers past sessions with its operator.
+Review the session chat log above and update the agent's MEMORY.md file. This memory is about **conversational continuity** — making the agent feel like it remembers past sessions with its operator.
 
 Focus on extracting:
 1. **Topics discussed** — what subjects came up in conversation (e.g., "we talked about ETH gas fees", "operator asked about macro outlook")
@@ -25,23 +41,5 @@ Follow these rules:
 6. **Keep it under ~200 lines** — This file is injected into every prompt, so brevity matters.
 
 Output the complete updated MEMORY.md content. Start with \`# Memory\` as the top-level header. Output ONLY the markdown content, no code fences or explanation.`;
-    // ── Prompt (dynamic — changes every call) ──
-    let sessionSection = '';
-    if (sessionMessages.length > 0) {
-        const listed = sessionMessages
-            .map((m) => `${m.role === 'user' ? 'Operator' : 'Agent'}: ${m.content}`)
-            .join('\n');
-        sessionSection = `\n## Session Chat Log\n\n${listed}\n`;
-    }
-    const currentMemorySection = currentMemory.trim().length > 0
-        ? `\n## Current MEMORY.md\n\n\`\`\`markdown\n${currentMemory}\n\`\`\`\n`
-        : '\n## Current MEMORY.md\n\n(empty - this is a fresh agent)\n';
-    const consolidationNote = lineCount > 200
-        ? `\n**IMPORTANT: The current memory is ${lineCount} lines, exceeding the 200-line soft limit. Aggressively consolidate: merge related items, remove outdated or low-value entries, and keep only the most important context.**\n`
-        : '';
-    const prompt = `${currentMemorySection}${consolidationNote}
-## Session Activity
-${sessionSection}
-Update the MEMORY.md based on the session activity above.`;
-    return { system, prompt };
+    return prompt;
 }