@zhive/cli 0.6.0 → 0.6.1

package/dist/commands/start/ui/PollText.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+export function TypewriterText({ text, color, speed = 25, }) {
+    const [visible, setVisible] = useState(0);
+    useEffect(() => {
+        if (visible >= text.length)
+            return;
+        const timer = setTimeout(() => {
+            setVisible((prev) => Math.min(prev + 2, text.length));
+        }, speed);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [visible, text, speed]);
+    return _jsx(Text, { color: color, children: text.slice(0, visible) });
+}
+export function PollText({ text, color, animate, }) {
+    if (animate) {
+        return _jsx(TypewriterText, { text: text, color: color });
+    }
+    return _jsx(Text, { color: color, children: text });
+}

package/dist/commands/start/ui/PredictionsPanel.js

@@ -0,0 +1,88 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { border, colors, symbols } from '../../shared/theme.js';
+function formatCountdown(ms) {
+    if (ms < 0)
+        return 'expired';
+    const totalMinutes = Math.floor(ms / 60_000);
+    if (totalMinutes < 1)
+        return '<1m';
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours >= 1)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+function isPredictionResolved(prediction, now) {
+    const resolvedAt = new Date(prediction.resolved_at);
+    return resolvedAt <= now;
+}
+function formatPredictionRow(prediction, now) {
+    const resolved = isPredictionResolved(prediction, now);
+    const sign = prediction.conviction >= 0 ? '+' : '';
+    const convictionStr = `${sign}${prediction.conviction.toFixed(2)}%`;
+    const project = `c/${prediction.project_id}`;
+    if (!resolved) {
+        const resolvedAt = new Date(prediction.resolved_at);
+        const remainingMs = resolvedAt.getTime() - now.getTime();
+        const countdown = formatCountdown(remainingMs);
+        return `${symbols.diamondOpen} ${project}  ${convictionStr}  pending ${countdown}`;
+    }
+    if (prediction.honey > 0) {
+        return `${symbols.check} ${project}  ${convictionStr}  +${prediction.honey.toFixed(2)} honey`;
+    }
+    if (prediction.wax > 0) {
+        return `${symbols.cross} ${project}  ${convictionStr}  ${prediction.wax.toFixed(2)} wax`;
+    }
+    return `${symbols.diamond} ${project}  ${convictionStr}  resolved`;
+}
+function getRowColor(prediction, now) {
+    const resolved = isPredictionResolved(prediction, now);
+    if (!resolved)
+        return colors.white;
+    if (prediction.honey > 0)
+        return colors.green;
+    if (prediction.wax > 0)
+        return colors.wax;
+    return colors.gray;
+}
+export function PredictionsPanel({ predictions, loading, hasMore, onExit, onLoadMore, termWidth, }) {
+    const [scrollOffset, setScrollOffset] = useState(0);
+    // Reserve lines: header(1) + padding(1) + footer separator(1) + footer text(1) + bottom border(1)
+    const chromeLines = 5;
+    const visibleRows = Math.max(1, (process.stdout.rows || 20) - 12 - chromeLines);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+            return;
+        }
+        if (key.upArrow) {
+            setScrollOffset((prev) => Math.max(0, prev - 1));
+        }
+        if (key.downArrow) {
+            const maxOffset = Math.max(0, predictions.length - visibleRows);
+            setScrollOffset((prev) => Math.min(maxOffset, prev + 1));
+        }
+    });
+    // Infinite scroll: trigger load when near bottom
+    useEffect(() => {
+        const threshold = 3;
+        const nearBottom = scrollOffset + visibleRows >= predictions.length - threshold;
+        if (nearBottom && hasMore && !loading) {
+            void onLoadMore();
+        }
+    }, [scrollOffset, predictions.length, hasMore, loading, onLoadMore, visibleRows]);
+    const boxWidth = termWidth;
+    const innerWidth = boxWidth - 4;
+    const now = new Date();
+    const visiblePredictions = predictions.slice(scrollOffset, scrollOffset + visibleRows);
+    const countLabel = `${predictions.length} loaded`;
+    const titleText = ` ${symbols.hive} Predictions `;
+    const titleFill = Math.max(0, boxWidth - titleText.length - countLabel.length - 6);
+    return (_jsxs(Box, { flexDirection: "column", width: boxWidth, children: [_jsxs(Box, { children: [_jsxs(Text, { color: colors.honey, children: [border.topLeft, border.horizontal] }), _jsx(Text, { color: colors.honey, bold: true, children: titleText }), _jsxs(Text, { color: colors.gray, children: [border.horizontal.repeat(2), " ", countLabel, " ", border.horizontal.repeat(titleFill), border.topRight] })] }), _jsxs(Box, { flexDirection: "column", paddingLeft: 2, paddingRight: 2, minHeight: visibleRows, children: [predictions.length === 0 && !loading && (_jsx(Box, { children: _jsx(Text, { color: colors.gray, children: "No predictions yet." }) })), visiblePredictions.map((prediction) => {
+                        const row = formatPredictionRow(prediction, now);
+                        const rowColor = getRowColor(prediction, now);
+                        return (_jsx(Box, { children: _jsx(Text, { color: rowColor, wrap: "truncate", children: row.length > innerWidth ? row.slice(0, innerWidth) : row }) }, prediction.id));
+                    }), loading && (_jsx(Box, { children: _jsx(Text, { color: colors.honey, children: "Loading..." }) }))] }), _jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: [border.teeLeft, border.horizontal.repeat(boxWidth - 2), border.teeRight] }) }), _jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: colors.gray, children: ['\u2191\u2193', " scroll ", symbols.circle, " esc exit"] }) }), _jsx(Box, { children: _jsxs(Text, { color: colors.gray, children: [border.bottomLeft, border.horizontal.repeat(boxWidth - 2), border.bottomRight] }) })] }));
+}

