@zhive/cli 0.5.0

package/dist/start/StartApp.js

@@ -0,0 +1,189 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+import { colors, symbols, border } from '../theme.js';
+import { scanAgents } from '../agents.js';
+const STATUS_COLORS = {
+    spawning: colors.honey,
+    running: colors.green,
+    exited: colors.grayDim,
+    errored: colors.red,
+};
+const STATUS_SYMBOLS = {
+    spawning: symbols.diamondOpen,
+    running: symbols.dot,
+    exited: '\u25CB', // ○
+    errored: symbols.cross,
+};
+const MAX_RECENT_LINES = 10;
+const FORCE_KILL_TIMEOUT_MS = 10_000;
+export function StartApp() {
+    const { exit } = useApp();
+    const [agents, setAgents] = useState([]);
+    const [recentLines, setRecentLines] = useState([]);
+    const [phase, setPhase] = useState('scanning');
+    const [error, setError] = useState(null);
+    const childrenRef = useRef(new Map());
+    const shuttingDownRef = useRef(false);
+    const lineIdRef = useRef(0);
+    const updateAgent = useCallback((name, update) => {
+        setAgents((prev) => prev.map((a) => (a.name === name ? { ...a, ...update } : a)));
+    }, []);
+    const pushRecentLine = useCallback((name, text) => {
+        const id = lineIdRef.current++;
+        setRecentLines((prev) => {
+            const next = [...prev, { id, name, text }];
+            if (next.length > MAX_RECENT_LINES) {
+                return next.slice(next.length - MAX_RECENT_LINES);
+            }
+            return next;
+        });
+    }, []);
+    const shutdown = useCallback(async () => {
+        if (shuttingDownRef.current) {
+            return;
+        }
+        shuttingDownRef.current = true;
+        setPhase('stopping');
+        const children = Array.from(childrenRef.current.values());
+        // Register exit listeners BEFORE sending signals to avoid race condition
+        const waitForAll = children.map((child) => new Promise((resolve) => {
+            if (child.exitCode !== null) {
+                resolve();
+                return;
+            }
+            child.on('exit', () => resolve());
+        }));
+        for (const child of children) {
+            child.kill('SIGTERM');
+        }
+        const forceKillTimer = setTimeout(() => {
+            for (const child of Array.from(childrenRef.current.values())) {
+                child.kill('SIGKILL');
+            }
+        }, FORCE_KILL_TIMEOUT_MS);
+        await Promise.all(waitForAll);
+        clearTimeout(forceKillTimer);
+        setPhase('done');
+        exit();
+    }, [exit]);
+    useInput((_input, key) => {
+        if (key.ctrl && _input === 'c') {
+            void shutdown();
+        }
+    });
+    const handleStreamData = useCallback((agentName, bufferRef) => {
+        return (chunk) => {
+            bufferRef.current += chunk.toString();
+            const lines = bufferRef.current.split('\n');
+            bufferRef.current = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.length === 0) {
+                    continue;
+                }
+                updateAgent(agentName, { status: 'running', lastLine: trimmed });
+                pushRecentLine(agentName, trimmed);
+            }
+        };
+    }, [updateAgent, pushRecentLine]);
+    useEffect(() => {
+        const run = async () => {
+            try {
+                const discovered = await scanAgents();
+                if (discovered.length === 0) {
+                    setError('No agents found in ~/.hive/agents/');
+                    setPhase('done');
+                    exit();
+                    return;
+                }
+                const agentsDir = path.join(os.homedir(), '.hive', 'agents');
+                const initial = discovered.map((a) => ({
+                    name: a.name,
+                    status: 'spawning',
+                    exitCode: null,
+                    lastLine: '',
+                }));
+                setAgents(initial);
+                setPhase('running');
+                for (const agent of discovered) {
+                    const agentDir = path.join(agentsDir, agent.name);
+                    const child = spawn('npm', ['start'], {
+                        cwd: agentDir,
+                        stdio: 'pipe',
+                    });
+                    childrenRef.current.set(agent.name, child);
+                    const stdoutBuffer = { current: '' };
+                    const stderrBuffer = { current: '' };
+                    child.stdout?.on('data', handleStreamData(agent.name, stdoutBuffer));
+                    child.stderr?.on('data', handleStreamData(agent.name, stderrBuffer));
+                    child.on('error', (err) => {
+                        updateAgent(agent.name, { status: 'errored', lastLine: err.message });
+                        childrenRef.current.delete(agent.name);
+                    });
+                    child.on('exit', (code) => {
+                        // Flush remaining buffered output
+                        const remainingStdout = stdoutBuffer.current.trim();
+                        if (remainingStdout.length > 0) {
+                            pushRecentLine(agent.name, remainingStdout);
+                        }
+                        const remainingStderr = stderrBuffer.current.trim();
+                        if (remainingStderr.length > 0) {
+                            pushRecentLine(agent.name, remainingStderr);
+                        }
+                        const exitCode = code ?? 1;
+                        const status = exitCode === 0 ? 'exited' : 'errored';
+                        updateAgent(agent.name, { status, exitCode });
+                        childrenRef.current.delete(agent.name);
+                        if (childrenRef.current.size === 0 && !shuttingDownRef.current) {
+                            setPhase('done');
+                            exit();
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                setError(`Failed to scan agents: ${message}`);
+                setPhase('done');
+                exit();
+            }
+        };
+        void run();
+        return () => {
+            void shutdown();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(Text, { color: colors.red, children: error })] }), _jsxs(Text, { color: colors.gray, children: ["Create agents with: ", _jsx(Text, { color: colors.white, children: "npx @hive-org/cli@latest create" })] })] }));
+    }
+    if (phase === 'scanning') {
+        return (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: colors.gray, children: "Scanning agents..." }) }));
+    }
+    const runningCount = agents.filter((a) => a.status === 'running').length;
+    const spawningCount = agents.filter((a) => a.status === 'spawning').length;
+    const nameWidth = Math.max(16, ...agents.map((a) => a.name.length + 2));
+    const statusLabel = phase === 'stopping'
+        ? 'shutting down...'
+        : `${runningCount} running${spawningCount > 0 ? `, ${spawningCount} starting` : ''}`;
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: colors.honey, children: [symbols.hive, " "] }), _jsx(Text, { color: colors.white, bold: true, children: "Hive Swarm" }), _jsxs(Text, { color: colors.gray, children: [" ", border.horizontal, " ", statusLabel] })] }), agents.map((agent) => {
+                const statusColor = STATUS_COLORS[agent.status];
+                const statusSymbol = STATUS_SYMBOLS[agent.status];
+                const statusText = agent.status === 'exited' || agent.status === 'errored'
+                    ? `${agent.status} (${agent.exitCode})`
+                    : agent.status;
+                const truncatedLine = agent.lastLine.length > 60
+                    ? agent.lastLine.slice(0, 57) + '...'
+                    : agent.lastLine;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: statusColor, children: `  ${statusSymbol} ` }), _jsx(Text, { color: colors.white, children: agent.name.padEnd(nameWidth) }), _jsx(Text, { color: statusColor, children: statusText.padEnd(12) }), _jsx(Text, { color: colors.grayDim, children: truncatedLine })] }, agent.name));
+            }), recentLines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: colors.grayDim, children: [border.horizontal.repeat(3), " Recent Activity ", border.horizontal.repeat(3)] }) }), recentLines.map((line) => {
+                        const truncatedText = line.text.length > 60
+                            ? line.text.slice(0, 57) + '...'
+                            : line.text;
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: ['  ', line.name.padEnd(nameWidth)] }), _jsxs(Text, { color: colors.grayDim, children: [border.vertical, " "] }), _jsx(Text, { color: colors.gray, children: truncatedText })] }, line.id));
+                    })] })), phase === 'stopping' && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.honey, children: "Sending SIGTERM to all agents..." }) }))] }));
+}

