@zhive/cli 0.6.7 → 0.6.8

package/dist/shared/ai-providers.js

@@ -0,0 +1,66 @@
+export const AI_PROVIDERS = [
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        package: '@ai-sdk/openai',
+        envVar: 'OPENAI_API_KEY',
+        models: { validation: 'gpt-4o-mini', generation: 'gpt-5-mini', runtime: 'gpt-5-mini' },
+    },
+    {
+        id: 'anthropic',
+        label: 'Anthropic',
+        package: '@ai-sdk/anthropic',
+        envVar: 'ANTHROPIC_API_KEY',
+        models: {
+            validation: 'claude-haiku-4-5-20251001',
+            generation: 'claude-haiku-4-5',
+            runtime: 'claude-haiku-4-5',
+        },
+    },
+    {
+        id: 'google',
+        label: 'Google',
+        package: '@ai-sdk/google',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        models: {
+            validation: 'gemini-2.0-flash',
+            generation: 'gemini-3-flash-preview',
+            runtime: 'gemini-3-flash-preview',
+        },
+    },
+    {
+        id: 'xai',
+        label: 'xAI',
+        package: '@ai-sdk/xai',
+        envVar: 'XAI_API_KEY',
+        models: {
+            validation: 'grok-2',
+            generation: 'grok-4-1-fast-reasoning',
+            runtime: 'grok-4-1-fast-reasoning',
+        },
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        package: '@openrouter/ai-sdk-provider',
+        envVar: 'OPENROUTER_API_KEY',
+        models: {
+            validation: 'openai/gpt-4o-mini',
+            generation: 'openai/gpt-5.1-mini',
+            runtime: 'openai/gpt-5.1-mini',
+        },
+    },
+];
+/**
+ * All env-var names used by AI providers.
+ * Used to clear shell-inherited keys before loading an agent's .env,
+ * so only the agent's chosen provider is active.
+ */
+export const AI_PROVIDER_ENV_VARS = AI_PROVIDERS.map((p) => p.envVar);
+export function getProvider(id) {
+    const provider = AI_PROVIDERS.find((p) => p.id === id);
+    if (!provider) {
+        throw new Error(`Unknown AI provider: ${id}`);
+    }
+    return provider;
+}

package/dist/shared/ta/error.js

@@ -0,0 +1,12 @@
+export class InsufficientDataError extends Error {
+    constructor(required, got) {
+        super('INSUFFICIENT_DATA');
+        this.required = required;
+        this.got = got;
+    }
+}
+export class PriceUnavailableError extends Error {
+    constructor(project) {
+        super(`Price of "${project}" is not available`);
+    }
+}

package/dist/shared/ta/service.js