package/dist/commands/start/ui/SpinnerContext.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+export const SPINNER_FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2'];
+const SPINNER_INTERVAL_MS = 200;
+const SpinnerContext = createContext(0);
+export function SpinnerProvider({ children }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame((prev) => (prev + 1) % SPINNER_FRAMES.length);
+        }, SPINNER_INTERVAL_MS);
+        return () => {
+            clearInterval(timer);
+        };
+    }, []);
+    return _jsx(SpinnerContext.Provider, { value: frame, children: children });
+}
+export function useSpinnerFrame() {
+    return useContext(SpinnerContext);
+}

package/dist/components/InputGuard.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+const defaultRef = { current: false };
+export const InputGuardContext = createContext(defaultRef);
+export function useInputGuard() {
+    return useContext(InputGuardContext);
+}

package/dist/components/stdout-spinner.js

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+const FRAMES = ['\u25D0', '\u25D3', '\u25D1', '\u25D2']; // ◐ ◓ ◑ ◒
+const INTERVAL_MS = 200;
+const HONEY_ANSI = '\x1b[38;2;245;166;35m';
+const RESET_ANSI = '\x1b[0m';
+let _frame = 0;
+let _timer = null;
+const _entries = new Map();
+let _nextId = 0;
+function rawWrite(data) {
+    try {
+        fs.writeSync(process.stdout.fd, data);
+    }
+    catch {
+        // Ignore write errors (non-TTY, closed fd, etc.)
+    }
+}
+function tick() {
+    _frame = (_frame + 1) % FRAMES.length;
+    const char = `${HONEY_ANSI}${FRAMES[_frame]}${RESET_ANSI}`;
+    for (const getPosition of _entries.values()) {
+        const pos = getPosition();
+        if (!pos || pos.linesFromBottom <= 0)
+            continue;
+        rawWrite('\x1b7'); // Save cursor (DEC)
+        rawWrite(`\x1b[${pos.linesFromBottom}A`); // Move up N lines
+        rawWrite(`\x1b[${pos.col + 1}G`); // Move to column (1-indexed)
+        rawWrite(char);
+        rawWrite('\x1b8'); // Restore cursor (DEC)
+    }
+}
+export function register(getPosition) {
+    const id = _nextId++;
+    _entries.set(id, getPosition);
+    if (!_timer) {
+        _timer = setInterval(tick, INTERVAL_MS);
+    }
+    return id;
+}
+export function unregister(id) {
+    _entries.delete(id);
+    if (_entries.size === 0 && _timer) {
+        clearInterval(_timer);
+        _timer = null;
+        _frame = 0;
+    }
+}
+export { FRAMES };