package/dist/start/patch-headless.js

@@ -0,0 +1,101 @@
+import fs from 'fs-extra';
+import path from 'path';
+const HEADLESS_MARKER = 'Input Bar — only when stdin is a real TTY';
+/**
+ * Patches an agent's index.tsx so that TextInput is only rendered when
+ * stdin is a real TTY.  Without this, Ink's setRawMode(true) throws
+ * when the agent is spawned with piped stdio.
+ *
+ * Idempotent — skips if already patched.
+ */
+export async function ensureHeadlessSupport(agentDir) {
+    const filePath = path.join(agentDir, 'index.tsx');
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return;
+    }
+    let content = await fs.readFile(filePath, 'utf-8');
+    let dirty = false;
+    // 1. Ensure isInteractive flag exists after useAgent() destructuring
+    const INTERACTIVE_DECL = 'const isInteractive = process.stdin.isTTY === true;';
+    if (!content.includes(INTERACTIVE_DECL)) {
+        const useAgentClose = '} = useAgent();';
+        const hookInsertIndex = content.indexOf(useAgentClose);
+        if (hookInsertIndex === -1) {
+            return;
+        }
+        const insertAfter = hookInsertIndex + useAgentClose.length;
+        const interactiveFlag = `\n\n  // When stdin is not a TTY (piped by hive-cli start), skip interactive input\n  ${INTERACTIVE_DECL}`;
+        content = content.slice(0, insertAfter) + interactiveFlag + content.slice(insertAfter);
+        dirty = true;
+    }
+    // 2. Wrap TextInput in isInteractive guard (if not already done)
+    if (content.includes(HEADLESS_MARKER)) {
+        // Input Bar already replaced — just write if we added the variable
+        if (dirty) {
+            await fs.writeFile(filePath, content, 'utf-8');
+        }
+        return;
+    }
+    if (!content.includes('<TextInput')) {
+        if (dirty) {
+            await fs.writeFile(filePath, content, 'utf-8');
+        }
+        return;
+    }
+    const inputBarStart = content.indexOf('{/* Input Bar */}');
+    if (inputBarStart === -1) {
+        if (dirty) {
+            await fs.writeFile(filePath, content, 'utf-8');
+        }
+        return;
+    }
+    // Find the closing </Box> of the bottom border (3 Box elements after Input Bar comment)
+    let pos = inputBarStart;
+    let boxCloseCount = 0;
+    const boxCloseTag = '</Box>';
+    while (boxCloseCount < 3 && pos < content.length) {
+        const nextClose = content.indexOf(boxCloseTag, pos);
+        if (nextClose === -1) {
+            break;
+        }
+        pos = nextClose + boxCloseTag.length;
+        boxCloseCount++;
+    }
+    if (boxCloseCount === 3) {
+        const inputBarEnd = pos;
+        const replacement = `{/* Input Bar — only when stdin is a real TTY */}
+      <Box>
+        <Text color="gray">
+          {isInteractive ? border.teeLeft : border.bottomLeft}
+          {border.horizontal.repeat(boxWidth - 2)}
+          {isInteractive ? border.teeRight : border.bottomRight}
+        </Text>
+      </Box>
+      {isInteractive && (
+        <>
+          <Box paddingLeft={1}>
+            <Text color={colors.honey}>{symbols.arrow} </Text>
+            <TextInput
+              value={input}
+              onChange={setInput}
+              onSubmit={(val) => {
+                setInput('');
+                void handleChatSubmit(val);
+              }}
+              placeholder={chatStreaming ? 'thinking...' : \`chat with \${agentName} agent...\`}
+            />
+          </Box>
+          <Box>
+            <Text color="gray">
+              {border.bottomLeft}
+              {border.horizontal.repeat(boxWidth - 2)}
+              {border.bottomRight}
+            </Text>
+          </Box>
+        </>
+      )}`;
+        content = content.slice(0, inputBarStart) + replacement + content.slice(inputBarEnd);
+    }
+    await fs.writeFile(filePath, content, 'utf-8');
+}

