@exagent/agent 0.3.6 → 0.3.8

package/src/strategy/templates.ts

@@ -1,74 +0,0 @@
-import type { StrategyTemplate } from '@exagent/sdk';
-
-const templates: StrategyTemplate[] = [
-  {
-    id: 'momentum',
-    name: 'Momentum Trader',
-    description: 'Identifies tokens with strong upward price momentum and rides the trend. Uses LLM to analyze price action and market sentiment.',
-    category: 'momentum',
-    venues: ['hyperliquid_perp', 'hyperliquid_spot'],
-    riskLevel: 'moderate',
-    systemPrompt: `You are a momentum trading agent. Analyze the provided market data and identify tokens with strong upward momentum.
-
-Rules:
-- Only trade tokens with clear directional momentum (avoid choppy markets)
-- Use trailing stops to protect gains
-- Size positions based on conviction (higher confidence = larger position)
-- Cut losses quickly if momentum reverses
-- Consider volume as confirmation of momentum
-
-Return a JSON array of trade signals.`,
-  },
-  {
-    id: 'value',
-    name: 'Value Investor',
-    description: 'Identifies undervalued tokens based on fundamental analysis. Buys dips and holds for mean reversion.',
-    category: 'value',
-    venues: ['hyperliquid_spot'],
-    riskLevel: 'conservative',
-    systemPrompt: `You are a value investing agent. Identify tokens trading below their intrinsic value.
-
-Rules:
-- Focus on established tokens with strong fundamentals
-- Buy on significant dips (>10% from recent highs)
-- Hold positions longer (swing/position timeframe)
-- Avoid chasing pumps
-- Diversify across sectors
-
-Return a JSON array of trade signals.`,
-  },
-  {
-    id: 'arbitrage',
-    name: 'Arbitrage Hunter',
-    description: 'Scans for price discrepancies across venues and chains. Executes quickly to capture spreads.',
-    category: 'arbitrage',
-    venues: ['hyperliquid_perp', 'hyperliquid_spot', 'uniswap', 'aerodrome'],
-    riskLevel: 'aggressive',
-    systemPrompt: `You are an arbitrage agent. Find price discrepancies between venues.
-
-Rules:
-- Speed is critical — execute quickly before spreads close
-- Account for fees and slippage in profitability calculations
-- Only trade when net profit > 0.5% after all costs
-- Monitor cross-chain opportunities (CEX vs DEX spreads)
-
-Return a JSON array of trade signals.`,
-  },
-  {
-    id: 'hold',
-    name: 'Hold (No Trading)',
-    description: 'Passive strategy that makes no trades. Useful for monitoring only.',
-    category: 'custom',
-    venues: [],
-    riskLevel: 'conservative',
-    systemPrompt: '',
-  },
-];
-
-export function getTemplate(id: string): StrategyTemplate | undefined {
-  return templates.find(t => t.id === id);
-}
-
-export function listTemplates(): StrategyTemplate[] {
-  return [...templates];
-}

package/src/trading/index.ts

@@ -1,2 +0,0 @@
-export { RiskManager } from './risk.js';
-export { MarketDataService } from './market.js';

package/src/trading/market.ts