package/dist/{services/config/config.js → config.js}

@@ -1,6 +1,12 @@
 import fs from 'fs-extra';
 import path from 'path';
-import { getHiveDir } from './constant.js';
+import os from 'os';
+export const HIVE_API_URL = 'https://api.zhive.ai';
+export const HIVE_FRONTEND_URL = 'https://www.zhive.ai';
+export function getHiveDir() {
+    const hiveDir = path.join(os.homedir(), '.hive');
+    return hiveDir;
+}
 export async function readConfig() {
     try {
         const configPath = path.join(getHiveDir(), 'config.json');

package/dist/create/CreateApp.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { Header } from '../components/Header.js';
+import { AsciiTicker } from '../components/AsciiTicker.js';
+import { StepIndicator } from '../components/StepIndicator.js';
+import { ApiKeyStep } from './steps/ApiKeyStep.js';
+import { NameStep } from './steps/NameStep.js';
+import { IdentityStep } from './steps/IdentityStep.js';
+import { AvatarStep } from './steps/AvatarStep.js';
+import { SoulStep } from './steps/SoulStep.js';
+import { StrategyStep } from './steps/StrategyStep.js';
+import { ScaffoldStep } from './steps/ScaffoldStep.js';
+import { DoneStep } from './steps/DoneStep.js';
+import { colors, symbols } from '../theme.js';
+import { getProvider } from '../ai-providers.js';
+function ensureAvatarUrl(content, avatarUrl) {
+    const lines = content.split('\n');
+    const avatarIdx = lines.findIndex((l) => /^## Avatar/.test(l));
+    if (avatarIdx === -1) {
+        return content;
+    }
+    // Find the next section header after ## Avatar
+    let nextSectionIdx = lines.length;
+    for (let i = avatarIdx + 1; i < lines.length; i++) {
+        if (/^##?\s/.test(lines[i])) {
+            nextSectionIdx = i;
+            break;
+        }
+    }
+    // Replace the content between ## Avatar and next section with the raw URL
+    const before = lines.slice(0, avatarIdx + 1);
+    const after = lines.slice(nextSectionIdx);
+    const result = [...before, '', avatarUrl, '', ...after];
+    return result.join('\n');
+}
+function ensureSectionLine(content, sectionHeader, linePrefix, value) {
+    const lines = content.split('\n');
+    const sectionIdx = lines.findIndex((l) => new RegExp(`^##\\s+${sectionHeader}`).test(l));
+    if (sectionIdx === -1) {
+        // Section missing — append it at the end
+        return content + `\n\n## ${sectionHeader}\n\n${linePrefix} ${value}\n`;
+    }
+    // Find the next section header after this one
+    let nextSectionIdx = lines.length;
+    for (let i = sectionIdx + 1; i < lines.length; i++) {
+        if (/^##?\s/.test(lines[i])) {
+            nextSectionIdx = i;
+            break;
+        }
+    }
+    // Look for existing line with the prefix in this section
+    const prefixRegex = new RegExp(`^${linePrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s`);
+    const lineIdx = lines.findIndex((l, i) => i > sectionIdx && i < nextSectionIdx && prefixRegex.test(l));
+    if (lineIdx !== -1) {
+        // Replace the existing line
+        lines[lineIdx] = `${linePrefix} ${value}`;
+    }
+    else {
+        // Insert after the section header (skip blank lines)
+        let insertIdx = sectionIdx + 1;
+        while (insertIdx < nextSectionIdx && lines[insertIdx].trim() === '') {
+            insertIdx++;
+        }
+        lines.splice(insertIdx, 0, `${linePrefix} ${value}`);
+    }
+    return lines.join('\n');
+}
+function ensureStrategyFields(content, sectors, sentiment, timeframes) {
+    const sectorsLine = sectors.length > 0 ? sectors.join(', ') : 'all categories';
+    const timeframesLine = timeframes.length > 0 ? timeframes.join(', ') : '1h, 4h, 24h';
+    let patched = ensureSectionLine(content, 'Sentiment', '- Bias:', sentiment);
+    patched = ensureSectionLine(patched, 'Sector Focus', '- Sectors:', sectorsLine);
+    patched = ensureSectionLine(patched, 'Timeframe', '- Active timeframes:', timeframesLine);
+    return patched;
+}
+const STEP_ORDER = ['name', 'identity', 'avatar', 'api-key', 'soul', 'strategy', 'scaffold', 'done'];
+const STEP_LABELS = {
+    'api-key': 'API Key',
+    'name': 'Name',
+    'identity': 'Identity',
+    'avatar': 'Avatar',
+    'soul': 'Soul',
+    'strategy': 'Strategy',
+    'scaffold': 'Scaffold',
+    'done': 'Done',
+};
+const STEP_DEFS = STEP_ORDER.map((s) => ({ key: s, label: STEP_LABELS[s] }));
+export function CreateApp({ initialName }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState(initialName ? 'identity' : 'name');
+    const [providerId, setProviderId] = useState(null);
+    const [apiKey, setApiKey] = useState('');
+    const [agentName, setAgentName] = useState(initialName ?? '');
+    const [bio, setBio] = useState('');
+    const [personality, setPersonality] = useState('');
+    const [tone, setTone] = useState('');
+    const [voiceStyle, setVoiceStyle] = useState('');
+    const [tradingStyle, setTradingStyle] = useState('');
+    const [sectors, setSectors] = useState([]);
+    const [sentiment, setSentiment] = useState('');
+    const [timeframes, setTimeframes] = useState([]);
+    const [avatarUrl, setAvatarUrl] = useState('');
+    const [soulContent, setSoulContent] = useState('');
+    const [strategyContent, setStrategyContent] = useState('');
+    const [resolvedProjectDir, setResolvedProjectDir] = useState('');
+    const [error, setError] = useState('');
+    const stepIndex = STEP_ORDER.indexOf(step);
+    const provider = providerId ? getProvider(providerId) : null;
+    const handleApiKey = useCallback((result) => {
+        setProviderId(result.providerId);
+        setApiKey(result.apiKey);
+        setStep('soul');
+    }, []);
+    const handleName = useCallback((name) => {
+        setAgentName(name);
+        setStep('identity');
+    }, []);
+    const handleIdentity = useCallback((result) => {
+        setPersonality(result.personality);
+        setTone(result.tone);
+        setVoiceStyle(result.voiceStyle);
+        setTradingStyle(result.tradingStyle);
+        setSectors(result.sectors);
+        setSentiment(result.sentiment);
+        setTimeframes(result.timeframes);
+        setBio(result.bio);
+        setStep('avatar');
+    }, []);
+    const handleAvatar = useCallback((value) => {
+        setAvatarUrl(value);
+        setStep('api-key');
+    }, []);
+    const handleSoul = useCallback((content) => {
+        const patched = ensureAvatarUrl(content, avatarUrl);
+        setSoulContent(patched);
+        setStep('strategy');
+    }, [avatarUrl]);
+    const handleStrategy = useCallback((content) => {
+        const patched = ensureStrategyFields(content, sectors, sentiment, timeframes);
+        setStrategyContent(patched);
+        setStep('scaffold');
+    }, [sectors, sentiment, timeframes]);
+    const handleScaffoldComplete = useCallback((projectDir) => {
+        setResolvedProjectDir(projectDir);
+        setStep('done');
+    }, []);
+    const handleScaffoldError = useCallback((message) => {
+        setError(message);
+        exit();
+    }, [exit]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, {}), _jsx(StepIndicator, { steps: STEP_DEFS, currentIndex: stepIndex }), step !== 'done' && (_jsx(Box, { marginBottom: 1, children: _jsx(AsciiTicker, { step: stepIndex + 1 }) })), step === 'api-key' && (_jsx(ApiKeyStep, { onComplete: handleApiKey })), step === 'name' && (_jsx(NameStep, { onComplete: handleName })), step === 'identity' && (_jsx(IdentityStep, { agentName: agentName, onComplete: handleIdentity })), step === 'avatar' && (_jsx(AvatarStep, { agentName: agentName, onComplete: handleAvatar })), step === 'soul' && providerId && (_jsx(SoulStep, { providerId: providerId, apiKey: apiKey, agentName: agentName, bio: bio, avatarUrl: avatarUrl, personality: personality, tone: tone, voiceStyle: voiceStyle, tradingStyle: tradingStyle, sectors: sectors, sentiment: sentiment, timeframes: timeframes, onComplete: handleSoul })), step === 'strategy' && providerId && (_jsx(StrategyStep, { providerId: providerId, apiKey: apiKey, agentName: agentName, bio: bio, personality: personality, tone: tone, voiceStyle: voiceStyle, tradingStyle: tradingStyle, sectors: sectors, sentiment: sentiment, timeframes: timeframes, onComplete: handleStrategy })), step === 'scaffold' && provider && (_jsx(ScaffoldStep, { projectName: agentName, provider: provider, apiKey: apiKey, soulContent: soulContent, strategyContent: strategyContent, onComplete: handleScaffoldComplete, onError: handleScaffoldError })), step === 'done' && (_jsx(DoneStep, { projectDir: resolvedProjectDir })), error !== '' && (_jsx(Box, { marginTop: 1, marginLeft: 2, children: _jsxs(Text, { color: colors.red, children: [symbols.cross, " ", error] }) }))] }));
+}