package/dist/start/patch-managed-mode.js

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.resolve(__dirname, '../../templates');
+const MANAGED_MARKER = 'HIVE_MANAGED';
+const INTERACTIVE_GUARD_MARKER = 'Input Bar — only when stdin is a real TTY';
+/**
+ * Patches an existing agent to support:
+ * 1. Headless mode — skip TextInput when stdin is not a TTY (piped by dashboard)
+ * 2. Managed mode — Escape exits back to dashboard when HIVE_MANAGED=1
+ *
+ * Idempotent — skips if already patched.
+ */
+export async function ensureManagedMode(agentDir) {
+    await patchProcessLifecycle(agentDir);
+    await patchIndexTsx(agentDir);
+}
+async function patchProcessLifecycle(agentDir) {
+    const filePath = path.join(agentDir, 'process-lifecycle.ts');
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return;
+    }
+    const content = await fs.readFile(filePath, 'utf-8');
+    // Already patched if gracefulShutdown is exported
+    if (content.includes('export const gracefulShutdown')) {
+        return;
+    }
+    // Copy the template version (it has the export + exitCode param)
+    const templatePath = path.join(TEMPLATES_DIR, 'process-lifecycle.ts');
+    const templateExists = await fs.pathExists(templatePath);
+    if (!templateExists) {
+        return;
+    }
+    await fs.copyFile(templatePath, filePath);
+}
+async function patchIndexTsx(agentDir) {
+    const filePath = path.join(agentDir, 'index.tsx');
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        return;
+    }
+    let content = await fs.readFile(filePath, 'utf-8');
+    // Already fully patched
+    if (content.includes(MANAGED_MARKER) && content.includes(INTERACTIVE_GUARD_MARKER)) {
+        return;
+    }
+    // 1. Add useInput to ink import if not present
+    //    Existing pattern: "import { render, Box, Text } from 'ink';"
+    //    Target:           "import { render, Box, Text, useInput } from 'ink';"
+    if (!content.includes('useInput')) {
+        content = content.replace(/\s*}\s*from\s*'ink'/, ", useInput } from 'ink'");
+    }
+    // 2. Add gracefulShutdown import from process-lifecycle if not present
+    if (!content.includes('gracefulShutdown')) {
+        content = content.replace(/import\s*\{\s*setupProcessLifecycle\s*\}\s*from\s*'\.\/process-lifecycle'/, "import { setupProcessLifecycle, gracefulShutdown } from './process-lifecycle'");
+    }
+    // 3. Add isInteractive + managed mode hooks after useAgent() destructuring
+    if (!content.includes(MANAGED_MARKER)) {
+        const useAgentClose = '} = useAgent();';
+        const hookInsertIndex = content.indexOf(useAgentClose);
+        if (hookInsertIndex === -1) {
+            return;
+        }
+        const insertAfter = hookInsertIndex + useAgentClose.length;
+        const hooks = `
+
+  // When stdin is not a TTY (piped by hive-cli start), skip interactive input
+  const isInteractive = process.stdin.isTTY === true;
+
+  // When managed by hive-cli start, Escape exits back to dashboard
+  const isManaged = process.env.HIVE_MANAGED === '1';
+
+  useInput((_input, key) => {
+    if (isManaged && key.escape) {
+      void gracefulShutdown(0);
+    }
+  }, { isActive: isManaged });`;
+        content = content.slice(0, insertAfter) + hooks + content.slice(insertAfter);
+    }
+    // 4. Wrap TextInput in isInteractive guard
+    //    Replace the input bar section to conditionally render TextInput
+    if (!content.includes(INTERACTIVE_GUARD_MARKER) && content.includes('<TextInput')) {
+        // Find the Input Bar comment and replace the entire block
+        const inputBarStart = content.indexOf('{/* Input Bar */}');
+        if (inputBarStart === -1) {
+            // Fallback: just wrap the TextInput line
+            await fs.writeFile(filePath, content, 'utf-8');
+            return;
+        }
+        // Find the closing </Box> of the bottom border (3 Box elements after Input Bar comment)
+        // Pattern: <Box> separator </Box> <Box> TextInput </Box> <Box> bottom border </Box>
+        let pos = inputBarStart;
+        let boxCloseCount = 0;
+        const boxCloseTag = '</Box>';
+        while (boxCloseCount < 3 && pos < content.length) {
+            const nextClose = content.indexOf(boxCloseTag, pos);
+            if (nextClose === -1) {
+                break;
+            }
+            pos = nextClose + boxCloseTag.length;
+            boxCloseCount++;
+        }
+        if (boxCloseCount === 3) {
+            const inputBarEnd = pos;
+            const replacement = `{/* Input Bar — only when stdin is a real TTY */}
+      <Box>
+        <Text color="gray">
+          {isInteractive ? border.teeLeft : border.bottomLeft}
+          {border.horizontal.repeat(boxWidth - 2)}
+          {isInteractive ? border.teeRight : border.bottomRight}
+        </Text>
+      </Box>
+      {isInteractive && (
+        <>
+          <Box paddingLeft={1}>
+            <Text color={colors.honey}>{symbols.arrow} </Text>
+            <TextInput
+              value={input}
+              onChange={setInput}
+              onSubmit={(val) => {
+                setInput('');
+                void handleChatSubmit(val);
+              }}
+              placeholder={chatStreaming ? 'thinking...' : \`chat with \${agentName} agent...\`}
+            />
+          </Box>
+          <Box>
+            <Text color="gray">
+              {border.bottomLeft}
+              {border.horizontal.repeat(boxWidth - 2)}
+              {border.bottomRight}
+            </Text>
+          </Box>
+        </>
+      )}`;
+            content = content.slice(0, inputBarStart) + replacement + content.slice(inputBarEnd);
+        }
+    }
+    await fs.writeFile(filePath, content, 'utf-8');
+}

