// Use Claude Code or Cursor to build strategies through conversation
import { createStrategy } from 'neural-trader';

// AI assistant converts: "Create a momentum strategy with RSI confirmation"
const strategy = await createStrategy({
  type: 'momentum',
  indicators: ['RSI', 'MACD'],
  riskManagement: { maxDrawdown: 0.1, positionSize: 'kelly' }
});

// AI assistant handles: "Backtest this on SPY from 2020-2024"
const results = await strategy.backtest({
  symbol: 'SPY',
  start: '2020-01-01',
  end: '2024-12-31'
});

console.log(results.sharpeRatio); // 2.34 (AI auto-optimized!)

import { NeuralModel } from '@neural-trader/neural';

// Neural model learns from every execution
const model = new NeuralModel({ modelType: 'Transformer' });

// First run - baseline performance
await model.train(historicalData);
const prediction1 = await model.predict(currentData); // Accuracy: 65%

// After 100 backtests - model has learned patterns
await model.train(moreData); // Auto-optimizes internally
const prediction2 = await model.predict(currentData); // Accuracy: 78%

// Memory persists across sessions - keeps improving!

// Install only what you need
// npm install @neural-trader/core @neural-trader/risk @neural-trader/backtesting

import { RiskManager } from '@neural-trader/risk';
import { BacktestEngine } from '@neural-trader/backtesting';
import type { RiskConfig, BacktestConfig } from '@neural-trader/core';

// 1. Set up risk management
const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
} as RiskConfig);

// 2. Calculate risk metrics
const var95 = riskManager.calculateVar(returns, 100000);
const cvar95 = riskManager.calculateCvar(returns, 100000);
const kelly = riskManager.calculateKelly(0.6, 500, 300);

console.log(`VaR (95%): $${var95.var_amount.toFixed(2)}`);
console.log(`CVaR (95%): $${cvar95.cvar_amount.toFixed(2)}`);
console.log(`Kelly Fraction: ${(kelly.kelly_fraction * 100).toFixed(2)}%`);

// 3. Backtest strategy
const backtest = new BacktestEngine({
  initialCapital: 100000,
  startDate: '2023-01-01',
  endDate: '2023-12-31',
  commission: 0.001,
  slippage: 0.0005
} as BacktestConfig);

const results = await backtest.run(signals, 'data.csv');
console.log(`Sharpe Ratio: ${results.metrics.sharpeRatio.toFixed(2)}`);

import { RiskManager } from '@neural-trader/risk';
import type { RiskConfig } from '@neural-trader/core';

const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
} as RiskConfig);

// Historical returns (daily)
const returns = [-0.02, 0.015, -0.01, 0.025, -0.005, 0.03];
const portfolioValue = 100000;

// 1. Value at Risk (VaR)
const var95 = riskManager.calculateVar(returns, portfolioValue);
console.log(`VaR (95%): $${var95.var_amount.toFixed(2)}`);
console.log(`VaR %: ${(var95.var_percentage * 100).toFixed(2)}%`);

// 2. Conditional Value at Risk (CVaR)
const cvar95 = riskManager.calculateCvar(returns, portfolioValue);
console.log(`CVaR (95%): $${cvar95.cvar_amount.toFixed(2)}`);

// 3. Kelly Criterion Position Sizing
const kelly = riskManager.calculateKelly(
  0.6,   // 60% win rate
  500,   // Average win size
  300    // Average loss size
);
console.log(`Kelly Fraction: ${(kelly.kelly_fraction * 100).toFixed(2)}%`);
console.log(`Position Size: $${kelly.position_size.toFixed(2)}`);

// 4. Drawdown Analysis
const equity = [100000, 105000, 102000, 108000, 103000, 110000];
const drawdown = riskManager.calculateDrawdown(equity);
console.log(`Max Drawdown: ${(drawdown.max_drawdown * 100).toFixed(2)}%`);
console.log(`Current Drawdown: ${(drawdown.current_drawdown * 100).toFixed(2)}%`);

import { BacktestEngine } from '@neural-trader/backtesting';
import type { BacktestConfig, Signal } from '@neural-trader/core';

const engine = new BacktestEngine({
  initialCapital: 100000,
  startDate: '2023-01-01',
  endDate: '2023-12-31',
  commission: 0.001,      // 0.1% per trade
  slippage: 0.0005,       // 0.05% slippage
  useMarkToMarket: true
} as BacktestConfig);

// Generate signals (from your strategy)
const signals: Signal[] = [
  { timestamp: '2023-01-15', symbol: 'AAPL', action: 'buy', quantity: 100 },
  { timestamp: '2023-02-20', symbol: 'AAPL', action: 'sell', quantity: 100 },
  // ... more signals
];

// Run backtest
const results = await engine.run(signals, 'market-data.csv');

// Analyze results
console.log('=== Backtest Results ===');
console.log(`Total Return: ${(results.metrics.totalReturn * 100).toFixed(2)}%`);
console.log(`Sharpe Ratio: ${results.metrics.sharpeRatio.toFixed(2)}`);
console.log(`Sortino Ratio: ${results.metrics.sortinoRatio.toFixed(2)}`);
console.log(`Max Drawdown: ${(results.metrics.maxDrawdown * 100).toFixed(2)}%`);
console.log(`Win Rate: ${(results.metrics.winRate * 100).toFixed(2)}%`);
console.log(`Profit Factor: ${results.metrics.profitFactor.toFixed(2)}`);
console.log(`Total Trades: ${results.metrics.totalTrades}`);

// Compare multiple backtests
const comparison = await compareBacktests([results1, results2, results3]);
console.log('Best Sharpe Ratio:', comparison.bestSharpe.metrics.sharpeRatio);

