hedgequantx 2.9.18 → 2.9.20

package/src/services/ai-supervision/directive.js

@@ -1,167 +0,0 @@
-/**
- * AI Supervision Directive - The 7 Phases
- * 
- * This directive is sent to ALL AI agents for trading supervision.
- * Each agent receives the same instructions and analyzes signals in parallel.
- */
-
-const DIRECTIVE_PHASES = {
-  phase1_strategy: `
-## PHASE 1: MAÎTRISER LA STRATÉGIE
-Tu connais cette stratégie par coeur. Tu sais exactement:
-- Les conditions d'entrée (setup patterns, confirmations requises)
-- Les règles de sortie (targets, stops, trailing)
-- La gestion du risque (sizing, max loss, drawdown limits)
-- Les filtres de marché (sessions, volatilité, corrélations)
-Tu ne devines jamais. Tu appliques la stratégie avec précision chirurgicale.
-`,
-
-  phase2_role: `
-## PHASE 2: TON RÔLE
-Tu es une arme de précision intégrée à l'algo de trading.
-Tu n'es PAS un conseiller - tu es un avantage décisif.
-Ton job: optimiser chaque signal pour maximiser le edge.
-Tu travailles EN TEMPS RÉEL avec latence minimale.
-Chaque milliseconde compte. Chaque tick compte.
-`,
-
-  phase3_analysis: `
-## PHASE 3: CE QUE TU ANALYSES
-Pour chaque signal reçu, tu analyses:
-- DOM (Depth of Market): déséquilibres bid/ask, absorption, spoofing
-- Order Flow: delta, CVD, volume profile, footprint
-- Manipulations: stop hunts, fakeouts, liquidity grabs
-- Patterns: structure de marché, S/R, pivots, VWAP
-- Historique: trades récents, winrate par setup, performance horaire
-- Corrélations: autres symboles liés (ES/NQ, GC/SI, etc.)
-`,
-
-  phase4_output: `
-## PHASE 4: CE QUE TU FOURNIS
-Pour chaque signal, tu retournes:
-1. DECISION: approve/reject/modify
-2. CONFIDENCE: score 0-100
-3. OPTIMIZATIONS (si approve/modify):
-   - entry: prix d'entrée optimisé (ou null)
-   - stopLoss: stop optimisé (ou null)
-   - takeProfit: target optimisé (ou null)
-   - size: ajustement de taille (-50% à +50%)
-   - timing: "now" | "wait" | "cancel"
-4. REASON: explication courte (max 50 chars)
-5. ALERTS: warnings importants (optionnel)
-`,
-
-  phase5_restrictions: `
-## PHASE 5: CE QUE TU NE FAIS JAMAIS
-- Tu ne BLOQUES jamais l'algo sans raison valide
-- Tu ne RALENTIS jamais l'exécution (réponse < 2 secondes)
-- Tu ne fais pas de VAGUE - décision claire et directe
-- Tu n'INVENTES pas de données - utilise uniquement ce qui est fourni
-- Tu ne CHANGES pas la stratégie - tu l'optimises dans ses règles
-`,
-
-  phase6_symbols: `
-## PHASE 6: CONNAISSANCE DES SYMBOLES
-Tu trades ces symboles avec leurs caractéristiques:
-- NQ (Nasdaq): volatile, tech-driven, corrélé ES
-- ES (S&P500): référence, plus stable, leader
-- YM (Dow): value stocks, moins volatile
-- RTY (Russell): small caps, plus volatile que ES
-- GC (Gold): safe haven, inverse USD, sessions Asia/London
-- SI (Silver): suit GC avec plus de volatilité
-- CL (Crude): news-driven, inventories, géopolitique
-
-Sessions importantes:
-- Asia: 18:00-03:00 ET (GC/SI actifs)
-- London: 03:00-08:00 ET (préparation US)
-- US Open: 09:30-11:30 ET (max volatilité)
-- US Close: 15:00-16:00 ET (rebalancing)
-`,
-
-  phase7_mindset: `
-## PHASE 7: TA MENTALITÉ
-- OBJECTIF: Gagner. Pas "essayer". Gagner.
-- PRÉCISION: Chaque décision compte
-- RAPIDITÉ: Temps = argent. Sois rapide.
-- RESPONSABILITÉ: Tu assumes tes recommandations
-- ADAPTATION: Le marché change, tu t'adaptes
-- DISCIPLINE: Les règles sont les règles
-`
-};
-
-/**
- * Build the complete directive string
- */
-const buildDirective = () => {
-  return Object.values(DIRECTIVE_PHASES).join('\n');
-};
-
-/**
- * Expected output format from AI agents
- */
-const OUTPUT_FORMAT = {
-  schema: {
-    decision: 'approve | reject | modify',
-    confidence: 'number 0-100',
-    optimizations: {
-      entry: 'number | null',
-      stopLoss: 'number | null',
-      takeProfit: 'number | null',
-      size: 'number (-0.5 to 0.5) | null',
-      timing: 'now | wait | cancel'
-    },
-    reason: 'string (max 50 chars)',
-    alerts: 'string[] | null'
-  },
-  example: {
-    decision: 'modify',
-    confidence: 85,
-    optimizations: {
-      entry: 21450.25,
-      stopLoss: 21445.00,
-      takeProfit: 21462.50,
-      size: 0,
-      timing: 'now'
-    },
-    reason: 'Strong bid stack, tighten stop',
-    alerts: null
-  }
-};
-
-/**
- * Build the output format instructions
- */
-const buildOutputInstructions = () => {
-  return `
-## OUTPUT FORMAT (JSON STRICT)
-Tu dois TOUJOURS répondre en JSON valide avec ce format exact:
-
-\`\`\`json
-${JSON.stringify(OUTPUT_FORMAT.example, null, 2)}
-\`\`\`
-
-IMPORTANT:
-- decision: "approve" (exécuter tel quel), "reject" (ne pas exécuter), "modify" (exécuter avec optimisations)
-- confidence: 0-100, ton niveau de confiance dans la décision
-- optimizations: null si decision="reject", sinon les ajustements
-- size: 0 = garder la taille, -0.5 = réduire de 50%, +0.5 = augmenter de 50%
-- timing: "now" = exécuter immédiatement, "wait" = attendre meilleur prix, "cancel" = annuler
-- reason: TOUJOURS fournir une raison courte
-- Pas de texte avant ou après le JSON
-`;
-};
-
-/**
- * Get the complete directive with output format
- */
-const getFullDirective = () => {
-  return buildDirective() + '\n' + buildOutputInstructions();
-};
-
-module.exports = {
-  DIRECTIVE_PHASES,
-  OUTPUT_FORMAT,
-  buildDirective,
-  buildOutputInstructions,
-  getFullDirective
-};

