Package Exports

@neural-trader/strategies
@neural-trader/strategies/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@neural-trader/strategies) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

@neural-trader/strategies

Professional-grade trading strategies for the Neural Trader platform, powered by Rust with native Node.js bindings. Implement momentum, mean reversion, arbitrage, and pairs trading strategies with real-time signal generation and subscription capabilities.

Features

Momentum Strategies: Trend-following algorithms with configurable parameters
Mean Reversion: Statistical arbitrage and price reversion detection
Pairs Trading: Cointegration-based pair selection and execution
Arbitrage Detection: Cross-exchange and cross-asset opportunity identification
Real-Time Signals: Subscribe to live trading signals with callbacks
Multi-Strategy Support: Run multiple strategies concurrently
Rust Performance: Microsecond-level signal generation
Backtestable: Full compatibility with @neural-trader/backtesting

Installation

npm install @neural-trader/strategies @neural-trader/core

Quick Start

import { StrategyRunner } from '@neural-trader/strategies';
import type { StrategyConfig, Signal } from '@neural-trader/core';

// Create strategy runner
const runner = new StrategyRunner();

// Add momentum strategy
const momentumConfig: StrategyConfig = {
  name: 'SMA Crossover',
  symbols: ['AAPL', 'MSFT', 'GOOGL'],
  parameters: JSON.stringify({
    shortPeriod: 20,
    longPeriod: 50,
    minVolume: 1000000
  })
};

const strategyId = await runner.addMomentumStrategy(momentumConfig);
console.log(`Strategy added: ${strategyId}`);

// Generate signals
const signals: Signal[] = await runner.generateSignals();
signals.forEach(signal => {
  console.log(`${signal.symbol}: ${signal.direction} (confidence: ${signal.confidence})`);
  console.log(`  Entry: $${signal.entryPrice}, Stop: $${signal.stopLoss}, Target: $${signal.takeProfit}`);
  console.log(`  Reason: ${signal.reasoning}`);
});

// Subscribe to live signals
const subscription = runner.subscribeSignals((signal: Signal) => {
  console.log('New signal received:', signal);
  // Execute trade logic here
});

// Later: Unsubscribe
await subscription.unsubscribe();

In-Depth Usage

Momentum Strategies

Momentum strategies capitalize on trending market movements:

import { StrategyRunner } from '@neural-trader/strategies';

async function setupMomentumStrategy() {
  const runner = new StrategyRunner();

  // Classic SMA crossover strategy
  const smaConfig: StrategyConfig = {
    name: 'SMA 20/50 Crossover',
    symbols: ['AAPL', 'TSLA', 'NVDA'],
    parameters: JSON.stringify({
      shortPeriod: 20,    // Fast moving average
      longPeriod: 50,     // Slow moving average
      minVolume: 1000000, // Minimum daily volume
      atr_multiplier: 2.0 // ATR for stop loss
    })
  };

  const strategyId = await runner.addMomentumStrategy(smaConfig);

  // Strategy generates signals when:
  // - Short SMA crosses above long SMA (bullish)
  // - Short SMA crosses below long SMA (bearish)
  // - Volume confirms the move
  // - ATR-based stop losses are calculated

  return { runner, strategyId };
}

// Advanced momentum: Multiple timeframe analysis
async function multiTimeframeMomentum() {
  const runner = new StrategyRunner();

  const config: StrategyConfig = {
    name: 'Multi-Timeframe Momentum',
    symbols: ['SPY', 'QQQ', 'IWM'],
    parameters: JSON.stringify({
      shortPeriod: 10,
      mediumPeriod: 20,
      longPeriod: 50,
      trend_strength_threshold: 0.7,
      volume_surge_multiplier: 1.5
    })
  };

  await runner.addMomentumStrategy(config);

  // This strategy confirms trends across multiple timeframes
  // Signals only when all timeframes align

  return runner;
}

Mean Reversion Strategies

Mean reversion strategies profit from price returning to average:

async function setupMeanReversionStrategy() {
  const runner = new StrategyRunner();

  // Bollinger Band reversion strategy
  const bbConfig: StrategyConfig = {
    name: 'Bollinger Band Reversion',
    symbols: ['SPY', 'QQQ'],
    parameters: JSON.stringify({
      period: 20,           // BB period
      stdDev: 2.0,          // Standard deviations
      oversold_threshold: 0.1,  // % below lower band
      overbought_threshold: 0.1, // % above upper band
      min_reversion_target: 0.02 // Minimum 2% reversion target
    })
  };

  const strategyId = await runner.addMeanReversionStrategy(bbConfig);

  // Generates signals when:
  // - Price touches or breaks lower band (buy signal)
  // - Price touches or breaks upper band (sell signal)
  // - RSI confirms oversold/overbought
  // - Target is middle or opposite band

  return { runner, strategyId };
}