import { NeuralModel } from '@neural-trader/neural';
import type { ModelConfig, TrainingConfig } from '@neural-trader/core';

// 1. Create LSTM model
const model = new NeuralModel({
  modelType: 'LSTM',
  inputSize: 20,          // 20 features
  horizon: 5,             // Predict 5 days ahead
  hiddenSize: 128,
  numLayers: 3,
  dropout: 0.2,
  learningRate: 0.001
} as ModelConfig);

// 2. Prepare training data
const trainingData = [...]; // Shape: [samples, sequence_length, features]
const targets = [...];      // Shape: [samples, horizon]

// 3. Train model
const trainingConfig: TrainingConfig = {
  epochs: 100,
  batchSize: 32,
  validationSplit: 0.2,
  earlyStoppingPatience: 10,
  learningRateSchedule: 'cosine',
  useGpu: true
};

const metrics = await model.train(trainingData, targets, trainingConfig);
console.log(`Final Loss: ${metrics.finalLoss.toFixed(4)}`);
console.log(`Best Validation Loss: ${metrics.bestValLoss.toFixed(4)}`);

// 4. Make predictions
const inputData = [...]; // Shape: [sequence_length, features]
const predictions = await model.predict(inputData);
console.log('Predictions:', predictions);

// 5. Save/Load model
await model.save('models/lstm_price_predictor.bin');

const loadedModel = new NeuralModel();
await loadedModel.load('models/lstm_price_predictor.bin');

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

const runner = new StrategyRunner();

// 1. Add momentum strategy
const momentumId = await runner.addMomentumStrategy({
  name: 'SMA Crossover',
  symbols: ['AAPL', 'MSFT', 'GOOGL'],
  parameters: JSON.stringify({
    shortPeriod: 20,
    longPeriod: 50,
    threshold: 0.02
  })
} as StrategyConfig);

// 2. Add mean reversion strategy
const meanReversionId = await runner.addMeanReversionStrategy({
  name: 'Bollinger Bands',
  symbols: ['SPY'],
  parameters: JSON.stringify({
    period: 20,
    stdDevs: 2,
    oversoldThreshold: -2,
    overboughtThreshold: 2
  })
} as StrategyConfig);

// 3. Generate signals
const signals = await runner.generateSignals();
console.log(`Generated ${signals.length} signals`);

// 4. Subscribe to real-time signals
const subscription = runner.subscribe((signal) => {
  console.log('New signal:', signal);
  // Execute trade, send notification, etc.
});

// Later: unsubscribe
subscription.unsubscribe();

import { BrokerClient } from '@neural-trader/brokers';
import { NeuralTrader } from '@neural-trader/execution';
import { RiskManager } from '@neural-trader/risk';
import type { BrokerConfig, OrderRequest } from '@neural-trader/core';

// 1. Connect to broker
const broker = new BrokerClient({
  brokerType: 'alpaca',
  apiKey: process.env.ALPACA_KEY,
  apiSecret: process.env.ALPACA_SECRET,
  paperTrading: true  // Start with paper trading!
} as BrokerConfig);

await broker.connect();
console.log('Connected to Alpaca (Paper Trading)');

// 2. Set up risk manager
const riskManager = new RiskManager({
  confidence_level: 0.95,
  lookback_periods: 252,
  method: 'historical'
});

// 3. Create trading system
const trader = new NeuralTrader();

// 4. Place orders with risk checks
const accountValue = 100000;
const returns = await getHistoricalReturns('AAPL');

// Check risk before trading
const var95 = riskManager.calculateVar(returns, accountValue);
const maxRisk = var95.var_amount;

console.log(`Maximum risk allowed: $${maxRisk.toFixed(2)}`);

// Place order
const order: OrderRequest = {
  symbol: 'AAPL',
  side: 'buy',
  orderType: 'market',
  quantity: 10,
  timeInForce: 'day'
};

const result = await broker.placeOrder(order);
console.log('Order placed:', result.orderId);

// 5. Monitor positions
const positions = await broker.getPositions();
positions.forEach(pos => {
  console.log(`${pos.symbol}: ${pos.quantity} shares @ $${pos.avgEntryPrice}`);
});

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

export class MyCustomStrategy {
  constructor(config: StrategyConfig);
  generateSignals(marketData: MarketData[]): Promise<Signal[]>;
}

export class MyCustomIndicator {
  calculate(prices: number[], period: number): number[];
}

// test.ts
import { MyCustomStrategy } from './index';

const strategy = new MyCustomStrategy({
  name: 'Test',
  symbols: ['AAPL'],
  parameters: JSON.stringify({ myParameter: 0.75 })
});

const signals = await strategy.generateSignals(testData);
console.log('Generated signals:', signals);

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

const app = express();
const runner = new StrategyRunner();

app.post('/webhook/tradingview', async (req, res) => {
  const alert = req.body;

  // Execute trade based on TradingView alert
  if (alert.action === 'buy') {
    await executeTrade(alert.symbol, 'buy', alert.quantity);
  }

  res.json({ success: true });
});

app.listen(3000);

import { Telegraf } from 'telegraf';
import { RiskManager } from '@neural-trader/risk';

const bot = new Telegraf(process.env.TELEGRAM_TOKEN);
const riskManager = new RiskManager({ confidence_level: 0.95 });

bot.command('risk', async (ctx) => {
  const var95 = riskManager.calculateVar(recentReturns, portfolioValue);
  ctx.reply(`Current VaR (95%): $${var95.var_amount.toFixed(2)}`);
});

bot.launch();