@zhive/cli 0.5.0

package/dist/agent/skills/skill-parser.js

@@ -0,0 +1,149 @@
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Parse YAML frontmatter from SKILL.md content.
+ * Expected format:
+ * ---
+ * name: skill-name
+ * description: Skill description
+ * ---
+ * Body content...
+ */
+export function parseFrontmatter(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('---')) {
+        throw new Error('SKILL.md must start with YAML frontmatter (---)');
+    }
+    const endIndex = trimmed.indexOf('---', 3);
+    if (endIndex === -1) {
+        throw new Error('SKILL.md frontmatter is not closed (missing closing ---)');
+    }
+    const frontmatterContent = trimmed.slice(3, endIndex).trim();
+    const body = trimmed.slice(endIndex + 3).trim();
+    const metadata = {
+        name: '',
+        description: '',
+    };
+    const lines = frontmatterContent.split('\n');
+    let currentKey = null;
+    let currentValue = '';
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith('name:')) {
+            if (currentKey !== null) {
+                setMetadataField(metadata, currentKey, currentValue.trim());
+            }
+            currentKey = 'name';
+            currentValue = trimmedLine.slice(5).trim();
+        }
+        else if (trimmedLine.startsWith('description:')) {
+            if (currentKey !== null) {
+                setMetadataField(metadata, currentKey, currentValue.trim());
+            }
+            currentKey = 'description';
+            const value = trimmedLine.slice(12).trim();
+            if (value === '>' || value === '|') {
+                currentValue = '';
+            }
+            else {
+                currentValue = value;
+            }
+        }
+        else if (currentKey !== null && (line.startsWith('  ') || line.startsWith('\t'))) {
+            currentValue += ' ' + trimmedLine;
+        }
+    }
+    if (currentKey !== null) {
+        setMetadataField(metadata, currentKey, currentValue.trim());
+    }
+    if (metadata.name === '') {
+        throw new Error('SKILL.md frontmatter must include "name" field');
+    }
+    if (metadata.description === '') {
+        throw new Error('SKILL.md frontmatter must include "description" field');
+    }
+    return { metadata, body };
+}
+function setMetadataField(metadata, key, value) {
+    if (key === 'name') {
+        metadata.name = value;
+    }
+    else if (key === 'description') {
+        metadata.description = value;
+    }
+}
+/**
+ * Check if a directory exists.
+ */
+async function directoryExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file exists.
+ */
+async function fileExists(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Discover and load a single skill from a directory.
+ * Skills are knowledge-only documents (no tools).
+ */
+export async function loadSkill(skillPath) {
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+    const exists = await fileExists(skillMdPath);
+    if (!exists) {
+        return null;
+    }
+    try {
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const { metadata, body } = parseFrontmatter(content);
+        const id = path.basename(skillPath);
+        const skill = {
+            id,
+            path: skillPath,
+            metadata,
+            body,
+        };
+        return skill;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to load skill from ${skillPath}: ${message}`);
+        return null;
+    }
+}
+/**
+ * Discover all skills in a directory.
+ * Each subdirectory containing SKILL.md is treated as a skill.
+ */
+export async function discoverSkills(skillsDir) {
+    const exists = await directoryExists(skillsDir);
+    if (!exists) {
+        return [];
+    }
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const skillPath = path.join(skillsDir, entry.name);
+        const skill = await loadSkill(skillPath);
+        if (skill !== null) {
+            skills.push(skill);
+        }
+    }
+    return skills;
+}

package/dist/agent/skills/types.js

@@ -0,0 +1 @@
+export {};

package/dist/agent/theme.js

@@ -0,0 +1,41 @@
+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', // ●
+    check: '\u2713', // ✓
+    cross: '\u2717', // ✗
+    arrow: '\u203A', // ›
+    circle: '\u25CB', // ○
+};
+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\u25AA\u25AB\u2591\u2592',
+    HEX_CHARS: '\u2B21\u2B22',
+    TICK_MS: 120,
+    HEX_W: 8,
+    HEX_H: 4,
+};

package/dist/agent/tools/index.js

@@ -0,0 +1,76 @@
+import * as path from 'node:path';
+import { discoverSkills } from '../skills/skill-parser.js';
+import { createReadSkillTool } from './read-skill-tool.js';
+import { marketTools } from './market/index.js';
+import { mindshareTools } from './mindshare/index.js';
+/**
+ * Get all tools that are always available to agents.
+ * Tools are bundled with the CLI and don't require skill installation.
+ * Skills provide knowledge/guidance on when and how to use these tools.
+ */
+export function getAllTools() {
+    const tools = {};
+    for (const [name, tool] of Object.entries(marketTools)) {
+        const namespacedName = `market_${name}`;
+        tools[namespacedName] = tool;
+    }
+    for (const [name, tool] of Object.entries(mindshareTools)) {
+        const namespacedName = `mindshare_${name}`;
+        tools[namespacedName] = tool;
+    }
+    return tools;
+}
+/**
+ * Initialize skills from agent's skills/ directory.
+ * Skills are knowledge-only documents that help agents understand
+ * when and how to use the always-available tools.
+ * Returns a registry map that should be passed to other skill functions.
+ */
+export async function initializeSkills(agentPath) {
+    const skillRegistry = new Map();
+    const skillsPath = path.join(agentPath, 'skills');
+    const agentSkills = await discoverSkills(skillsPath);
+    for (const skill of agentSkills) {
+        skillRegistry.set(skill.id, skill);
+    }
+    return skillRegistry;
+}
+/**
+ * Get a skill metadata list for prompt injection.
+ * Shows skill ID and description to help the agent decide what to use.
+ */
+export function getSkillMetadataList(skillRegistry) {
+    if (skillRegistry.size === 0) {
+        return '';
+    }
+    const lines = Array.from(skillRegistry.values())
+        .map((s) => `- ${s.id}: ${s.metadata.description}`)
+        .join('\n');
+    const output = `Available skills:\n${lines}`;
+    return output;
+}
+/**
+ * Get the readSkill tool for agent to read skill knowledge.
+ */
+export function getReadSkillTool(skillRegistry) {
+    const readSkillTool = createReadSkillTool(skillRegistry);
+    return readSkillTool;
+}
+/**
+ * Get a skill definition by ID.
+ */
+export function getSkill(skillRegistry, id) {
+    return skillRegistry.get(id);
+}
+/**
+ * Get all registered skills.
+ */
+export function getAllSkills(skillRegistry) {
+    return Array.from(skillRegistry.values());
+}
+/**
+ * Check if any skills are registered.
+ */
+export function hasSkills(skillRegistry) {
+    return skillRegistry.size > 0;
+}

package/dist/agent/tools/market/client.js

@@ -0,0 +1,41 @@
+import { HIVE_API_URL } from '../../../config.js';
+/**
+ * Client for the backend Market API.
+ */
+export class MarketClient {
+    constructor(baseUrl = HIVE_API_URL) {
+        this._baseUrl = baseUrl;
+    }
+    async getPrice(projectId, timestamp) {
+        const url = `${this._baseUrl}/market/price/${encodeURIComponent(projectId)}?timestamp=${encodeURIComponent(timestamp)}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Market price request failed: ${response.status} - ${text}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+    async getOHLC(id, from, to, interval = 'daily') {
+        const params = new URLSearchParams({
+            from,
+            to,
+            interval,
+        });
+        const url = `${this._baseUrl}/market/ohlc/${encodeURIComponent(id)}?${params.toString()}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Market OHLC request failed: ${response.status} - ${text}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+}
+let clientInstance = null;
+export function getMarketClient() {
+    if (clientInstance === null) {
+        clientInstance = new MarketClient();
+    }
+    return clientInstance;
+}

package/dist/agent/tools/market/index.js

@@ -0,0 +1,3 @@
+export { marketTools } from './tools.js';
+export { getPriceTool, getOHLCTool, getSMATool, getEMATool, getRSITool, getMACDTool, getBollingerTool, } from './tools.js';
+export { MarketClient, getMarketClient } from './client.js';