@@ -1,120 +0,0 @@
-import type { MarketData, OHLCV } from '@exagent/sdk';
-
-export class MarketDataService implements MarketData {
-  private prices: Record<string, number> = {};
-  private lastFetch = 0;
-  private cacheTTL: number;
-  private apiUrl: string | null;
-  private ohlcvCache: Map<string, { data: OHLCV[]; fetchedAt: number }> = new Map();
-
-  constructor(cacheTTLMs: number = 30000, apiUrl?: string) {
-    this.cacheTTL = cacheTTLMs;
-    this.apiUrl = apiUrl || null;
-  }
-
-  async refreshPrices(symbols: string[]): Promise<Record<string, number>> {
-    if (symbols.length === 0) return this.prices;
-
-    const now = Date.now();
-    if (now - this.lastFetch < this.cacheTTL && Object.keys(this.prices).length > 0) {
-      return this.prices;
-    }
-
-    // Try API first (if relay URL is configured)
-    if (this.apiUrl) {
-      try {
-        const res = await fetch(`${this.apiUrl}/v1/prices`);
-        if (res.ok) {
-          const data = await res.json() as Record<string, number>;
-          for (const [symbol, price] of Object.entries(data)) {
-            this.prices[symbol.toUpperCase()] = price;
-          }
-          this.lastFetch = now;
-          return this.prices;
-        }
-      } catch {
-        // Fall through to CoinGecko
-      }
-    }
-
-    // Fallback: CoinGecko (free, no API key)
-    try {
-      const ids = symbols.map(s => s.toLowerCase()).join(',');
-      const res = await fetch(
-        `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd`,
-      );
-
-      if (res.ok) {
-        const data = await res.json() as Record<string, { usd: number }>;
-        for (const [id, price] of Object.entries(data)) {
-          this.prices[id.toUpperCase()] = price.usd;
-        }
-        this.lastFetch = now;
-      }
-    } catch (err) {
-      console.warn('[market] Price fetch failed:', (err as Error).message);
-    }
-
-    return this.prices;
-  }
-
-  getPrice(symbol: string): number | undefined {
-    return this.prices[symbol.toUpperCase()];
-  }
-
-  getPrices(): Record<string, number> {
-    return { ...this.prices };
-  }
-
-  setPrice(symbol: string, price: number): void {
-    this.prices[symbol.toUpperCase()] = price;
-  }
-
-  setPrices(prices: Record<string, number>): void {
-    for (const [symbol, price] of Object.entries(prices)) {
-      this.prices[symbol.toUpperCase()] = price;
-    }
-  }
-
-  getOHLCV(symbol: string, timeframe: string): OHLCV[] {
-    const cacheKey = `${symbol.toUpperCase()}:${timeframe}`;
-    const cached = this.ohlcvCache.get(cacheKey);
-    if (cached && Date.now() - cached.fetchedAt < this.cacheTTL) {
-      return cached.data;
-    }
-
-    // Trigger async fetch (non-blocking) — returns cached or empty on first call
-    this.fetchOHLCV(symbol, timeframe).catch(() => {});
-    return cached?.data || [];
-  }
-
-  private async fetchOHLCV(symbol: string, timeframe: string): Promise<void> {
-    const cacheKey = `${symbol.toUpperCase()}:${timeframe}`;
-
-    // Try API first
-    if (this.apiUrl) {
-      try {
-        const res = await fetch(
-          `${this.apiUrl}/v1/prices/${symbol.toUpperCase()}/ohlcv?interval=${timeframe}&limit=100`,
-        );
-        if (res.ok) {
-          const bars = await res.json() as Array<{ t: number; o: number; h: number; l: number; c: number; v: number }>;
-          const ohlcv: OHLCV[] = bars.map((b) => ({
-            timestamp: b.t,
-            open: b.o,
-            high: b.h,
-            low: b.l,
-            close: b.c,
-            volume: b.v,
-          }));
-          this.ohlcvCache.set(cacheKey, { data: ohlcv, fetchedAt: Date.now() });
-          return;
-        }
-      } catch {
-        // Fall through
-      }
-    }
-
-    // No fallback for OHLCV — requires API
-  }
-}

package/src/trading/risk.ts