package/dist/start/start-command.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { render } from 'ink';
+import { showWelcome } from '../create/welcome.js';
+import { scanAgents, fetchBulkStats, sortAgentsByHoney } from '../agents.js';
+import { symbols, styled } from '../theme.js';
+import { AgentProcessManager } from './AgentProcessManager.js';
+import { Dashboard } from './Dashboard.js';
+export async function startCommand() {
+    // Run welcome animation and scan agents in parallel
+    const results = await Promise.all([showWelcome(), scanAgents()]);
+    const discovered = results[1];
+    if (discovered.length === 0) {
+        console.log(`\n  ${styled.honey(symbols.hive)} ${styled.red('No agents found in ~/.hive/agents/')}\n`);
+        console.log(`  ${styled.gray('Create agents with:')} ${styled.white('npx @hive-org/cli@latest create')}\n`);
+        return;
+    }
+    const names = discovered.map((a) => a.name);
+    const statsMap = await fetchBulkStats(names);
+    const sortedDiscovered = sortAgentsByHoney(discovered, statsMap);
+    const manager = new AgentProcessManager();
+    manager.spawnAll(sortedDiscovered);
+    const { waitUntilExit } = render(React.createElement(Dashboard, { manager, statsMap }));
+    await waitUntilExit();
+}