// RSI-based mean reversion
async function rsiReversionStrategy() {
  const runner = new StrategyRunner();

  const config: StrategyConfig = {
    name: 'RSI Mean Reversion',
    symbols: ['AAPL', 'MSFT', 'GOOGL', 'AMZN'],
    parameters: JSON.stringify({
      rsi_period: 14,
      oversold: 30,
      overbought: 70,
      lookback_period: 50,
      mean_reversion_strength: 0.6
    })
  };

  await runner.addMeanReversionStrategy(config);

  // Signals when RSI extreme and price deviates from mean
  // Filters for high-quality reversion opportunities

  return runner;
}

Pairs Trading Strategies

Statistical arbitrage using correlated assets:

async function setupPairsTradingStrategy() {
  const runner = new StrategyRunner();

  // Classic pairs trading
  const pairsConfig: StrategyConfig = {
    name: 'Pairs Trading',
    symbols: ['PEP,KO', 'XOM,CVX', 'JPM,BAC'], // Comma-separated pairs
    parameters: JSON.stringify({
      lookback: 60,           // Cointegration lookback
      entry_threshold: 2.0,   // Z-score entry
      exit_threshold: 0.5,    // Z-score exit
      stop_threshold: 3.0,    // Max z-score
      min_correlation: 0.7,   // Minimum correlation
      half_life_max: 20       // Maximum half-life (days)
    })
  };

  const strategyId = await runner.addArbitrageStrategy(pairsConfig);

  // Strategy identifies:
  // - Cointegrated pairs
  // - Spread deviations
  // - Entry/exit points
  // - Position sizing for both legs

  return { runner, strategyId };
}

// Real-time pairs monitoring
async function monitorPairsSpreads(runner: StrategyRunner) {
  const subscription = runner.subscribeSignals((signal: Signal) => {
    if (signal.strategyId.includes('pairs')) {
      console.log(`Pairs Signal: ${signal.symbol}`);
      console.log(`Z-Score: ${JSON.parse(signal.reasoning).zscore}`);
      console.log(`Direction: ${signal.direction}`);
      console.log(`Confidence: ${(signal.confidence * 100).toFixed(1)}%`);

      // Execute both legs of the pair
      if (signal.direction === 'long') {
        console.log('  Long: First symbol');
        console.log('  Short: Second symbol');
      } else {
        console.log('  Short: First symbol');
        console.log('  Long: Second symbol');
      }
    }
  });

  return subscription;
}

Arbitrage Strategies

Cross-exchange and cross-asset arbitrage:

async function setupArbitrageStrategy() {
  const runner = new StrategyRunner();

  // Cross-exchange arbitrage
  const arbConfig: StrategyConfig = {
    name: 'Cross-Exchange Arbitrage',
    symbols: ['BTC/USD', 'ETH/USD'],
    parameters: JSON.stringify({
      min_spread: 0.002,      // 0.2% minimum spread
      fee_per_trade: 0.001,   // 0.1% fees
      slippage_buffer: 0.0005, // 0.05% slippage
      execution_time_ms: 1000, // Max execution time
      min_profit_after_costs: 0.001 // 0.1% minimum profit
    })
  };

  await runner.addArbitrageStrategy(arbConfig);

  // Monitors price discrepancies across exchanges
  // Accounts for fees, slippage, and execution time
  // Only signals when profitable after all costs

  return runner;
}

// Statistical arbitrage
async function statArbStrategy() {
  const runner = new StrategyRunner();

  const config: StrategyConfig = {
    name: 'Statistical Arbitrage',
    symbols: ['SPY', 'IVV', 'VOO'], // ETFs tracking same index
    parameters: JSON.stringify({
      cointegration_period: 90,
      zscore_entry: 2.5,
      zscore_exit: 0.0,
      max_holding_period: 5,
      basket_optimization: true
    })
  };

  await runner.addArbitrageStrategy(config);
  return runner;
}

Signal Processing and Filtering

import type { Signal } from '@neural-trader/core';

class SignalProcessor {
  private signals: Signal[] = [];
  private minConfidence: number = 0.7;

  async processSignals(runner: StrategyRunner) {
    const rawSignals = await runner.generateSignals();

    // Filter by confidence
    const highQualitySignals = rawSignals.filter(s => s.confidence >= this.minConfidence);

    // Remove conflicting signals
    const dedupedSignals = this.deduplicateSignals(highQualitySignals);

    // Sort by confidence
    const sortedSignals = dedupedSignals.sort((a, b) => b.confidence - a.confidence);

    console.log(`Processed ${rawSignals.length} raw signals`);
    console.log(`High quality signals: ${sortedSignals.length}`);

    return sortedSignals;
  }