@@ -0,0 +1,93 @@
+import { rsi, sma, ema, macd, bb } from 'indicatorts';
+import { getMarketClient } from '../agent/tools/market/client.js';
+import { InsufficientDataError } from './error.js';
+import { adjustFromDate } from './utils.js';
+export const getPrice = async ({ project, at }) => {
+    const client = getMarketClient();
+    const priceData = await client.getPrice(project, at ?? new Date());
+    return priceData.price ?? undefined;
+};
+export const getOHLC = async ({ project, from, to, interval = 'hourly', }) => {
+    const client = getMarketClient();
+    const ohlcData = await client.getOHLC(project, from, to, interval);
+    return ohlcData;
+};
+export const getRSI = async ({ project, interval = 'hourly', period = 14, from, to, }) => {
+    const market = getMarketClient();
+    const adjustedFrom = adjustFromDate(from, period, interval);
+    const ohlcData = await market.getOHLC(project, adjustedFrom, to, interval);
+    if (ohlcData.length < period) {
+        throw new InsufficientDataError(period, ohlcData.length);
+    }
+    const rsiData = rsi(ohlcData.map((data) => data[4]), { period });
+    const results = rsiData.map((value, i) => ({
+        value,
+        timestamp: new Date(ohlcData[i]?.[0] ?? 0).toISOString(),
+    }));
+    return results;
+};
+export const getSMA = async ({ project, interval = 'hourly', period = 20, from, to, }) => {
+    const market = getMarketClient();
+    const adjustedFrom = adjustFromDate(from, period, interval);
+    const ohlcData = await market.getOHLC(project, adjustedFrom, to, interval);
+    if (ohlcData.length < period) {
+        throw new InsufficientDataError(period, ohlcData.length);
+    }
+    const closePrices = ohlcData.map((data) => data[4]);
+    const smaData = sma(closePrices, { period });
+    const results = smaData.map((value, i) => ({
+        value,
+        timestamp: new Date(ohlcData[i]?.[0] ?? 0).toISOString(),
+    }));
+    return results;
+};
+export const getEMA = async ({ project, interval = 'hourly', period = 12, from, to, }) => {
+    const market = getMarketClient();
+    const adjustedFrom = adjustFromDate(from, period, interval);
+    const ohlcData = await market.getOHLC(project, adjustedFrom, to, interval);
+    if (ohlcData.length < period) {
+        throw new InsufficientDataError(period, ohlcData.length);
+    }
+    const closePrices = ohlcData.map((data) => data[4]);
+    const emaData = ema(closePrices, { period });
+    const results = emaData.map((value, i) => ({
+        value,
+        timestamp: new Date(ohlcData[i]?.[0] ?? 0).toISOString(),
+    }));
+    return results;
+};
+export const getMACD = async ({ project, interval = 'hourly', fast = 12, slow = 26, signal = 9, from, to, }) => {
+    const market = getMarketClient();
+    const minRequired = slow + signal;
+    const adjustedFrom = adjustFromDate(from, minRequired, interval);
+    const ohlcData = await market.getOHLC(project, adjustedFrom, to, interval);
+    if (ohlcData.length < minRequired) {
+        throw new InsufficientDataError(minRequired, ohlcData.length);
+    }
+    const closePrices = ohlcData.map((data) => data[4]);
+    const macdResult = macd(closePrices, { fast, slow, signal });
+    const results = macdResult.macdLine.map((macdVal, i) => ({
+        timestamp: new Date(ohlcData[i]?.[0] ?? 0).toISOString(),
+        macd: macdVal,
+        signal: macdResult.signalLine[i],
+        histogram: macdVal - macdResult.signalLine[i],
+    }));
+    return results;
+};
+export const getBollingerBands = async ({ project, interval = 'hourly', period = 20, from, to, }) => {
+    const market = getMarketClient();
+    const adjustedFrom = adjustFromDate(from, period, interval);
+    const ohlcData = await market.getOHLC(project, adjustedFrom, to, interval);
+    if (ohlcData.length < period) {
+        throw new InsufficientDataError(period, ohlcData.length);
+    }
+    const closePrices = ohlcData.map((data) => data[4]);
+    const bbResult = bb(closePrices, { period });
+    const results = bbResult.upper.map((upper, i) => ({
+        timestamp: new Date(ohlcData[i]?.[0] ?? 0).toISOString(),
+        upper,
+        middle: bbResult.middle[i],
+        lower: bbResult.lower[i],
+    }));
+    return results;
+};

package/dist/shared/ta/utils.js

@@ -0,0 +1,16 @@
+/**
+ * Adjusts the 'from' date backwards to ensure sufficient data points are fetched
+ * for indicator calculation. Adds a 30% buffer for weekends/gaps in data.
+ */
+export function adjustFromDate(from, minPoints, interval) {
+    const fromDate = new Date(from);
+    const buffer = Math.ceil(minPoints * 0.3);
+    const totalPoints = minPoints + buffer;
+    if (interval === 'hourly') {
+        fromDate.setTime(fromDate.getTime() - totalPoints * 60 * 60 * 1000);
+    }
+    else {
+        fromDate.setTime(fromDate.getTime() - totalPoints * 24 * 60 * 60 * 1000);
+    }
+    return fromDate.toISOString();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhive/cli",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "CLI for bootstrapping zHive AI Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -38,6 +38,7 @@
     "commander": "^14.0.3",
     "dotenv": "^16.0.0",
     "fs-extra": "^11.2.0",
+    "indicatorts": "^2.2.2",
     "ink": "^5.1.0",
     "ink-select-input": "^6.0.0",
     "ink-text-input": "^6.0.0",