package/dist/theme.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+export const colors = {
+    honey: '#F5A623',
+    honeyDark: '#D4891A',
+    honeyBright: '#FFD700',
+    white: '#FFFFFF',
+    gray: '#A6A6A6',
+    grayDim: '#555555',
+    green: '#27C587',
+    red: '#E14B4B',
+    wax: '#C45C5C',
+    cyan: '#22D3EE',
+    hot: '#FB923C',
+    controversial: '#C084FC',
+};
+export const symbols = {
+    hive: '\u2B21', // ⬡
+    diamond: '\u25C6', // ◆
+    diamondOpen: '\u25C7', // ◇
+    dot: '\u25CF', // ●
+    spinner: ['\u25D0', '\u25D3', '\u25D1', '\u25D2'], // ◐ ◓ ◑ ◒
+    check: '\u2713', // ✓
+    cross: '\u2717', // ✗
+    arrow: '\u203A', // ›
+};
+export const border = {
+    horizontal: '\u2500', // ─
+    vertical: '\u2502', // │
+    topLeft: '\u250C', // ┌
+    topRight: '\u2510', // ┐
+    bottomLeft: '\u2514', // └
+    bottomRight: '\u2518', // ┘
+    teeLeft: '\u251C', // ├
+    teeRight: '\u2524', // ┤
+};
+export const animation = {
+    DATA_CHARS: '01▪▫░▒',
+    HEX_CHARS: '⬡⬢',
+    TICK_MS: 120,
+};
+export const styled = {
+    honey: (text) => chalk.hex(colors.honey)(text),
+    honeyBold: (text) => chalk.hex(colors.honey).bold(text),
+    white: (text) => chalk.white(text),
+    whiteBold: (text) => chalk.bold.white(text),
+    gray: (text) => chalk.gray(text),
+    dim: (text) => chalk.hex(colors.grayDim)(text),
+    green: (text) => chalk.hex(colors.green)(text),
+    red: (text) => chalk.hex(colors.red)(text),
+    wax: (text) => chalk.hex(colors.wax)(text),
+    cyan: (text) => chalk.hex(colors.cyan)(text),
+    hot: (text) => chalk.hex(colors.hot)(text),
+    controversial: (text) => chalk.hex(colors.controversial)(text),
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@zhive/cli",
+  "version": "0.5.0",
+  "description": "CLI for bootstrapping Hive AI Agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "hive-cli": "dist/index.js",
+    "cli": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/index.tsx",
+    "start": "node dist/index.js",
+    "deploy": "node scripts/deploy.cjs",
+    "analyze": "tsx src/sandbox/analyze.ts",
+    "prepublishOnly": "pnpm run build",
+    "test": "vitest --run --passWithNoTests"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@ai-sdk/devtools": "^0.0.15",
+    "@ai-sdk/google": "^3.0.0",
+    "@ai-sdk/openai": "^3.0.25",
+    "@ai-sdk/xai": "^3.0.0",
+    "@zhive/sdk": "^0.5.0",
+    "@openrouter/ai-sdk-provider": "^0.4.0",
+    "ai": "^6.0.71",
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "dotenv": "^16.0.0",
+    "fs-extra": "^11.2.0",
+    "ink": "^5.1.0",
+    "ink-select-input": "^6.0.0",
+    "ink-text-input": "^6.0.0",
+    "langsmith": "^0.5.7",
+    "react": "^18.3.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.0",
+    "@types/react": "^18.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "hive",
+    "ai-agent",
+    "trading",
+    "cli",
+    "scaffold"
+  ],
+  "author": "zhive",
+  "license": "GPL-3.0"
+}