@hive-org/cli 0.0.6 → 0.0.7

package/dist/start/AgentProcessManager.js

@@ -0,0 +1,131 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+const FORCE_KILL_TIMEOUT_MS = 5_000;
+const SHUTDOWN_TIMEOUT_MS = 10_000;
+const ABSOLUTE_TIMEOUT_MS = FORCE_KILL_TIMEOUT_MS + 2_000;
+export class AgentProcessManager {
+    constructor() {
+        this._agents = new Map();
+        this._agentsDir = path.join(os.homedir(), '.hive', 'agents');
+    }
+    spawnAll(discovered) {
+        for (const agent of discovered) {
+            this._agents.set(agent.name, {
+                name: agent.name,
+                status: 'spawning',
+                exitCode: null,
+                child: null,
+            });
+            this._spawnPiped(agent.name);
+        }
+    }
+    getStates() {
+        const states = [];
+        for (const agent of this._agents.values()) {
+            states.push({
+                name: agent.name,
+                status: agent.status,
+                exitCode: agent.exitCode,
+            });
+        }
+        return states;
+    }
+    async stopAgent(name) {
+        const agent = this._agents.get(name);
+        if (!agent?.child) {
+            return;
+        }
+        const child = agent.child;
+        const exitPromise = new Promise((resolve) => {
+            if (child.exitCode !== null) {
+                resolve();
+                return;
+            }
+            child.on('exit', () => resolve());
+            // Absolute safety timeout in case SIGKILL is not enough
+            setTimeout(() => resolve(), ABSOLUTE_TIMEOUT_MS);
+        });
+        child.kill('SIGTERM');
+        const forceKillTimer = setTimeout(() => {
+            child.kill('SIGKILL');
+        }, FORCE_KILL_TIMEOUT_MS);
+        await exitPromise;
+        clearTimeout(forceKillTimer);
+        agent.child = null;
+    }
+    respawnPiped(name) {
+        const agent = this._agents.get(name);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'spawning';
+        agent.exitCode = null;
+        agent.child = null;
+        this._spawnPiped(name);
+    }
+    async shutdownAll() {
+        const children = [];
+        for (const agent of this._agents.values()) {
+            if (agent.child) {
+                children.push(agent.child);
+            }
+        }
+        if (children.length === 0) {
+            return;
+        }
+        const waitForAll = children.map((child) => new Promise((resolve) => {
+            if (child.exitCode !== null) {
+                resolve();
+                return;
+            }
+            child.on('exit', () => resolve());
+            // Absolute safety timeout
+            setTimeout(() => resolve(), SHUTDOWN_TIMEOUT_MS + 2_000);
+        }));
+        for (const child of children) {
+            child.kill('SIGTERM');
+        }
+        const forceKillTimer = setTimeout(() => {
+            for (const agent of this._agents.values()) {
+                if (agent.child && agent.child.exitCode === null) {
+                    agent.child.kill('SIGKILL');
+                }
+            }
+        }, SHUTDOWN_TIMEOUT_MS);
+        await Promise.all(waitForAll);
+        clearTimeout(forceKillTimer);
+    }
+    _spawnPiped(name) {
+        const agentDir = path.join(this._agentsDir, name);
+        const child = spawn('npm', ['start'], {
+            cwd: agentDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const agent = this._agents.get(name);
+        if (!agent) {
+            return;
+        }
+        agent.child = child;
+        // Transition to 'running' once the OS has spawned the process
+        child.on('spawn', () => {
+            if (agent.status === 'spawning') {
+                agent.status = 'running';
+            }
+        });
+        // Drain stdout/stderr to prevent buffer blocking
+        child.stdout?.resume();
+        child.stderr?.resume();
+        child.on('error', () => {
+            agent.status = 'errored';
+            agent.exitCode = null;
+            agent.child = null;
+        });
+        child.on('exit', (code) => {
+            const exitCode = code ?? 1;
+            agent.status = exitCode === 0 ? 'exited' : 'errored';
+            agent.exitCode = exitCode;
+            agent.child = null;
+        });
+    }
+}

package/dist/start/Dashboard.js

@@ -0,0 +1,88 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { colors, symbols, border } from '../theme.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 POLL_INTERVAL_MS = 1_000;
+const STOPPABLE = new Set(['running', 'spawning']);
+const STARTABLE = new Set(['exited', 'errored']);
+export function Dashboard({ manager }) {
+    const { exit } = useApp();
+    const [agents, setAgents] = useState(manager.getStates());
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setAgents(manager.getStates());
+        }, POLL_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [manager]);
+    // Clamp selectedIndex when agents list changes
+    useEffect(() => {
+        const maxIndex = Math.max(agents.length - 1, 0);
+        setSelectedIndex((prev) => Math.min(prev, maxIndex));
+    }, [agents.length]);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((prev) => {
+                const max = agents.length - 1;
+                return prev > 0 ? prev - 1 : max;
+            });
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((prev) => {
+                const max = agents.length - 1;
+                return prev < max ? prev + 1 : 0;
+            });
+        }
+        else if (_input === ' ' || key.return) {
+            const agent = agents[selectedIndex];
+            if (!agent) {
+                return;
+            }
+            if (STOPPABLE.has(agent.status)) {
+                void manager.stopAgent(agent.name);
+            }
+            else if (STARTABLE.has(agent.status)) {
+                manager.respawnPiped(agent.name);
+            }
+        }
+        else if (key.ctrl && _input === 'c') {
+            exit();
+        }
+    });
+    const runningCount = agents.filter((a) => a.status === 'running').length;
+    const spawningCount = agents.filter((a) => a.status === 'spawning').length;
+    const stoppedCount = agents.filter((a) => a.status === 'exited' || a.status === 'errored').length;
+    const statusParts = [];
+    if (runningCount > 0) {
+        statusParts.push(`${runningCount} running`);
+    }
+    if (spawningCount > 0) {
+        statusParts.push(`${spawningCount} starting`);
+    }
+    if (stoppedCount > 0) {
+        statusParts.push(`${stoppedCount} stopped`);
+    }
+    const statusLabel = statusParts.length > 0 ? statusParts.join(', ') : 'no agents running';
+    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, " ", agents.length, " agent", agents.length !== 1 ? 's' : '', ' ', border.horizontal, " ", statusLabel] })] }), agents.map((agent, index) => {
+                const isSelected = index === selectedIndex;
+                const statusColor = STATUS_COLORS[agent.status];
+                const statusSymbol = STATUS_SYMBOLS[agent.status];
+                const isAlive = agent.status === 'running' || agent.status === 'spawning';
+                const statusText = agent.status === 'exited' || agent.status === 'errored'
+                    ? `${agent.status} (${agent.exitCode})`
+                    : agent.status;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.honey : undefined, children: isSelected ? `${symbols.diamond} ` : '  ' }), _jsxs(Text, { color: statusColor, children: [statusSymbol, " "] }), _jsx(Text, { color: isAlive ? colors.white : colors.grayDim, children: agent.name.padEnd(20) }), _jsx(Text, { color: statusColor, children: statusText })] }, agent.name));
+            }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.grayDim, children: [symbols.arrow, " ", '\u2191\u2193', " navigate ", '  ', " space/enter stop/start ", '  ', " ctrl+c quit"] }) })] }));
+}

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,22 @@
+import React from 'react';
+import { render } from 'ink';
+import { showWelcome } from '../create/welcome.js';
+import { scanAgents } 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 manager = new AgentProcessManager();
+    manager.spawnAll(discovered);
+    const { waitUntilExit } = render(React.createElement(Dashboard, { manager }));
+    await waitUntilExit();
+    await manager.shutdownAll();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hive-org/cli",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "CLI for bootstrapping Hive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -10,7 +10,6 @@
   },
   "files": [
     "dist",
-    "templates",
     "README.md"
   ],
   "publishConfig": {
@@ -28,16 +27,18 @@
     "@ai-sdk/google": "^3.0.0",
     "@ai-sdk/openai": "^3.0.25",
     "@ai-sdk/xai": "^3.0.0",
-    "@hive-org/sdk": "^0.0.9",
+    "@hive-org/sdk": "^0.0.12",
     "@openrouter/ai-sdk-provider": "^0.4.0",
-    "ai": "^6.0.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",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/templates/analysis.ts

@@ -1,103 +0,0 @@
-import { openai } from '@ai-sdk/openai';
-import { generateText, Output } from 'ai';
-import { z } from 'zod';
-import type { Conviction, ThreadDto } from './hive/objects';
-import { buildAnalystPrompt } from './prompt';
-import type { BuildPromptOptions } from './prompt';
-import type { ChatMessage } from './chat-prompt';
-import { loadMemory, saveMemory, getMemoryLineCount, MEMORY_SOFT_LIMIT } from './hive/memory';
-import { buildMemoryExtractionPrompt } from './memory-prompt';
-import { stripCodeFences } from './helpers';
-
-// ─── Prediction Schema ──────────────────────────────
-
-export const predictionSchema = z.object({
-  skip: z
-    .boolean()
-    .describe(
-      'true if this signal is outside your expertise or you have no strong take. false if you want to comment.',
-    ),
-  summary: z
-    .string()
-    .min(1)
-    .max(280)
-    .nullable()
-    .describe(
-      'Your CT-style take on this signal. Short, punchy, in character. Think tweet, not essay. null if skipping.',
-    ),
-  conviction: z
-    .number()
-    .nullable()
-    .describe(
-      'Predicted percent price change over the next 3 hours, up to one decimal place. Use the FULL range based on signal strength: tiny signals ±0.1-1.0, moderate ±1.5-5.0, strong ±5.0-12.0, extreme ±12.0-25.0. Negative for bearish. 0 if neutral. null if skipping. VARY your predictions — do NOT default to the same number repeatedly.',
-    ),
-});
-
-type Prediction = z.infer<typeof predictionSchema>;
-
-// ─── Signal Analysis ────────────────────────────────
-
-export async function processSignalAndSummarize(
-  thread: ThreadDto,
-  recentComments: readonly string[],
-  memory: string,
-): Promise<{ skip: boolean; summary: string; conviction: Conviction }> {
-  const promptOptions: BuildPromptOptions = {
-    threadText: thread.text,
-    projectId: thread.project_id,
-    timestamp: thread.timestamp,
-    priceOnFetch: thread.price_on_fetch,
-    citations: thread.citations,
-    recentPosts: recentComments,
-    memory,
-  };
-  const prompt = await buildAnalystPrompt(promptOptions);
-
-  const { output } = await generateText({
-    model: openai('gpt-4o'),
-    output: Output.object({ schema: predictionSchema }),
-    prompt,
-  });
-
-  if (!output) {
-    return { skip: true, summary: '', conviction: 0 };
-  }
-
-  const prediction = output as Prediction;
-  const skip = prediction.skip ?? false;
-  const summary = prediction.summary ?? '';
-  const conviction: Conviction = prediction.conviction ?? 0;
-
-  return { skip, summary, conviction };
-}
-
-// ─── Memory Extraction ──────────────────────────────
-
-export async function extractAndSaveMemory(sessionMessages: ChatMessage[]): Promise<string | null> {
-  const currentMemory = await loadMemory();
-  const lineCount = getMemoryLineCount(currentMemory);
-
-  if (sessionMessages.length === 0 && lineCount <= MEMORY_SOFT_LIMIT) {
-    return null;
-  }
-
-  const prompt = buildMemoryExtractionPrompt({
-    currentMemory,
-    sessionMessages,
-    lineCount,
-  });
-
-  try {
-    const { text } = await generateText({
-      model: openai('gpt-4o'),
-      prompt,
-    });
-    const cleaned = stripCodeFences(text);
-    await saveMemory(cleaned);
-    return cleaned;
-  } catch (err: unknown) {
-    const raw = err instanceof Error ? err.message : String(err);
-    console.error(`[Memory] Failed to extract memory: ${raw.slice(0, 200)}`);
-    return null;
-  }
-}