@@ -1,107 +0,0 @@
-import type { TradeSignal, RiskParams, MarketData } from '@exagent/sdk';
-
-export class RiskManager {
-  private params: RiskParams;
-  private dailyPnL = 0;
-  private dailyFees = 0;
-  private lastResetDate: string = '';
-  private initialCapitalUSD: number;
-
-  constructor(params: RiskParams, initialCapitalUSD: number = 10000) {
-    this.params = params;
-    this.initialCapitalUSD = initialCapitalUSD;
-    this.resetIfNewDay();
-  }
-
-  filterSignals(signals: TradeSignal[], market: MarketData, openPositionCount: number): TradeSignal[] {
-    this.resetIfNewDay();
-
-    if (this.isDailyLossLimitHit()) {
-      console.log('[risk] Daily loss limit hit — blocking all trades');
-      return [];
-    }
-
-    return signals.filter(signal => this.validateSignal(signal, market, openPositionCount));
-  }
-
-  private validateSignal(signal: TradeSignal, market: MarketData, openPositionCount: number): boolean {
-    // Confidence threshold
-    const threshold = this.params.confidenceThreshold ?? 0.5;
-    if (signal.confidence !== undefined && signal.confidence < threshold) {
-      console.log(`[risk] Blocked ${signal.symbol}: confidence ${signal.confidence} < ${threshold}`);
-      return false;
-    }
-
-    // Position size limit — use leverage-adjusted notional exposure
-    // A 10x leveraged $5k position = $50k notional exposure
-    const leverage = signal.leverage || 1;
-    const tradeValue = signal.size * signal.price * leverage;
-    const maxPositionValue = (this.params.maxPositionSizeBps / 10000) * this.initialCapitalUSD;
-    if (tradeValue > maxPositionValue) {
-      console.log(`[risk] Blocked ${signal.symbol}: notional $${tradeValue.toFixed(0)} (${leverage}x leverage) > max $${maxPositionValue.toFixed(0)}`);
-      return false;
-    }
-
-    // Min trade value
-    if (tradeValue < this.params.minTradeValueUSD) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(2)} < min $${this.params.minTradeValueUSD}`);
-      return false;
-    }
-
-    // Max concurrent positions (only for buys/longs)
-    if ((signal.side === 'buy' || signal.side === 'long') && openPositionCount >= this.params.maxConcurrentPositions) {
-      console.log(`[risk] Blocked ${signal.symbol}: ${openPositionCount} positions >= max ${this.params.maxConcurrentPositions}`);
-      return false;
-    }
-
-    // Max slippage
-    if (signal.orderType === 'market') {
-      const currentPrice = market.getPrice(signal.symbol);
-      if (currentPrice) {
-        const slippageBps = Math.abs(signal.price - currentPrice) / currentPrice * 10000;
-        if (slippageBps > this.params.maxSlippageBps) {
-          console.log(`[risk] Blocked ${signal.symbol}: slippage ${slippageBps.toFixed(0)}bps > max ${this.params.maxSlippageBps}bps`);
-          return false;
-        }
-      }
-    }
-
-    return true;
-  }
-
-  updateParams(updates: Record<string, number>): void {
-    if (updates.maxPositionSizeBps !== undefined) this.params.maxPositionSizeBps = updates.maxPositionSizeBps;
-    if (updates.maxDailyLossBps !== undefined) this.params.maxDailyLossBps = updates.maxDailyLossBps;
-    if (updates.maxConcurrentPositions !== undefined) this.params.maxConcurrentPositions = updates.maxConcurrentPositions;
-    if (updates.maxSlippageBps !== undefined) this.params.maxSlippageBps = updates.maxSlippageBps;
-    if (updates.minTradeValueUSD !== undefined) this.params.minTradeValueUSD = updates.minTradeValueUSD;
-    console.log('[risk] Params updated:', JSON.stringify(this.params));
-  }
-
-  recordTrade(pnl: number, fee: number): void {
-    this.dailyPnL += pnl;
-    this.dailyFees += fee;
-  }
-
-  isDailyLossLimitHit(): boolean {
-    const limit = (this.params.maxDailyLossBps / 10000) * this.initialCapitalUSD;
-    return this.dailyPnL < -limit;
-  }
-
-  getDailyPnL(): number {
-    return this.dailyPnL;
-  }
-
-  getDailyLossLimit(): number {
-    return (this.params.maxDailyLossBps / 10000) * this.initialCapitalUSD;
-  }
-
-  private resetIfNewDay(): void {
-    const today = new Date().toISOString().slice(0, 10);
-    if (today !== this.lastResetDate) {
-      this.dailyPnL = 0;
-      this.dailyFees = 0;
-      this.lastResetDate = today;
-    }
-  }
-}

package/src/ui.ts

@@ -1,75 +0,0 @@
-import figlet from 'figlet';
-import gradient from 'gradient-string';
-import boxen from 'boxen';
-import pc from 'picocolors';
-import { createRequire } from 'node:module';
-
-// Brand gradient: Blue → Indigo → Violet (from Exagent design system)
-const brandGradient: (text: string) => string = gradient(['#3B82F6', '#6366F1', '#7C3AED']);
-
-// Secondary gradient: Cyan → Blue
-const accentGradient: (text: string) => string = gradient(['#22D3EE', '#3B82F6']);
-
-function getVersion(): string {
-  try {
-    const require = createRequire(import.meta.url);
-    const pkg = require('../package.json');
-    return pkg.version || '0.0.0';
-  } catch {
-    return '0.0.0';
-  }
-}
-
-export function printBanner(): void {
-  const art = figlet.textSync('EXAGENT', {
-    font: 'Small',
-    horizontalLayout: 'default',
-  });
-
-  console.log();
-  console.log(brandGradient(art));
-  console.log(pc.dim(`  v${getVersion()}`));
-  console.log();
-}
-
-export function printSuccess(title: string, lines: string[]): void {
-  const body = [
-    '',
-    pc.bold(pc.white(title)),
-    '',
-    ...lines.map(l => `  ${l}`),
-    '',
-  ].join('\n');
-
-  console.log();
-  console.log(boxen(body, {
-    padding: { top: 0, bottom: 0, left: 2, right: 2 },
-    borderColor: '#3B82F6',
-    borderStyle: 'round',
-    dimBorder: false,
-  }));
-  console.log();
-}
-
-export function printStep(step: number, total: number, label: string): void {
-  console.log();
-  console.log(accentGradient(`  Step ${step} of ${total}`) + pc.dim(` — ${label}`));
-}
-
-export function printDone(message: string): void {
-  console.log(`  ${pc.green('✓')} ${message}`);
-}
-
-export function printInfo(message: string): void {
-  console.log(`  ${pc.dim('│')} ${message}`);
-}
-
-export function printWarn(message: string): void {
-  console.log(`  ${pc.yellow('!')} ${message}`);
-}
-
-export function printError(message: string): void {
-  console.log(`  ${pc.red('✗')} ${message}`);
-}
-
-export { pc, brandGradient, accentGradient };

package/test/strategy-loader.test.ts

@@ -1,150 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadStrategy } from '../src/strategy/loader.js';
-import type { StrategyContext } from '@exagent/sdk';
-
-function createContext(llmContent: string, prices: Record<string, number> = { ETH: 3000 }): StrategyContext {
-  const logs: string[] = [];
-  return {
-    llm: {
-      async chat() {
-        return { content: llmContent };
-      },
-      getMetadata() {
-        return { provider: 'test', model: 'test' };
-      },
-    },
-    market: {
-      getPrice(symbol: string) {
-        return prices[symbol] ?? prices[symbol.toUpperCase()];
-      },
-      getPrices() {
-        return prices;
-      },
-      getOHLCV() {
-        return [];
-      },
-    },
-    position: {
-      openPositions: [],
-      totalUnrealizedPnL: 0,
-      totalRealizedPnL: 0,
-    },
-    store: {
-      get() {
-        return undefined;
-      },
-      set() {
-        // no-op
-      },
-      delete() {
-        // no-op
-      },
-      keys() {
-        return [];
-      },
-    },
-    config: {
-      mode: 'paper',
-      timeHorizon: 'swing',
-      maxPositionSizeBps: 2000,
-      maxDailyLossBps: 500,
-      maxConcurrentPositions: 5,
-      tradingIntervalMs: 60000,
-      maxSlippageBps: 100,
-      minTradeValueUSD: 10,
-      initialCapitalUSD: 10000,
-    },
-    log(message: string) {
-      logs.push(message);
-    },
-  };
-}
-
-test('loadStrategy rejects raw JavaScript code configs', async () => {
-  await assert.rejects(
-    () => loadStrategy({ code: 'globalThis.stoleSecrets = true; return [];' }),
-    /Raw JavaScript strategy code is disabled/,
-  );
-});
-
-test('template strategies run through prompt-backed validation', async () => {
-  const strategy = await loadStrategy({ template: 'momentum' });
-  const signals = await strategy(createContext(JSON.stringify([
-    { symbol: 'ETH', side: 'buy', venue: 'hyperliquid_perp', confidence: 0.8 },
-  ])));
-
-  assert.equal(signals.length, 1);
-  assert.equal(signals[0].symbol, 'ETH');
-  assert.equal(signals[0].venue, 'hyperliquid_perp');
-  assert.equal(signals[0].price, 3000);
-  assert.equal(signals[0].venueFillId, '');
-});
-
-test('prompt strategies drop venues outside the configured strategy scope', async () => {
-  const strategy = await loadStrategy({
-    prompt: {
-      name: 'Scoped Prompt',
-      systemPrompt: 'Return scoped trade intents.',
-      venues: ['hyperliquid_perp'],
-    },
-  });
-
-  const signals = await strategy(createContext(JSON.stringify([
-    { symbol: 'ETH', side: 'buy', venue: 'polymarket', confidence: 0.9 },
-    { symbol: 'ETH', side: 'buy', venue: 'hyperliquid_perp', confidence: 0.9 },
-  ])));
-
-  assert.equal(signals.length, 1);
-  assert.equal(signals[0].venue, 'hyperliquid_perp');
-});
-
-test('strategy metadata files are parsed as data, not executable modules', async () => {
-  const dir = mkdtempSync(join(tmpdir(), 'exagent-strategy-'));
-  const strategyPath = join(dir, 'strategy.ts');
-
-  writeFileSync(strategyPath, [
-    '// Generated by Exagent',
-    'export const name = "Prompt File";',
-    'export const venues = ["hyperliquid_perp"];',
-    'export const systemPrompt = "Return trade intents.";'
-  ].join('\n'));
-
-  try {
-    const strategy = await loadStrategy({ file: strategyPath });
-    const signals = await strategy(createContext(JSON.stringify([
-      { symbol: 'ETH', side: 'long', confidence: 0.7 },
-    ])));
-
-    assert.equal(signals.length, 1);
-    assert.equal(signals[0].venue, 'hyperliquid_perp');
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('strategy files cannot export code or arbitrary statements', async () => {
-  const dir = mkdtempSync(join(tmpdir(), 'exagent-strategy-'));
-  const codeExportPath = join(dir, 'code-strategy.ts');
-  const statementPath = join(dir, 'statement-strategy.ts');
-
-  writeFileSync(codeExportPath, 'export const code = "return [];";\n');
-  writeFileSync(statementPath, 'export const systemPrompt = "Return []";\nglobalThis.compromised = true;\n');
-
-  try {
-    await assert.rejects(
-      () => loadStrategy({ file: codeExportPath }),
-      /Raw JavaScript strategy code is disabled/,
-    );
-    await assert.rejects(
-      () => loadStrategy({ file: statementPath }),
-      /Unsupported statement/,
-    );
-    assert.equal((globalThis as Record<string, unknown>).compromised, undefined);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}