@zhive/cli 0.6.4 → 0.6.6

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/shared/config/agent.js

@@ -1,3 +1,4 @@
+import { loadConfig } from '@zhive/sdk';
 import axios from 'axios';
 import fsExtra from 'fs-extra';
 import * as fs from 'fs/promises';
@@ -51,15 +52,16 @@ export async function loadAgentConfig(_agentDir) {
     const agentDir = _agentDir ?? process.cwd();
     const soulPath = join(agentDir, 'SOUL.md');
     const strategyPath = join(agentDir, 'STRATEGY.md');
+    const config = await loadConfig(_agentDir);
+    if (!config) {
+        throw new Error('Agent not registered');
+    }
     const soulContent = await loadMarkdownFile(soulPath);
     const strategyContent = await loadMarkdownFile(strategyPath);
-    const name = extractField(soulContent, /^#\s+Agent:\s+(.+)$/m);
-    if (name === null) {
-        throw new Error('Could not parse agent name from SOUL.md. Expected "# Agent: <name>" as the first heading.');
-    }
-    const avatarUrl = extractField(soulContent, /^## Avatar\s*\n+(https?:\/\/.+)$/m);
-    if (avatarUrl === null) {
-        throw new Error('Could not parse avatar URL from SOUL.md. Expected a valid URL under "## Avatar".');
+    const name = config.name;
+    const avatarUrl = config.avatarUrl;
+    if (!avatarUrl) {
+        throw new Error('Missing avatarUrl');
     }
     const bioRaw = extractField(soulContent, /^## Bio\s*\n+(.+)$/m);
     const bio = bioRaw ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "CLI for bootstrapping zHive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/xai": "^3.0.0",
     "@openrouter/ai-sdk-provider": "^0.4.0",
-    "@zhive/sdk": "^0.5.6",
+    "@zhive/sdk": "^0.5.7",
     "ai": "^6.0.71",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",