package/src/services/ai-supervision/index.js

@@ -1,309 +0,0 @@
-/**
- * AI Supervision Engine - Main Entry Point
- * 
- * Orchestrates multi-agent AI supervision for trading signals.
- * Sends signals to all active agents in parallel and calculates
- * weighted consensus for final decision.
- */
-
-const { getFullDirective } = require('./directive');
-const { buildMarketContext, formatContextForPrompt } = require('./context');
-const { parseAgentResponse } = require('./parser');
-const { calculateConsensus, isApproved, applyOptimizations } = require('./consensus');
-const { runPreflightCheck, formatPreflightResults, getPreflightSummary } = require('./health');
-const cliproxy = require('../cliproxy');
-
-/**
- * SupervisionEngine class - manages multi-agent supervision
- */
-class SupervisionEngine {
-  constructor(config = {}) {
-    this.agents = config.agents || [];
-    this.timeout = config.timeout || 30000;
-    this.minAgents = config.minAgents || 1;
-    this.directive = getFullDirective();
-    this.activeAgents = new Map();
-    this.rateLimitedAgents = new Set();
-    
-    // Initialize active agents
-    for (const agent of this.agents) {
-      if (agent.active) {
-        this.activeAgents.set(agent.id, agent);
-      }
-    }
-  }
-
-  /**
-   * Get count of active (non-rate-limited) agents
-   */
-  getActiveCount() {
-    return this.activeAgents.size - this.rateLimitedAgents.size;
-  }
-
-  /**
-   * Check if supervision is available
-   */
-  isAvailable() {
-    return this.getActiveCount() >= this.minAgents;
-  }
-
-  /**
-   * Mark agent as rate limited
-   */
-  markRateLimited(agentId) {
-    this.rateLimitedAgents.add(agentId);
-  }
-
-  /**
-   * Reset rate limited agents (call periodically)
-   */
-  resetRateLimits() {
-    this.rateLimitedAgents.clear();
-  }
-
-  /**
-   * Build prompt for AI agent
-   */
-  buildPrompt(context) {
-    const contextStr = formatContextForPrompt(context);
-    return `${this.directive}\n\n${contextStr}\n\nAnalyze this signal and respond with JSON only.`;
-  }
-
-  /**
-   * Query a single agent
-   */
-  async queryAgent(agent, prompt) {
-    const startTime = Date.now();
-    
-    try {
-      let response;
-      
-      if (agent.connectionType === 'cliproxy') {
-        // Use CLIProxy API
-        response = await cliproxy.chat(agent.provider, agent.modelId, prompt, this.timeout);
-      } else if (agent.connectionType === 'apikey' && agent.apiKey) {
-        // Direct API call (implement per provider)
-        response = await this.callDirectAPI(agent, prompt);
-      } else {
-        throw new Error('Invalid agent configuration');
-      }
-
-      const latency = Date.now() - startTime;
-      
-      if (!response.success) {
-        // Check for rate limit
-        if (response.error?.includes('rate') || response.error?.includes('limit')) {
-          this.markRateLimited(agent.id);
-        }
-        return { success: false, error: response.error, latency };
-      }
-
-      const parsed = parseAgentResponse(response.content || response.text);
-      
-      return {
-        success: true,
-        response: parsed,
-        latency,
-        raw: response
-      };
-
-    } catch (error) {
-      const latency = Date.now() - startTime;
-      
-      // Check for rate limit errors
-      if (error.message?.includes('429') || error.message?.includes('rate')) {
-        this.markRateLimited(agent.id);
-      }
-      
-      return {
-        success: false,
-        error: error.message,
-        latency
-      };
-    }
-  }
-
-  /**
-   * Direct API call for API key connections
-   */
-  async callDirectAPI(agent, prompt) {
-    // This would be implemented per provider
-    // For now, return error to use CLIProxy instead
-    return {
-      success: false,
-      error: 'Direct API not implemented - use CLIProxy'
-    };
-  }
-
-  /**
-   * Query all agents in parallel
-   */
-  async queryAllAgents(prompt) {
-    const availableAgents = Array.from(this.activeAgents.values())
-      .filter(agent => !this.rateLimitedAgents.has(agent.id));
-
-    if (availableAgents.length === 0) {
-      return [];
-    }
-
-    // Query all agents in parallel with timeout
-    const queries = availableAgents.map(agent => 
-      Promise.race([
-        this.queryAgent(agent, prompt),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('Timeout')), this.timeout)
-        )
-      ]).then(result => ({
-        agentId: agent.id,
-        agentName: agent.name,
-        weight: agent.weight || 100,
-        ...result
-      })).catch(error => ({
-        agentId: agent.id,
-        agentName: agent.name,
-        weight: agent.weight || 100,
-        success: false,
-        error: error.message
-      }))
-    );
-
-    return Promise.all(queries);
-  }
-
-  /**
-   * Main supervision method - analyze a signal
-   */
-  async supervise(params) {
-    const {
-      symbolId,
-      signal,
-      recentTicks = [],
-      recentSignals = [],
-      recentTrades = [],
-      domData = null,
-      position = null,
-      stats = {},
-      config = {}
-    } = params;
-
-    // Check availability
-    if (!this.isAvailable()) {
-      return {
-        success: false,
-        error: 'No agents available',
-        decision: 'approve',
-        reason: 'No AI supervision - passing through'
-      };
-    }
-
-    // Build context and prompt
-    const context = buildMarketContext({
-      symbolId,
-      signal,
-      recentTicks,
-      recentSignals,
-      recentTrades,
-      domData,
-      position,
-      stats,
-      config
-    });
-
-    const prompt = this.buildPrompt(context);
-
-    // Query all agents
-    const results = await this.queryAllAgents(prompt);
-
-    // Filter successful responses
-    const successfulResults = results.filter(r => r.success);
-
-    if (successfulResults.length === 0) {
-      return {
-        success: false,
-        error: 'All agents failed',
-        decision: 'approve',
-        reason: 'Agent errors - passing through',
-        agentResults: results
-      };
-    }
-
-    // Calculate consensus
-    const consensus = calculateConsensus(
-      successfulResults.map(r => ({
-        agentId: r.agentId,
-        response: r.response,
-        weight: r.weight
-      })),
-      { minAgents: this.minAgents }
-    );
-
-    // Apply optimizations if approved
-    const optimizedSignal = isApproved(consensus) 
-      ? applyOptimizations(signal, consensus)
-      : signal;
-
-    return {
-      success: true,
-      decision: consensus.decision,
-      confidence: consensus.confidence,
-      reason: consensus.reason,
-      optimizedSignal,
-      consensus,
-      agentResults: results,
-      context
-    };
-  }
-
-  /**
-   * Get engine status
-   */
-  getStatus() {
-    return {
-      totalAgents: this.agents.length,
-      activeAgents: this.activeAgents.size,
-      rateLimitedAgents: this.rateLimitedAgents.size,
-      availableAgents: this.getActiveCount(),
-      isAvailable: this.isAvailable(),
-      agents: Array.from(this.activeAgents.values()).map(a => ({
-        id: a.id,
-        name: a.name,
-        provider: a.provider,
-        weight: a.weight,
-        rateLimited: this.rateLimitedAgents.has(a.id)
-      }))
-    };
-  }
-
-  /**
-   * Run pre-flight check on all agents
-   * Verifies CLIProxy is running and all agents respond correctly
-   * @returns {Promise<Object>} Pre-flight results
-   */
-  async preflightCheck() {
-    const agents = Array.from(this.activeAgents.values());
-    return runPreflightCheck(agents);
-  }
-}
-
-/**
- * Create supervision engine from config
- */
-const createSupervisionEngine = (config) => {
-  return new SupervisionEngine(config);
-};
-
-module.exports = {
-  SupervisionEngine,
-  createSupervisionEngine,
-  // Re-export utilities
-  buildMarketContext,
-  formatContextForPrompt,
-  parseAgentResponse,
-  calculateConsensus,
-  isApproved,
-  applyOptimizations,
-  // Health check
-  runPreflightCheck,
-  formatPreflightResults,
-  getPreflightSummary
-};