package/dist/create/ai-generate.js

@@ -0,0 +1,147 @@
+import { streamText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createXai } from '@ai-sdk/xai';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { getProvider } from '../ai-providers.js';
+import { SOUL_PRESETS, STRATEGY_PRESETS, buildSoulMarkdown, buildStrategyMarkdown, } from '../presets.js';
+function buildModel(providerId, apiKey) {
+    const provider = getProvider(providerId);
+    const modelId = provider.models.generation;
+    switch (providerId) {
+        case 'openai':
+            return createOpenAI({ apiKey })(modelId);
+        case 'anthropic':
+            return createAnthropic({ apiKey })(modelId);
+        case 'google':
+            return createGoogleGenerativeAI({ apiKey })(modelId);
+        case 'xai':
+            return createXai({ apiKey })(modelId);
+        case 'openrouter':
+            return createOpenRouter({ apiKey }).chat(modelId);
+    }
+}
+function buildPresetExamples() {
+    const soulExamples = SOUL_PRESETS.map((p) => buildSoulMarkdown('ExampleAgent', 'example bio text for reference', p, '')).join('\n---\n');
+    const strategyExamples = STRATEGY_PRESETS.map((p) => buildStrategyMarkdown('ExampleAgent', p)).join('\n---\n');
+    return `${soulExamples}\n\n===\n\n${strategyExamples}`;
+}
+const PRESET_EXAMPLES = buildPresetExamples();
+export function streamSoul(providerId, apiKey, agentName, bio, avatarUrl, personality, tone, voiceStyle, tradingStyle, sectors, sentiment, timeframes, feedback) {
+    const feedbackLine = feedback
+        ? `\n\nThe user gave this feedback on the previous draft. Adjust accordingly:\n"${feedback}"`
+        : '';
+    const sectorsLine = sectors.length > 0 ? sectors.join(', ') : 'all categories';
+    const timeframesLine = timeframes.length > 0 ? timeframes.join(', ') : 'all timeframes';
+    const identityContext = `Personality: ${personality}
+Tone: ${tone}
+Voice style: ${voiceStyle}
+Trading style: ${tradingStyle}
+Sectors: ${sectorsLine}
+Sentiment: ${sentiment}
+Preferred timeframes: ${timeframesLine}`;
+    const prompt = `You are a creative writer designing an AI agent's personality profile for a crypto trading bot called "${agentName}".
+
+The agent's bio is: "${bio}"
+${avatarUrl ? `Avatar URL: ${avatarUrl}` : 'No avatar URL provided.'}
+
+Identity traits:
+${identityContext}
+
+Context — Hive is a prediction game for AI agents:
+- Signals appear in cells (e.g. c/ethereum, c/bitcoin) when noteworthy crypto events happen.
+- Agents submit a percentage prediction (predicted price change over 3 hours) and a short reasoning.
+- Threads resolve at T+3h. Correct-direction predictions earn honey (the ranking currency); wrong-direction predictions earn wax.
+- Early predictions are worth dramatically more than late ones (steep time bonus decay).
+- Streaks track consecutive correct-direction predictions. Skipping a thread carries no penalty and does not break streaks.
+- Agents are ranked on a leaderboard by total honey.
+
+Generate a SOUL.md file for this agent. The SOUL.md defines who the agent IS — their personality, voice, quirks, opinions, and how they post. The personality should be aware that the agent operates in this prediction game — their voice should reflect how they approach predictions, risk, and competition. Use the identity traits above to shape the personality, tone, and writing style.
+
+CRITICAL: Output ONLY valid markdown matching this exact structure. No extra commentary.
+
+The first line MUST be: # Agent: ${agentName}
+
+Here are reference examples of well-crafted SOUL.md files:
+---
+${PRESET_EXAMPLES.split('===')[0]}
+---
+
+Use these as style/quality references but create something UNIQUE based on the agent's name, bio, and identity traits.${feedbackLine}`;
+    const model = buildModel(providerId, apiKey);
+    const result = streamText({
+        model,
+        prompt,
+        maxOutputTokens: 1500,
+    });
+    return result.textStream;
+}
+export function streamStrategy(providerId, apiKey, agentName, bio, personality, tone, voiceStyle, tradingStyle, sectors, sentiment, timeframes, feedback) {
+    const feedbackLine = feedback
+        ? `\n\nThe user gave this feedback on the previous draft. Adjust accordingly:\n"${feedback}"`
+        : '';
+    const sectorsLine = sectors.length > 0 ? sectors.join(', ') : 'all categories';
+    const timeframesLine = timeframes.length > 0 ? timeframes.join(', ') : 'all timeframes';
+    const identityContext = `Personality: ${personality}
+Tone: ${tone}
+Voice style: ${voiceStyle}
+Trading style: ${tradingStyle}
+Sectors: ${sectorsLine}
+Sentiment: ${sentiment}
+Preferred timeframes: ${timeframesLine}`;
+    const prompt = `You are designing a prediction strategy profile for a crypto trading bot called "${agentName}".
+
+The agent's bio is: "${bio}"
+
+Identity traits:
+${identityContext}
+
+Context — Hive game mechanics that the strategy should account for:
+- Agents predict the percentage price change of a crypto asset over a 3-hour window.
+- Conviction is a number (e.g. 2.5 for +2.5%, -3.0 for -3.0%, 0 for neutral).
+- Correct-direction predictions earn honey (the primary ranking currency). Wrong-direction predictions earn wax (not a penalty, but doesn't help ranking).
+- Direction matters more than magnitude for earning honey, though closer magnitude predictions earn more.
+- Early predictions earn dramatically more honey due to steep time bonus decay — speed matters.
+- Consecutive correct-direction predictions build a streak (tracked on profile). Skipping does not break streaks.
+- Skipping is a valid strategy — no penalty, no streak break. Knowing when to sit out is a skill.
+- Agents are ranked on a leaderboard by total honey.
+
+Generate a STRATEGY.md file. The STRATEGY.md defines HOW the agent makes predictions — their method, sector focus, and decision framework. The strategy should reflect the agent's personality and tone, and should address the game mechanics above (e.g. when to skip, how aggressive to be with timing, how to calibrate conviction magnitude).
+
+CRITICAL: Output ONLY valid markdown matching this exact structure. No extra commentary.
+
+The first line MUST be: # Prediction Strategy: ${agentName}
+
+Required sections with EXACT headers:
+## Philosophy
+## Signal Interpretation
+- Method: (must be one of: technical, fundamental, sentiment, onchain, macro)
+- Primary indicators: (list key indicators)
+## Sentiment
+- Bias: ${sentiment}
+## Sector Focus
+- Sectors: ${sectorsLine}
+- Avoid: (sectors to avoid)
+## Timeframe
+- Active timeframes: ${timeframesLine}
+(Explain why these timeframes suit the agent's style. Mention that the agent skips signals outside these timeframes.)
+## Decision Framework
+1. (first step)
+2. (second step)
+3. (third step)
+
+Here are reference examples of well-crafted STRATEGY.md files:
+---
+${PRESET_EXAMPLES.split('===')[1] || ''}
+---
+
+Create something UNIQUE based on the agent's name, bio, and identity traits.${feedbackLine}`;
+    const model = buildModel(providerId, apiKey);
+    const result = streamText({
+        model,
+        prompt,
+        maxOutputTokens: 1200,
+    });
+    return result.textStream;
+}

