hedgequantx 2.7.99 → 2.8.0

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

@@ -0,0 +1,167 @@
+/**
+ * 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/health.js

@@ -0,0 +1,288 @@
+/**
+ * AI Supervision Health Check
+ * 
+ * Verifies that AI agents are properly connected and responding
+ * before allowing algo trading with AI supervision.
+ * 
+ * Two verification points:
+ * 1. [T] TEST in AI Agents menu - manual verification
+ * 2. Pre-check before algo launch - automatic verification
+ */
+
+const cliproxy = require('../cliproxy');
+
+/** Test prompt to verify agent understands directive format */
+const TEST_PROMPT = `You are being tested. Respond ONLY with this exact JSON, nothing else:
+{"decision":"approve","confidence":100,"reason":"test-ok"}`;
+
+/** Timeout for agent response (agents should respond in < 1 second) */
+const AGENT_TIMEOUT = 2000;
+
+/**
+ * Check if CLIProxy is running and responding
+ * @returns {Promise<Object>} { success, latency, error }
+ */
+const checkCliproxyRunning = async () => {
+  const startTime = Date.now();
+  
+  try {
+    const status = await cliproxy.isRunning();
+    const latency = Date.now() - startTime;
+    
+    if (status.running) {
+      return { success: true, latency, error: null };
+    }
+    
+    return { success: false, latency, error: 'CLIProxy not running' };
+  } catch (error) {
+    return { success: false, latency: Date.now() - startTime, error: error.message };
+  }
+};
+
+/**
+ * Test a single agent connection and response format
+ * @param {Object} agent - Agent config { id, provider, modelId, connectionType, ... }
+ * @returns {Promise<Object>} { success, latency, formatValid, error }
+ */
+const testAgentConnection = async (agent) => {
+  const startTime = Date.now();
+  
+  try {
+    // Only test CLIProxy connections for now
+    if (agent.connectionType !== 'cliproxy') {
+      // For API key connections, we would need different logic
+      // For now, mark as needing CLIProxy
+      return {
+        success: false,
+        latency: 0,
+        formatValid: false,
+        error: 'Only CLIProxy connections supported for pre-check'
+      };
+    }
+    
+    // Send test prompt with short timeout
+    const result = await cliproxy.chat(agent.provider, agent.modelId, TEST_PROMPT, AGENT_TIMEOUT);
+    const latency = Date.now() - startTime;
+    
+    if (!result.success) {
+      return {
+        success: false,
+        latency,
+        formatValid: false,
+        error: result.error || 'No response from agent'
+      };
+    }
+    
+    // Validate response format
+    const formatResult = validateResponseFormat(result.content);
+    
+    return {
+      success: formatResult.valid,
+      latency,
+      formatValid: formatResult.valid,
+      error: formatResult.valid ? null : formatResult.error,
+      response: result.content
+    };
+    
+  } catch (error) {
+    return {
+      success: false,
+      latency: Date.now() - startTime,
+      formatValid: false,
+      error: error.message || 'Connection failed'
+    };
+  }
+};
+
+/**
+ * Validate that response matches expected JSON format
+ * @param {string} content - Response content from agent
+ * @returns {Object} { valid, error }
+ */
+const validateResponseFormat = (content) => {
+  if (!content) {
+    return { valid: false, error: 'Empty response' };
+  }
+  
+  try {
+    // Try to extract JSON from response
+    let json;
+    
+    // Direct parse
+    try {
+      json = JSON.parse(content.trim());
+    } catch (e) {
+      // Try to find JSON in response
+      const match = content.match(/\{[\s\S]*\}/);
+      if (match) {
+        json = JSON.parse(match[0]);
+      } else {
+        return { valid: false, error: 'No JSON in response' };
+      }
+    }
+    
+    // Check required fields
+    if (!json.decision) {
+      return { valid: false, error: 'Missing "decision" field' };
+    }
+    
+    if (json.confidence === undefined) {
+      return { valid: false, error: 'Missing "confidence" field' };
+    }
+    
+    if (!json.reason) {
+      return { valid: false, error: 'Missing "reason" field' };
+    }
+    
+    // Validate decision value
+    const validDecisions = ['approve', 'reject', 'modify'];
+    if (!validDecisions.includes(json.decision)) {
+      return { valid: false, error: `Invalid decision: ${json.decision}` };
+    }
+    
+    // Validate confidence is number 0-100
+    const conf = Number(json.confidence);
+    if (isNaN(conf) || conf < 0 || conf > 100) {
+      return { valid: false, error: `Invalid confidence: ${json.confidence}` };
+    }
+    
+    return { valid: true, error: null };
+    
+  } catch (error) {
+    return { valid: false, error: `Parse error: ${error.message}` };
+  }
+};
+
+/**
+ * Run pre-flight check on all agents
+ * @param {Array} agents - Array of agent configs
+ * @returns {Promise<Object>} { success, cliproxy, agents, summary }
+ */
+const runPreflightCheck = async (agents) => {
+  const results = {
+    success: false,
+    cliproxy: null,
+    agents: [],
+    summary: { total: 0, passed: 0, failed: 0 }
+  };
+  
+  // Step 1: Check CLIProxy
+  results.cliproxy = await checkCliproxyRunning();
+  
+  if (!results.cliproxy.success) {
+    results.summary.total = agents.length;
+    results.summary.failed = agents.length;
+    return results;
+  }
+  
+  // Step 2: Test each agent
+  results.summary.total = agents.length;
+  
+  for (const agent of agents) {
+    const agentResult = await testAgentConnection(agent);
+    
+    results.agents.push({
+      id: agent.id,
+      name: agent.name,
+      provider: agent.provider,
+      modelId: agent.modelId,
+      ...agentResult
+    });
+    
+    if (agentResult.success) {
+      results.summary.passed++;
+    } else {
+      results.summary.failed++;
+    }
+  }
+  
+  // Success only if ALL agents pass
+  results.success = results.summary.failed === 0 && results.summary.passed > 0;
+  
+  return results;
+};
+
+/**
+ * Format pre-flight results for console display
+ * @param {Object} results - Results from runPreflightCheck
+ * @param {number} boxWidth - Width for formatting
+ * @returns {Array<string>} Lines to display
+ */
+const formatPreflightResults = (results, boxWidth) => {
+  const chalk = require('chalk');
+  const lines = [];
+  const W = boxWidth - 2;
+  
+  // CLIProxy status
+  if (results.cliproxy.success) {
+    lines.push(chalk.white('  CLIProxy Status') + chalk.gray('.'.repeat(Math.max(1, W - 35))) + chalk.green(' ✓ RUNNING'));
+  } else {
+    lines.push(chalk.white('  CLIProxy Status') + chalk.gray('.'.repeat(Math.max(1, W - 35))) + chalk.red(' ✗ NOT RUNNING'));
+    lines.push(chalk.red(`  Error: ${results.cliproxy.error}`));
+    return lines;
+  }
+  
+  lines.push('');
+  lines.push(chalk.white(`  Testing ${results.summary.total} agent(s):`));
+  lines.push('');
+  
+  // Each agent
+  for (let i = 0; i < results.agents.length; i++) {
+    const agent = results.agents[i];
+    const num = `[${i + 1}/${results.summary.total}]`;
+    
+    lines.push(chalk.cyan(`  ${num} ${agent.name} (${agent.modelId || agent.provider})`));
+    
+    if (agent.success) {
+      const latencyStr = `${agent.latency}ms`;
+      lines.push(chalk.gray('        Connection') + chalk.gray('.'.repeat(Math.max(1, W - 40))) + chalk.green(` ✓ OK ${latencyStr}`));
+      lines.push(chalk.gray('        Format') + chalk.gray('.'.repeat(Math.max(1, W - 36))) + chalk.green(' ✓ VALID'));
+    } else {
+      lines.push(chalk.gray('        Connection') + chalk.gray('.'.repeat(Math.max(1, W - 38))) + chalk.red(' ✗ FAILED'));
+      lines.push(chalk.red(`        Error: ${agent.error}`));
+    }
+    
+    lines.push('');
+  }
+  
+  return lines;
+};
+
+/**
+ * Get summary line for pre-flight results
+ * @param {Object} results - Results from runPreflightCheck
+ * @returns {Object} { text, success }
+ */
+const getPreflightSummary = (results) => {
+  const chalk = require('chalk');
+  
+  if (!results.cliproxy.success) {
+    return {
+      text: chalk.red('✗ CLIProxy not running - cannot verify agents'),
+      success: false
+    };
+  }
+  
+  if (results.success) {
+    return {
+      text: chalk.green(`✓ ALL SYSTEMS GO - ${results.summary.passed}/${results.summary.total} agents ready`),
+      success: true
+    };
+  }
+  
+  return {
+    text: chalk.red(`✗ FAILED - ${results.summary.passed}/${results.summary.total} agents passed (all must pass)`),
+    success: false
+  };
+};
+
+module.exports = {
+  checkCliproxyRunning,
+  testAgentConnection,
+  validateResponseFormat,
+  runPreflightCheck,
+  formatPreflightResults,
+  getPreflightSummary,
+  TEST_PROMPT,
+  AGENT_TIMEOUT
+};