@one_deploy/sdk 1.0.7 → 1.2.0

package/src/hooks/useAIQuantConsole.ts

@@ -0,0 +1,283 @@
+/**
+ * ONE SDK - AI Quant Console Hook
+ * Combined hook for all AI trading console data
+ */
+
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { useBotSimulation } from './useBotSimulation';
+import { useAIPositions } from './useAIPositions';
+import { useAIDecisions } from './useAIDecisions';
+import { useAIRiskStatus } from './useAIRiskStatus';
+import type {
+  AIAgent,
+  AIPosition,
+  AIDecision,
+  RiskStatus,
+  ConsoleMetrics,
+  AIQuantConsoleOptions,
+} from '../types/console';
+import { DEFAULT_CONSOLE_METRICS, AGENT_STATUS_COLORS } from '../types/console';
+import type { BotLogEntry, BotState, StrategyPersonality } from '../services/forex/BotSimulationEngine';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export interface UseAIQuantConsoleResult {
+  // Strategies and Agents
+  strategies: StrategyPersonality[];
+  agents: AIAgent[];
+  // Logs
+  logs: BotLogEntry[];
+  logsByStrategy: Map<string, BotLogEntry[]>;
+  // Bot States
+  botStates: Map<string, BotState>;
+  // Positions
+  positions: AIPosition[];
+  openPositions: AIPosition[];
+  // Decisions
+  decisions: AIDecision[];
+  recentDecisions: AIDecision[];
+  // Risk
+  riskStatus: RiskStatus | null;
+  // Metrics
+  metrics: ConsoleMetrics;
+  // State
+  isRunning: boolean;
+  isLoading: boolean;
+  error: string | null;
+  // Controls
+  start: (strategyIds?: string[]) => void;
+  stop: (strategyIds?: string[]) => void;
+  clearLogs: () => void;
+  emitBootSequence: () => void;
+  refresh: () => Promise<void>;
+  // Agent helpers
+  getAgent: (strategyId: string) => AIAgent | undefined;
+  getAgentLogs: (strategyId: string) => BotLogEntry[];
+  getAgentPositions: (strategyId: string) => AIPosition[];
+  getAgentDecisions: (strategyId: string) => AIDecision[];
+}
+
+// ── Hook Implementation ───────────────────────────────────────────────────────
+
+export function useAIQuantConsole(options?: AIQuantConsoleOptions): UseAIQuantConsoleResult {
+  const simulation = options?.simulation ?? true;
+  const pollInterval = options?.pollInterval ?? 5000;
+  const maxLogs = options?.maxLogs ?? 500;
+  const strategyIds = options?.strategyIds;
+
+  // Sub-hooks
+  const botSim = useBotSimulation({
+    maxLogs,
+    strategyIds,
+    autoStart: false,
+  });
+
+  const positionsHook = useAIPositions({
+    strategyIds,
+    pollInterval,
+    simulation,
+  });
+
+  const decisionsHook = useAIDecisions({
+    strategyIds,
+    pollInterval,
+    simulation,
+    limit: 100,
+  });
+
+  const riskHook = useAIRiskStatus({
+    pollInterval,
+    simulation,
+  });
+
+  // Transform bot states to agents
+  const agents = useMemo((): AIAgent[] => {
+    const agentList: AIAgent[] = [];
+
+    for (const strategy of botSim.strategies) {
+      const state = botSim.botStates.get(strategy.id);
+      const strategyPositions = positionsHook.positions.filter(p => p.strategyId === strategy.id);
+      const strategyDecisions = decisionsHook.decisions.filter(d => d.strategyId === strategy.id);
+      const openPos = strategyPositions.filter(p => p.status === 'open');
+
+      const totalPnl = strategyPositions.reduce((sum, p) => sum + p.pnl, 0);
+      const exposure = openPos.reduce((sum, p) => sum + p.size, 0);
+      const winCount = strategyPositions.filter(p => p.pnl > 0).length;
+      const totalTrades = strategyPositions.length;
+
+      // Determine agent risk level based on exposure and drawdown
+      let riskLevel: 'low' | 'medium' | 'high' | 'critical' = 'low';
+      if (strategy.riskTolerance === 'high') riskLevel = 'medium';
+      if (exposure > 50000) riskLevel = 'high';
+      if (state && state.openPositions.length >= 3) riskLevel = 'high';
+
+      agentList.push({
+        id: strategy.id,
+        strategyId: strategy.id,
+        name: strategy.name,
+        shortName: strategy.shortName,
+        color: strategy.color,
+        status: state?.isRunning ? 'active' : botSim.isRunning ? 'idle' : 'paused',
+        totalPnl: state?.totalPnl ?? totalPnl,
+        pnlToday: totalPnl * 0.3, // Simulated
+        winRate: state?.winRate ?? (totalTrades > 0 ? winCount / totalTrades : 0.5),
+        totalTrades: state?.totalTrades ?? totalTrades,
+        tradesToday: Math.floor((state?.totalTrades ?? totalTrades) * 0.2),
+        currentPair: state?.currentPair,
+        currentPrice: state?.currentPrice,
+        lastSignal: state?.lastSignal,
+        lastSignalConfidence: state?.lastSignalConfidence,
+        lastActivity: state ? Date.now() : undefined,
+        openPositions: openPos.length,
+        totalExposure: exposure,
+        riskLevel,
+        drawdown: Math.random() * 5, // Simulated
+        riskTolerance: strategy.riskTolerance,
+        primaryIndicators: strategy.primaryIndicators,
+        preferredPairs: strategy.preferredPairs,
+        leverageRange: [strategy.leverageMin, strategy.leverageMax],
+      });
+    }
+
+    return agentList;
+  }, [botSim.strategies, botSim.botStates, botSim.isRunning, positionsHook.positions, decisionsHook.decisions]);
+
+  // Calculate combined metrics
+  const metrics = useMemo((): ConsoleMetrics => {
+    const positions = positionsHook.positions;
+    const openPos = positions.filter(p => p.status === 'open');
+    const closedPos = positions.filter(p => p.status === 'closed');
+
+    const totalPnl = positions.reduce((sum, p) => sum + p.pnl, 0);
+    const unrealizedPnl = openPos.reduce((sum, p) => sum + p.pnl, 0);
+    const realizedPnl = closedPos.reduce((sum, p) => sum + p.pnl, 0);
+
+    const wins = positions.filter(p => p.pnl > 0);
+    const losses = positions.filter(p => p.pnl < 0);
+
+    const avgWin = wins.length > 0
+      ? wins.reduce((sum, p) => sum + p.pnl, 0) / wins.length
+      : 0;
+    const avgLoss = losses.length > 0
+      ? Math.abs(losses.reduce((sum, p) => sum + p.pnl, 0)) / losses.length
+      : 0;
+
+    const profitFactor = avgLoss > 0 ? avgWin / avgLoss : avgWin > 0 ? Infinity : 0;
+
+    const totalExposure = openPos.reduce((sum, p) => sum + p.size, 0);
+    const avgLeverage = openPos.length > 0
+      ? openPos.reduce((sum, p) => sum + p.leverage, 0) / openPos.length
+      : 0;
+
+    // Strategy metrics
+    const strategyMetrics: Record<string, { pnl: number; trades: number; winRate: number; exposure: number }> = {};
+    for (const agent of agents) {
+      const strategyPos = positions.filter(p => p.strategyId === agent.strategyId);
+      const strategyOpen = strategyPos.filter(p => p.status === 'open');
+      const strategyWins = strategyPos.filter(p => p.pnl > 0);
+
+      strategyMetrics[agent.strategyId] = {
+        pnl: strategyPos.reduce((sum, p) => sum + p.pnl, 0),
+        trades: strategyPos.length,
+        winRate: strategyPos.length > 0 ? strategyWins.length / strategyPos.length : 0,
+        exposure: strategyOpen.reduce((sum, p) => sum + p.size, 0),
+      };
+    }
+
+    return {
+      nav: 100000 + totalPnl,
+      navChange24h: totalPnl * 0.3,
+      navChangePercent24h: (totalPnl * 0.3) / 100000 * 100,
+      totalPnl,
+      realizedPnl,
+      unrealizedPnl,
+      pnlToday: totalPnl * 0.3,
+      pnl7d: totalPnl * 0.7,
+      pnl30d: totalPnl,
+      totalTrades: positions.length,
+      tradesToday: Math.floor(positions.length * 0.2),
+      winRate: positions.length > 0 ? wins.length / positions.length : 0,
+      winCount: wins.length,
+      lossCount: losses.length,
+      avgWin,
+      avgLoss,
+      profitFactor,
+      openPositions: openPos.length,
+      totalExposure,
+      avgLeverage,
+      strategyMetrics,
+    };
+  }, [positionsHook.positions, agents]);
+
+  // Controls
+  const start = useCallback((ids?: string[]) => {
+    botSim.start(ids || strategyIds);
+  }, [botSim, strategyIds]);
+
+  const stop = useCallback((ids?: string[]) => {
+    botSim.stop(ids);
+  }, [botSim]);
+
+  const clearLogs = useCallback(() => {
+    botSim.clearLogs();
+  }, [botSim]);
+
+  const refresh = useCallback(async () => {
+    await Promise.all([
+      positionsHook.refresh(),
+      decisionsHook.refresh(),
+      riskHook.refresh(),
+    ]);
+  }, [positionsHook, decisionsHook, riskHook]);
+
+  // Agent helpers
+  const getAgent = useCallback((strategyId: string) =>
+    agents.find(a => a.strategyId === strategyId),
+    [agents]
+  );
+
+  const getAgentLogs = useCallback((strategyId: string) =>
+    botSim.logsByStrategy.get(strategyId) || [],
+    [botSim.logsByStrategy]
+  );
+
+  const getAgentPositions = useCallback((strategyId: string) =>
+    positionsHook.positions.filter(p => p.strategyId === strategyId),
+    [positionsHook.positions]
+  );
+
+  const getAgentDecisions = useCallback((strategyId: string) =>
+    decisionsHook.decisions.filter(d => d.strategyId === strategyId),
+    [decisionsHook.decisions]
+  );
+
+  // Combined loading/error state
+  const isLoading = positionsHook.isLoading || decisionsHook.isLoading || riskHook.isLoading;
+  const error = positionsHook.error || decisionsHook.error || riskHook.error;
+
+  return {
+    strategies: botSim.strategies,
+    agents,
+    logs: botSim.logs,
+    logsByStrategy: botSim.logsByStrategy,
+    botStates: botSim.botStates,
+    positions: positionsHook.positions,
+    openPositions: positionsHook.openPositions,
+    decisions: decisionsHook.decisions,
+    recentDecisions: decisionsHook.recentDecisions,
+    riskStatus: riskHook.riskStatus,
+    metrics,
+    isRunning: botSim.isRunning,
+    isLoading,
+    error,
+    start,
+    stop,
+    clearLogs,
+    emitBootSequence: botSim.emitBootSequence,
+    refresh,
+    getAgent,
+    getAgentLogs,
+    getAgentPositions,
+    getAgentDecisions,
+  };
+}