  private deduplicateSignals(signals: Signal[]): Signal[] {
    const bySymbol = new Map<string, Signal>();

    for (const signal of signals) {
      const existing = bySymbol.get(signal.symbol);
      if (!existing || signal.confidence > existing.confidence) {
        bySymbol.set(signal.symbol, signal);
      }
    }

    return Array.from(bySymbol.values());
  }

  async subscribeWithFilter(runner: StrategyRunner, filter: (s: Signal) => boolean) {
    return runner.subscribeSignals((signal: Signal) => {
      if (filter(signal)) {
        console.log('Filtered signal:', signal);
        this.signals.push(signal);
        // Execute trade
      }
    });
  }
}

// Example filters
const highConfidenceFilter = (s: Signal) => s.confidence >= 0.8;
const momentumOnlyFilter = (s: Signal) => s.strategyId.includes('momentum');
const largeCapFilter = (s: Signal) => ['AAPL', 'MSFT', 'GOOGL', 'AMZN'].includes(s.symbol);

Strategy Management

async function manageStrategies() {
  const runner = new StrategyRunner();

  // Add multiple strategies
  const strategy1 = await runner.addMomentumStrategy(config1);
  const strategy2 = await runner.addMeanReversionStrategy(config2);
  const strategy3 = await runner.addArbitrageStrategy(config3);

  // List all active strategies
  const strategies = await runner.listStrategies();
  console.log('Active strategies:', strategies);

  // Remove underperforming strategy
  const removed = await runner.removeStrategy(strategy2);
  if (removed) {
    console.log(`Strategy ${strategy2} removed`);
  }

  // Subscribe to all signals
  const subscription = runner.subscribeSignals((signal: Signal) => {
    console.log(`Signal from ${signal.strategyId}:`, signal.symbol);
  });

  // Clean up
  setTimeout(async () => {
    await subscription.unsubscribe();
    console.log('Unsubscribed from signals');
  }, 3600000); // 1 hour
}

API Reference

StrategyRunner

class StrategyRunner {
  constructor();

  // Add momentum strategy
  addMomentumStrategy(config: StrategyConfig): Promise<string>;

  // Add mean reversion strategy
  addMeanReversionStrategy(config: StrategyConfig): Promise<string>;

  // Add arbitrage strategy
  addArbitrageStrategy(config: StrategyConfig): Promise<string>;

  // Generate signals from all strategies
  generateSignals(): Promise<Signal[]>;

  // Subscribe to real-time signals
  subscribeSignals(callback: (signal: Signal) => void): SubscriptionHandle;

  // List active strategies
  listStrategies(): Promise<string[]>;

  // Remove strategy
  removeStrategy(strategyId: string): Promise<boolean>;
}

SubscriptionHandle

class SubscriptionHandle {
  // Unsubscribe from signal updates
  unsubscribe(): Promise<void>;
}

Configuration

StrategyConfig

Field	Type	Description
`name`	`string`	Strategy name
`symbols`	`string[]`	Trading symbols
`parameters`	`string`	JSON-encoded strategy parameters

Common Parameters

Momentum:

shortPeriod: Fast MA period
longPeriod: Slow MA period
minVolume: Minimum volume filter
atr_multiplier: Stop loss calculation

Mean Reversion:

period: Lookback period
stdDev: Standard deviations
oversold_threshold: Buy trigger
overbought_threshold: Sell trigger

Pairs Trading:

lookback: Cointegration period
entry_threshold: Z-score entry
exit_threshold: Z-score exit
min_correlation: Minimum correlation

Examples

Example 1: Multi-Strategy Portfolio

async function runMultiStrategyPortfolio() {
  const runner = new StrategyRunner();

  // Momentum for trending markets
  await runner.addMomentumStrategy({
    name: 'Tech Momentum',
    symbols: ['AAPL', 'MSFT', 'GOOGL', 'NVDA'],
    parameters: JSON.stringify({ shortPeriod: 20, longPeriod: 50 })
  });

  // Mean reversion for range-bound markets
  await runner.addMeanReversionStrategy({
    name: 'Index Reversion',
    symbols: ['SPY', 'QQQ'],
    parameters: JSON.stringify({ period: 20, stdDev: 2.0 })
  });

  // Pairs trading for market-neutral exposure
  await runner.addArbitrageStrategy({
    name: 'Sector Pairs',
    symbols: ['XLE,XLF', 'XLK,XLV'],
    parameters: JSON.stringify({ lookback: 60, entry_threshold: 2.0 })
  });

  // Subscribe to all signals
  const subscription = runner.subscribeSignals(async (signal: Signal) => {
    console.log(`Signal: ${signal.symbol} ${signal.direction}`);
    // Route to appropriate execution engine
  });

  return { runner, subscription };
}

License

This package is dual-licensed under MIT OR Apache-2.0.