hedgequantx 2.5.15 → 2.5.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.5.15",
+  "version": "2.5.16",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/menus/dashboard.js

@@ -22,6 +22,9 @@ const dashboardMenu = async (service) => {
   const boxWidth = getLogoWidth();
   const W = boxWidth - 2;
   
+  // Check AI connection status
+  const aiConnected = aiService.isConnected();
+  
   const makeLine = (content, align = 'left') => {
     const plainLen = content.replace(/\x1b\[[0-9;]*m/g, '').length;
     const padding = W - plainLen;

package/src/pages/algo/copy-trading.js

@@ -330,12 +330,33 @@ const launchCopyTrading = async (config) => {
         if (!existing && pos.quantity !== 0) {
           // New position opened - copy to follower
           const side = pos.quantity > 0 ? 'LONG' : 'SHORT';
+          const orderSide = pos.quantity > 0 ? 0 : 1; // 0=Buy, 1=Sell
           const symbol = pos.symbol || pos.contractId;
           const size = Math.abs(pos.quantity);
           const entry = pos.averagePrice || 0;
+          
           algoLogger.positionOpened(ui, symbol, side, size, entry);
           algoLogger.info(ui, 'COPYING TO FOLLOWER', `${side} ${size}x ${symbol}`);
-          // TODO: Place order on follower account
+          
+          // Place order on follower account
+          try {
+            const orderResult = await follower.service.placeOrder({
+              accountId: follower.account.accountId,
+              contractId: pos.contractId,
+              type: 2, // Market order
+              side: orderSide,
+              size: follower.contracts
+            });
+            
+            if (orderResult.success) {
+              algoLogger.orderFilled(ui, symbol, side, follower.contracts, entry);
+              algoLogger.info(ui, 'FOLLOWER ORDER', `${side} ${follower.contracts}x filled`);
+            } else {
+              algoLogger.orderRejected(ui, symbol, orderResult.error || 'Order failed');
+            }
+          } catch (err) {
+            algoLogger.error(ui, 'FOLLOWER ORDER FAILED', err.message);
+          }
         }
       }
       
@@ -344,13 +365,44 @@ const launchCopyTrading = async (config) => {
         const stillOpen = currentPositions.find(p => p.contractId === oldPos.contractId);
         if (!stillOpen || stillOpen.quantity === 0) {
           const side = oldPos.quantity > 0 ? 'LONG' : 'SHORT';
+          const closeSide = oldPos.quantity > 0 ? 1 : 0; // Opposite side to close
           const symbol = oldPos.symbol || oldPos.contractId;
           const size = Math.abs(oldPos.quantity);
           const exit = stillOpen?.averagePrice || oldPos.averagePrice || 0;
           const pnl = oldPos.profitAndLoss || 0;
+          
           algoLogger.positionClosed(ui, symbol, side, size, exit, pnl);
           algoLogger.info(ui, 'CLOSING ON FOLLOWER', symbol);
-          // TODO: Close position on follower account
+          
+          // Close position on follower account
+          try {
+            // First try closePosition API
+            const closeResult = await follower.service.closePosition(
+              follower.account.accountId,
+              oldPos.contractId
+            );
+            
+            if (closeResult.success) {
+              algoLogger.info(ui, 'FOLLOWER CLOSED', `${symbol} position closed`);
+            } else {
+              // Fallback: place market order to close
+              const orderResult = await follower.service.placeOrder({
+                accountId: follower.account.accountId,
+                contractId: oldPos.contractId,
+                type: 2, // Market order
+                side: closeSide,
+                size: follower.contracts
+              });
+              
+              if (orderResult.success) {
+                algoLogger.info(ui, 'FOLLOWER CLOSED', `${symbol} via market order`);
+              } else {
+                algoLogger.error(ui, 'FOLLOWER CLOSE FAILED', orderResult.error || 'Close failed');
+              }
+            }
+          } catch (err) {
+            algoLogger.error(ui, 'FOLLOWER CLOSE ERROR', err.message);
+          }
         }
       }
       

package/src/pages/algo/index.js

@@ -182,7 +182,7 @@ const startAISupervised = async (service, agent) => {
     
     await prompts.waitForEnter();
     
-    // Start the algo (placeholder for real implementation)
+    // Launch algo trading with AI supervision active
     return await oneAccountMenu(service);
     
   } else {

package/src/pages/stats.js

@@ -14,6 +14,8 @@ const asciichart = require('asciichart');
 const { connections } = require('../services');
 const { getLogoWidth, visibleLength, drawBoxHeader, drawBoxFooter, getColWidths, draw2ColHeader, draw2ColSeparator, fmtRow } = require('../ui');
 const { prompts } = require('../utils');
+const aiService = require('../services/ai');
+const AISupervisor = require('../services/ai/supervisor');
 
 /**
  * Show Stats Page
@@ -383,6 +385,56 @@ const showStats = async (service) => {
     
     drawBoxFooter(boxWidth);
     
+    // ========== AI SUPERVISION ==========
+    const aiAgents = aiService.getAgents();
+    const supervisionStatus = AISupervisor.getAllStatus();
+    
+    if (aiAgents.length > 0) {
+      console.log();
+      drawBoxHeader('AI SUPERVISION', boxWidth);
+      draw2ColHeader('AGENTS', 'PERFORMANCE', boxWidth);
+      
+      // Agent info
+      const activeAgent = aiService.getActiveAgent();
+      const agentNames = aiAgents.map(a => a.name).join(', ');
+      const agentMode = aiAgents.length >= 2 ? 'CONSENSUS' : 'INDIVIDUAL';
+      const modeColor = aiAgents.length >= 2 ? chalk.magenta : chalk.cyan;
+      
+      // Supervision metrics
+      let totalDecisions = 0;
+      let totalInterventions = 0;
+      let totalOptimizations = 0;
+      let totalRiskWarnings = 0;
+      let totalSessionTime = 0;
+      
+      for (const status of supervisionStatus) {
+        if (status.active) {
+          totalDecisions += status.metrics?.totalDecisions || 0;
+          totalInterventions += status.metrics?.interventions || 0;
+          totalOptimizations += status.metrics?.optimizations || 0;
+          totalRiskWarnings += status.metrics?.riskWarnings || 0;
+          totalSessionTime += status.duration || 0;
+        }
+      }
+      
+      const sessionTimeStr = totalSessionTime > 0 
+        ? Math.floor(totalSessionTime / 60000) + 'm ' + Math.floor((totalSessionTime % 60000) / 1000) + 's'
+        : 'INACTIVE';
+      
+      // Get real supervision data
+      const supervisionData = AISupervisor.getAggregatedData();
+      const supervisedAccounts = supervisionData.totalAccounts;
+      const supervisedPnL = supervisionData.totalPnL;
+      
+      console.log(chalk.cyan('\u2551') + fmtRow('CONNECTED AGENTS:', chalk.green(String(aiAgents.length)), col1) + chalk.cyan('\u2502') + fmtRow('SUPERVISED ACCOUNTS:', supervisedAccounts > 0 ? chalk.white(String(supervisedAccounts)) : chalk.gray('0'), col2) + chalk.cyan('\u2551'));
+      console.log(chalk.cyan('\u2551') + fmtRow('MODE:', modeColor(agentMode), col1) + chalk.cyan('\u2502') + fmtRow('SUPERVISED P&L:', supervisedPnL !== 0 ? (supervisedPnL >= 0 ? chalk.green('$' + supervisedPnL.toFixed(2)) : chalk.red('$' + supervisedPnL.toFixed(2))) : chalk.gray('$0.00'), col2) + chalk.cyan('\u2551'));
+      console.log(chalk.cyan('\u2551') + fmtRow('ACTIVE:', activeAgent ? chalk.green(activeAgent.name) : chalk.gray('NONE'), col1) + chalk.cyan('\u2502') + fmtRow('POSITIONS:', chalk.white(String(supervisionData.totalPositions)), col2) + chalk.cyan('\u2551'));
+      console.log(chalk.cyan('\u2551') + fmtRow('SESSION TIME:', chalk.white(sessionTimeStr), col1) + chalk.cyan('\u2502') + fmtRow('OPEN ORDERS:', chalk.white(String(supervisionData.totalOrders)), col2) + chalk.cyan('\u2551'));
+      console.log(chalk.cyan('\u2551') + fmtRow('AGENTS:', chalk.gray(agentNames.substring(0, col1 - 10)), col1) + chalk.cyan('\u2502') + fmtRow('TRADES TODAY:', chalk.white(String(supervisionData.totalTrades)), col2) + chalk.cyan('\u2551'));
+      
+      drawBoxFooter(boxWidth);
+    }
+    
     // ========== EQUITY CURVE ==========
     console.log();
     drawBoxHeader('EQUITY CURVE', boxWidth);

package/src/services/ai/client.js

@@ -0,0 +1,281 @@
+/**
+ * AI Client - Makes real API calls to AI providers
+ * 
+ * STRICT RULE: No mock responses. Real API calls only.
+ * If API fails → return null, not fake data.
+ */
+
+const https = require('https');
+const http = require('http');
+const { getProvider } = require('./providers');
+
+/**
+ * Make HTTP request to AI provider
+ * @param {string} url - Full URL
+ * @param {Object} options - Request options
+ * @returns {Promise<Object>} Response data
+ */
+const makeRequest = (url, options) => {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+    
+    const req = protocol.request(url, {
+      method: options.method || 'POST',
+      headers: options.headers || {},
+      timeout: options.timeout || 30000
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else {
+            reject(new Error(json.error?.message || `HTTP ${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(new Error(`Invalid JSON response: ${data.substring(0, 100)}`));
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => reject(new Error('Request timeout')));
+    
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+    req.end();
+  });
+};
+
+/**
+ * Call OpenAI-compatible API
+ * Works with: OpenAI, Groq, Together, DeepSeek, Mistral, xAI, etc.
+ * @param {Object} agent - Agent configuration
+ * @param {string} prompt - User prompt
+ * @param {string} systemPrompt - System prompt
+ * @returns {Promise<string|null>} Response text or null on error
+ */
+const callOpenAICompatible = async (agent, prompt, systemPrompt) => {
+  const provider = getProvider(agent.providerId);
+  if (!provider) return null;
+  
+  const endpoint = agent.credentials?.endpoint || provider.endpoint;
+  const apiKey = agent.credentials?.apiKey;
+  const model = agent.model || provider.defaultModel;
+  
+  if (!apiKey && provider.category !== 'local') {
+    return null;
+  }
+  
+  const url = `${endpoint}/chat/completions`;
+  
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+  
+  if (apiKey) {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+  
+  // OpenRouter requires additional headers
+  if (agent.providerId === 'openrouter') {
+    headers['HTTP-Referer'] = 'https://hedgequantx.com';
+    headers['X-Title'] = 'HQX-CLI';
+  }
+  
+  const body = {
+    model,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: prompt }
+    ],
+    temperature: 0.3,
+    max_tokens: 500
+  };
+  
+  try {
+    const response = await makeRequest(url, { headers, body, timeout: 30000 });
+    return response.choices?.[0]?.message?.content || null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Call Anthropic Claude API
+ * @param {Object} agent - Agent configuration
+ * @param {string} prompt - User prompt
+ * @param {string} systemPrompt - System prompt
+ * @returns {Promise<string|null>} Response text or null on error
+ */
+const callAnthropic = async (agent, prompt, systemPrompt) => {
+  const provider = getProvider('anthropic');
+  if (!provider) return null;
+  
+  const apiKey = agent.credentials?.apiKey;
+  const model = agent.model || provider.defaultModel;
+  
+  if (!apiKey) return null;
+  
+  const url = `${provider.endpoint}/messages`;
+  
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01'
+  };
+  
+  const body = {
+    model,
+    max_tokens: 500,
+    system: systemPrompt,
+    messages: [
+      { role: 'user', content: prompt }
+    ]
+  };
+  
+  try {
+    const response = await makeRequest(url, { headers, body, timeout: 30000 });
+    return response.content?.[0]?.text || null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Call Google Gemini API
+ * @param {Object} agent - Agent configuration
+ * @param {string} prompt - User prompt
+ * @param {string} systemPrompt - System prompt
+ * @returns {Promise<string|null>} Response text or null on error
+ */
+const callGemini = async (agent, prompt, systemPrompt) => {
+  const provider = getProvider('gemini');
+  if (!provider) return null;
+  
+  const apiKey = agent.credentials?.apiKey;
+  const model = agent.model || provider.defaultModel;
+  
+  if (!apiKey) return null;
+  
+  const url = `${provider.endpoint}/models/${model}:generateContent?key=${apiKey}`;
+  
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+  
+  const body = {
+    contents: [
+      { role: 'user', parts: [{ text: `${systemPrompt}\n\n${prompt}` }] }
+    ],
+    generationConfig: {
+      temperature: 0.3,
+      maxOutputTokens: 500
+    }
+  };
+  
+  try {
+    const response = await makeRequest(url, { headers, body, timeout: 30000 });
+    return response.candidates?.[0]?.content?.parts?.[0]?.text || null;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * Call AI provider based on agent configuration
+ * @param {Object} agent - Agent with providerId and credentials
+ * @param {string} prompt - User prompt
+ * @param {string} systemPrompt - System prompt
+ * @returns {Promise<string|null>} AI response or null on error
+ */
+const callAI = async (agent, prompt, systemPrompt = '') => {
+  if (!agent || !agent.providerId) return null;
+  
+  switch (agent.providerId) {
+    case 'anthropic':
+      return callAnthropic(agent, prompt, systemPrompt);
+    
+    case 'gemini':
+      return callGemini(agent, prompt, systemPrompt);
+    
+    // All OpenAI-compatible APIs
+    case 'openai':
+    case 'openrouter':
+    case 'deepseek':
+    case 'groq':
+    case 'xai':
+    case 'mistral':
+    case 'perplexity':
+    case 'together':
+    case 'qwen':
+    case 'moonshot':
+    case 'yi':
+    case 'zhipu':
+    case 'baichuan':
+    case 'ollama':
+    case 'lmstudio':
+    case 'custom':
+      return callOpenAICompatible(agent, prompt, systemPrompt);
+    
+    default:
+      return null;
+  }
+};
+
+/**
+ * Analyze trading data with AI
+ * @param {Object} agent - AI agent
+ * @param {Object} data - Trading data from APIs
+ * @returns {Promise<Object|null>} Analysis result or null
+ */
+const analyzeTrading = async (agent, data) => {
+  if (!agent || !data) return null;
+  
+  const systemPrompt = `You are a professional trading analyst for prop firm futures trading.
+Analyze the provided real-time trading data and provide actionable insights.
+Be concise. Focus on risk management and optimization.
+Respond in JSON format with: { "action": "HOLD|REDUCE_SIZE|PAUSE|CONTINUE", "confidence": 0-100, "reason": "brief reason" }`;
+  
+  const prompt = `Current trading session data:
+- Account Balance: ${data.account?.balance ?? 'N/A'}
+- Today P&L: ${data.account?.profitAndLoss ?? 'N/A'}
+- Open Positions: ${data.positions?.length ?? 0}
+- Open Orders: ${data.orders?.length ?? 0}
+- Today Trades: ${data.trades?.length ?? 0}
+
+${data.positions?.length > 0 ? `Positions: ${JSON.stringify(data.positions.map(p => ({
+  symbol: p.symbol || p.contractId,
+  qty: p.quantity,
+  pnl: p.profitAndLoss
+})))}` : ''}
+
+Analyze and provide recommendation.`;
+
+  try {
+    const response = await callAI(agent, prompt, systemPrompt);
+    if (!response) return null;
+    
+    // Try to parse JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  callAI,
+  analyzeTrading,
+  callOpenAICompatible,
+  callAnthropic,
+  callGemini
+};

package/src/services/ai/index.js

@@ -214,36 +214,9 @@ const addAgent = async (providerId, optionId, credentials, model = null, customN
   
   saveAISettings(aiSettings);
   
-  // Start AI supervision automatically
+  // Agent is ready - supervision will start when algo trading begins
+  // Supervision requires a real service connection and account
   const agent = getAgent(agentId);
-  if (agent) {
-    // Mock algo target - in real implementation, this would be HQX Ultra Scalping
-    const mockAlgo = {
-      name: 'HQX Ultra Scalping',
-      status: 'ready',
-      active: false
-    };
-    
-    // Check if other agents are already supervising
-    const allAgents = getAgents();
-    const activeSupervisionCount = allAgents.filter(a => a.id !== agentId && a.isActive).length;
-    
-    if (activeSupervisionCount === 0) {
-      // First agent - start single supervision
-      AISupervisor.start(agentId, mockAlgo);
-      console.log(`\n🤖 AI supervision started for ${agent.name}`);
-      console.log(`   Monitoring: HQX Ultra Scalping`);
-      console.log(`   Mode: Single agent supervision`);
-    } else {
-      // Additional agent - switch to consensus mode
-      console.log(`\n🤖 ${agent.name} added to supervision`);
-      console.log(`   Switching to multi-agent consensus mode`);
-      console.log(`   Total agents: ${allAgents.length}`);
-      
-      // Start consensus mode would be handled by supervisor
-      AISupervisor.start(agentId, mockAlgo);
-    }
-  }
   
   return agent;
 };