package/src/hooks/useAIRiskStatus.ts

@@ -0,0 +1,276 @@
+/**
+ * ONE SDK - AI Risk Status Hook
+ * Provides React hook for monitoring trading risk status and limits
+ */
+
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import type { RiskStatus, RiskLevel, TradingStatus } from '../types/console';
+import { DEFAULT_RISK_STATUS, calculateRiskLevel } from '../types/console';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export interface UseAIRiskStatusOptions {
+  strategyId?: string;
+  pollInterval?: number;
+  simulation?: boolean;
+}
+
+export interface UseAIRiskStatusResult {
+  riskStatus: RiskStatus;
+  isLoading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+  // Computed values
+  isWithinLimits: boolean;
+  canTrade: boolean;
+  riskLevel: RiskLevel;
+  tradingStatus: TradingStatus;
+  warnings: string[];
+  // Actions
+  pauseTrading: () => Promise<boolean>;
+  resumeTrading: () => Promise<boolean>;
+  resetDailyLimits: () => Promise<boolean>;
+}
+
+// ── Simulation Data Generator ─────────────────────────────────────────────────
+
+function generateSimulatedRiskStatus(): RiskStatus {
+  const totalExposure = Math.random() * 80000 + 10000;
+  const maxExposure = 100000;
+  const exposurePercent = (totalExposure / maxExposure) * 100;
+
+  const dailyPnl = (Math.random() - 0.3) * 3000;
+  const dailyPnlLimit = 5000;
+  const dailyPnlPercent = (Math.abs(dailyPnl) / dailyPnlLimit) * 100;
+
+  const currentDrawdown = Math.random() * 10;
+  const maxDrawdown = 15;
+  const drawdownPercent = (currentDrawdown / maxDrawdown) * 100;
+
+  const openPositions = Math.floor(Math.random() * 8);
+  const maxPositions = 10;
+
+  const dailyTradeCount = Math.floor(Math.random() * 30);
+  const dailyTradeLimit = 50;
+
+  const riskLevel = calculateRiskLevel(exposurePercent, drawdownPercent, dailyPnlPercent);
+
+  const warnings: string[] = [];
+  if (exposurePercent > 70) warnings.push('High portfolio exposure');
+  if (drawdownPercent > 60) warnings.push('Approaching max drawdown');
+  if (dailyPnlPercent > 80 && dailyPnl < 0) warnings.push('Daily loss limit warning');
+  if (openPositions >= maxPositions - 1) warnings.push('Position limit nearly reached');
+
+  let tradingStatus: TradingStatus = 'active';
+  if (riskLevel === 'critical') tradingStatus = 'stopped';
+  else if (riskLevel === 'high' && warnings.length > 1) tradingStatus = 'paused';
+
+  const strategyRisks: Record<string, { exposure: number; drawdown: number; riskLevel: RiskLevel }> = {
+    'balanced-01': {
+      exposure: Math.random() * 30000,
+      drawdown: Math.random() * 5,
+      riskLevel: Math.random() > 0.7 ? 'medium' : 'low',
+    },
+    'conservative-01': {
+      exposure: Math.random() * 20000,
+      drawdown: Math.random() * 3,
+      riskLevel: 'low',
+    },
+    'aggressive-01': {
+      exposure: Math.random() * 40000,
+      drawdown: Math.random() * 8,
+      riskLevel: Math.random() > 0.5 ? 'high' : 'medium',
+    },
+  };
+
+  return {
+    timestamp: Date.now(),
+    totalExposure,
+    maxExposure,
+    exposurePercent,
+    dailyPnl,
+    dailyPnlLimit,
+    dailyPnlPercent,
+    dailyTradeCount,
+    dailyTradeLimit,
+    currentDrawdown,
+    maxDrawdown,
+    drawdownPercent,
+    openPositions,
+    maxPositions,
+    riskLevel,
+    tradingStatus,
+    warnings,
+    strategyRisks,
+  };
+}
+
+// ── Hook Implementation ───────────────────────────────────────────────────────
+
+export function useAIRiskStatus(options?: UseAIRiskStatusOptions): UseAIRiskStatusResult {
+  const [riskStatus, setRiskStatus] = useState<RiskStatus>(DEFAULT_RISK_STATUS);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchRiskStatus = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      if (options?.simulation) {
+        const simulated = generateSimulatedRiskStatus();
+        setRiskStatus(simulated);
+      } else {
+        let path = '/api/v1/ai-quant/risk-status';
+        if (options?.strategyId) {
+          path += `?strategyId=${options.strategyId}`;
+        }
+
+        const res = await fetch(`https://api.one23.io${path}`);
+        if (res.ok) {
+          const data = await res.json();
+          if (data) {
+            setRiskStatus(mapRiskStatus(data));
+          }
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to fetch risk status');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [options?.simulation, options?.strategyId]);
+
+  // Initial fetch and polling
+  useEffect(() => {
+    fetchRiskStatus();
+    if (options?.pollInterval) {
+      const timer = setInterval(fetchRiskStatus, options.pollInterval);
+      return () => clearInterval(timer);
+    }
+  }, [fetchRiskStatus, options?.pollInterval]);
+
+  // Actions
+  const pauseTrading = useCallback(async (): Promise<boolean> => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus(prev => ({ ...prev, tradingStatus: 'paused' }));
+        return true;
+      }
+      const res = await fetch('https://api.one23.io/api/v1/ai-quant/trading/pause', {
+        method: 'POST',
+      });
+      if (res.ok) {
+        setRiskStatus(prev => ({ ...prev, tradingStatus: 'paused' }));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+
+  const resumeTrading = useCallback(async (): Promise<boolean> => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus(prev => ({ ...prev, tradingStatus: 'active' }));
+        return true;
+      }
+      const res = await fetch('https://api.one23.io/api/v1/ai-quant/trading/resume', {
+        method: 'POST',
+      });
+      if (res.ok) {
+        setRiskStatus(prev => ({ ...prev, tradingStatus: 'active' }));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+
+  const resetDailyLimits = useCallback(async (): Promise<boolean> => {
+    try {
+      if (options?.simulation) {
+        setRiskStatus(prev => ({
+          ...prev,
+          dailyPnl: 0,
+          dailyPnlPercent: 0,
+          dailyTradeCount: 0,
+          warnings: prev.warnings.filter(w => !w.includes('Daily')),
+        }));
+        return true;
+      }
+      const res = await fetch('https://api.one23.io/api/v1/ai-quant/risk/reset-daily', {
+        method: 'POST',
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [options?.simulation]);
+
+  // Computed values
+  const isWithinLimits = useMemo(() => {
+    return (
+      riskStatus.exposurePercent < 90 &&
+      riskStatus.drawdownPercent < 90 &&
+      riskStatus.dailyPnlPercent < 90 &&
+      riskStatus.openPositions < riskStatus.maxPositions
+    );
+  }, [riskStatus]);
+
+  const canTrade = useMemo(() => {
+    return riskStatus.tradingStatus === 'active' && isWithinLimits;
+  }, [riskStatus.tradingStatus, isWithinLimits]);
+
+  return {
+    riskStatus,
+    isLoading,
+    error,
+    refresh: fetchRiskStatus,
+    isWithinLimits,
+    canTrade,
+    riskLevel: riskStatus.riskLevel,
+    tradingStatus: riskStatus.tradingStatus,
+    warnings: riskStatus.warnings,
+    pauseTrading,
+    resumeTrading,
+    resetDailyLimits,
+  };
+}
+
+// ── Helper Functions ──────────────────────────────────────────────────────────
+
+function mapRiskStatus(raw: any): RiskStatus {
+  const exposurePercent = raw.maxExposure > 0
+    ? (raw.totalExposure / raw.maxExposure) * 100
+    : 0;
+  const dailyPnlPercent = raw.dailyPnlLimit > 0
+    ? (Math.abs(raw.dailyPnl) / raw.dailyPnlLimit) * 100
+    : 0;
+  const drawdownPercent = raw.maxDrawdown > 0
+    ? (raw.currentDrawdown / raw.maxDrawdown) * 100
+    : 0;
+
+  return {
+    timestamp: raw.timestamp ?? Date.now(),
+    totalExposure: raw.totalExposure ?? raw.total_exposure ?? 0,
+    maxExposure: raw.maxExposure ?? raw.max_exposure ?? 100000,
+    exposurePercent,
+    dailyPnl: raw.dailyPnl ?? raw.daily_pnl ?? 0,
+    dailyPnlLimit: raw.dailyPnlLimit ?? raw.daily_pnl_limit ?? 5000,
+    dailyPnlPercent,
+    dailyTradeCount: raw.dailyTradeCount ?? raw.daily_trade_count ?? 0,
+    dailyTradeLimit: raw.dailyTradeLimit ?? raw.daily_trade_limit ?? 50,
+    currentDrawdown: raw.currentDrawdown ?? raw.current_drawdown ?? 0,
+    maxDrawdown: raw.maxDrawdown ?? raw.max_drawdown ?? 15,
+    drawdownPercent,
+    openPositions: raw.openPositions ?? raw.open_positions ?? 0,
+    maxPositions: raw.maxPositions ?? raw.max_positions ?? 10,
+    riskLevel: raw.riskLevel ?? raw.risk_level ?? calculateRiskLevel(exposurePercent, drawdownPercent, dailyPnlPercent),
+    tradingStatus: raw.tradingStatus ?? raw.trading_status ?? 'active',
+    warnings: raw.warnings ?? [],
+    strategyRisks: raw.strategyRisks ?? raw.strategy_risks,
+  };
+}