package/dist/create/generate.js

@@ -0,0 +1,73 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function scaffoldProject(projectName, provider, apiKey, soulContent, strategyContent, callbacks) {
+    // Validate project name to prevent path traversal / command injection
+    if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
+        callbacks.onError('Project name can only contain letters, numbers, dashes, and underscores.');
+        return;
+    }
+    const agentsDir = path.join(os.homedir(), '.hive', 'agents');
+    const projectDir = path.join(agentsDir, projectName);
+    // Ensure resolved path is still inside ~/.hive/agents/
+    const normalizedProjectDir = path.resolve(projectDir);
+    const normalizedAgentsDir = path.resolve(agentsDir);
+    if (!normalizedProjectDir.startsWith(normalizedAgentsDir + path.sep)) {
+        callbacks.onError('Invalid project name: path traversal detected.');
+        return;
+    }
+    if (await fs.pathExists(projectDir)) {
+        callbacks.onError(`Directory ${normalizedProjectDir} already exists. Run "npx @hive-org/cli@latest create" again with a different name.`);
+        return;
+    }
+    // 1. Create directory
+    callbacks.onStep('Creating project directory');
+    await fs.ensureDir(projectDir);
+    // 2. Write SOUL.md and STRATEGY.md
+    callbacks.onStep('Writing personality files');
+    await fs.writeFile(path.join(projectDir, 'SOUL.md'), soulContent, 'utf-8');
+    await fs.writeFile(path.join(projectDir, 'STRATEGY.md'), strategyContent, 'utf-8');
+    const seedMemory = `# Memory
+
+## Key Learnings
+
+(none yet)
+
+## Market Observations
+
+(none yet)
+
+## Session Notes
+
+(none yet)
+`;
+    await fs.writeFile(path.join(projectDir, 'MEMORY.md'), seedMemory, 'utf-8');
+    // 3. Write .env
+    callbacks.onStep('Writing environment file');
+    const envContent = `${provider.envVar}="${apiKey}"
+`;
+    await fs.writeFile(path.join(projectDir, '.env'), envContent, { encoding: 'utf-8', mode: 0o600 });
+    // 4. Write minimal package.json — no deps needed, npx fetches @hive-org/agent@latest on every run
+    callbacks.onStep('Configuring project');
+    const packageJson = {
+        name: `hive-agent-${projectName}`,
+        private: true,
+        type: 'module',
+        scripts: {
+            start: 'npx @hive-org/cli@latest start',
+        },
+    };
+    await fs.writeJson(path.join(projectDir, 'package.json'), packageJson, { spaces: 2 });
+    // 5. Copy default skills
+    callbacks.onStep('Installing default skills');
+    const templateSkillsDir = path.resolve(__dirname, '../../templates/skills');
+    const projectSkillsDir = path.join(projectDir, 'skills');
+    const templateSkillsExist = await fs.pathExists(templateSkillsDir);
+    if (templateSkillsExist) {
+        await fs.copy(templateSkillsDir, projectSkillsDir);
+    }
+    callbacks.onDone(normalizedProjectDir);
+}