kbs 0.0.1

data/examples/redis_trading_demo.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kbs/blackboard'
+
+puts "Redis-Backed High-Frequency Trading System"
+puts "=" * 70
+
+# Demo 1: Pure Redis Store (fast, in-memory)
+puts "\n=== Pure Redis Store Demo ==="
+puts "Fast in-memory fact storage with Redis"
+
+begin
+  redis_store = KBS::Blackboard::Persistence::RedisStore.new(
+    url: 'redis://localhost:6379/1' # Use DB 1 for demo
+  )
+
+  # Clear previous demo data
+  redis_store.redis.flushdb
+  puts "(Cleared previous Redis data)"
+
+  engine = KBS::Blackboard::Engine.new(store: redis_store)
+
+  # Add trading rules
+  spread_rule = KBS::Rule.new('tight_spread_opportunity') do |r|
+    r.conditions << KBS::Condition.new(:market_price, { symbol: 'AAPL' })
+    r.conditions << KBS::Condition.new(:order, { symbol: 'AAPL', type: 'BUY' })
+    r.action = ->(facts) {
+      price = facts.find { |f| f.type == :market_price }
+      order = facts.find { |f| f.type == :order }
+      spread = 0.02 # Tight spread
+      puts "\n💹 TRADING SIGNAL: Tight spread opportunity for #{price[:symbol]}"
+      puts "   Price: $#{price[:price]}, Spread: $#{spread}"
+      puts "   Order: #{order[:type]} #{order[:quantity]} @ $#{order[:limit]}"
+    }
+  end
+
+  high_volume_rule = KBS::Rule.new('high_volume_alert') do |r|
+    r.conditions << KBS::Condition.new(:market_price, { volume: ->(v) { v > 800 } })
+    r.action = ->(facts) {
+      price = facts.first
+      puts "\n📊 HIGH VOLUME: #{price[:symbol]} trading at #{price[:volume]} shares"
+    }
+  end
+
+  engine.add_rule(spread_rule)
+  engine.add_rule(high_volume_rule)
+
+  puts "\nAdding high-frequency market data..."
+  price1 = engine.add_fact(:market_price, { symbol: "AAPL", price: 150.25, volume: 1000 })
+  price2 = engine.add_fact(:market_price, { symbol: "GOOGL", price: 2800.50, volume: 500 })
+  order = engine.add_fact(:order, { symbol: "AAPL", type: "BUY", quantity: 100, limit: 150.00 })
+
+  puts "Facts added with UUIDs:"
+  puts "  AAPL Price: #{price1.uuid}"
+  puts "  GOOGL Price: #{price2.uuid}"
+  puts "  Order: #{order.uuid}"
+
+  puts "\nRunning inference engine..."
+  engine.run
+
+  puts "\nPosting trading messages..."
+  engine.post_message("MarketDataFeed", "prices", { symbol: "AAPL", bid: 150.24, ask: 150.26 }, priority: 10)
+  engine.post_message("OrderManager", "orders", { action: "fill", order_id: order.uuid }, priority: 5)
+
+  puts "\nConsuming highest priority message..."
+  message = engine.consume_message("prices", "TradingStrategy")
+  puts "  Received: #{message[:content]}" if message
+
+  puts "\nQuerying market prices..."
+  prices = engine.blackboard.get_facts(:market_price)
+  puts "  Found #{prices.size} price(s):"
+  prices.each { |p| puts "    - #{p}" }
+
+  puts "\nRedis Statistics:"
+  stats = engine.stats
+  stats.each do |key, value|
+    puts "  #{key.to_s.gsub('_', ' ').capitalize}: #{value}"
+  end
+
+  engine.blackboard.close
+
+rescue Redis::CannotConnectError => e
+  puts "\n⚠️  Redis not available: #{e.message}"
+  puts "   Please start Redis: redis-server"
+  puts "   Or install Redis: brew install redis (macOS)"
+end
+
+# Demo 2: Hybrid Store (Redis + SQLite)
+puts "\n\n=== Hybrid Store Demo ==="
+puts "Redis for fast fact access + SQLite for durable audit trail"
+
+begin
+  hybrid_store = KBS::Blackboard::Persistence::HybridStore.new(
+    redis_url: 'redis://localhost:6379/2', # Use DB 2 for demo
+    db_path: ':memory:' # In-memory SQLite for demo
+  )
+
+  # Clear previous demo data from Redis
+  hybrid_store.redis_store.redis.flushdb
+  puts "(Cleared previous Redis data)"
+
+  engine = KBS::Blackboard::Engine.new(store: hybrid_store)
+
+  # Add monitoring rules
+  temp_alert = KBS::Rule.new('temperature_alert') do |r|
+    r.conditions << KBS::Condition.new(:sensor, {
+      type: 'temperature',
+      value: ->(v) { v > 25 }
+    })
+    r.action = ->(facts) {
+      sensor = facts.first
+      puts "\n🌡️  TEMPERATURE ALERT: #{sensor[:location]} at #{sensor[:value]}°C (threshold: 25°C)"
+    }
+  end
+
+  cpu_warning = KBS::Rule.new('cpu_warning') do |r|
+    r.conditions << KBS::Condition.new(:sensor, {
+      type: 'cpu_usage',
+      value: ->(v) { v > 40 }
+    })
+    r.action = ->(facts) {
+      sensor = facts.first
+      puts "\n⚙️  CPU WARNING: #{sensor[:location]} at #{sensor[:value]}% (threshold: 40%)"
+    }
+  end
+
+  engine.add_rule(temp_alert)
+  engine.add_rule(cpu_warning)
+
+  puts "\nAdding facts (stored in Redis)..."
+  sensor1 = engine.add_fact(:sensor, { location: "trading_floor", type: "temperature", value: 22 })
+  sensor2 = engine.add_fact(:sensor, { location: "data_center", type: "cpu_usage", value: 45 })
+
+  puts "Facts added:"
+  puts "  Sensor 1: #{sensor1.uuid}"
+  puts "  Sensor 2: #{sensor2.uuid}"
+
+  puts "\nRunning inference engine..."
+  engine.run
+
+  puts "\nUpdating sensor value (audit logged to SQLite)..."
+  sensor1[:value] = 28
+
+  puts "\nRunning inference again after update..."
+  engine.run
+
+  puts "\nFact History from SQLite Audit Log:"
+  history = engine.blackboard.get_history(limit: 5)
+  history.each do |entry|
+    puts "  [#{entry[:timestamp].strftime('%H:%M:%S')}] #{entry[:action]}: #{entry[:fact_type]}(#{entry[:attributes]})"
+  end
+
+  puts "\nHybrid Store Benefits:"
+  puts "  ✓ Facts in Redis (fast reads/writes)"
+  puts "  ✓ Messages in Redis (real-time messaging)"
+  puts "  ✓ Audit trail in SQLite (durable, queryable)"
+  puts "  ✓ Best of both worlds for production systems"
+
+  puts "\nStatistics:"
+  stats = engine.stats
+  stats.each do |key, value|
+    puts "  #{key.to_s.gsub('_', ' ').capitalize}: #{value}"
+  end
+
+  engine.blackboard.close
+
+rescue Redis::CannotConnectError => e
+  puts "\n⚠️  Redis not available: #{e.message}"
+  puts "   Hybrid store requires Redis for fact storage"
+end
+
+puts "\n" + "=" * 70
+puts "Demo complete!"
+puts "\nComparison:"
+puts "  SQLite Store:  Durable, transactional, embedded (no server needed)"
+puts "  Redis Store:   Fast (100x), distributed, requires Redis server"
+puts "  Hybrid Store:  Fast facts + durable audit (production recommended)"

data/examples/sample_stock_data.csv

@@ -0,0 +1,46 @@
+Date,Symbol,Open,High,Low,Close,Volume
+2024-08-01,AAPL,190.50,192.30,189.80,191.75,45231000
+2024-08-02,AAPL,191.90,193.45,190.25,192.10,42891000
+2024-08-03,AAPL,192.20,194.80,191.55,194.25,51203000
+2024-08-04,AAPL,194.00,195.20,192.30,193.85,38756000
+2024-08-05,AAPL,193.50,194.75,191.80,192.45,44672000
+2024-08-06,AAPL,192.80,195.60,192.45,195.25,47938000
+2024-08-07,AAPL,195.50,197.80,194.90,197.35,52847000
+2024-08-08,AAPL,197.20,198.45,195.75,196.80,46291000
+2024-08-09,AAPL,196.50,197.90,194.80,195.60,41859000
+2024-08-10,AAPL,195.80,198.20,195.40,197.85,49562000
+2024-08-11,AAPL,198.00,200.15,197.25,199.90,55743000
+2024-08-12,AAPL,199.75,201.40,198.60,200.85,48392000
+2024-08-13,AAPL,200.90,202.75,199.85,202.30,53681000
+2024-08-14,AAPL,202.50,204.20,201.80,203.45,47256000
+2024-08-15,AAPL,203.20,205.80,202.90,205.15,51847000
+2024-08-01,GOOGL,160.20,162.50,159.80,161.90,28453000
+2024-08-02,GOOGL,162.10,163.75,160.95,162.85,26781000
+2024-08-03,GOOGL,162.90,165.40,162.20,164.75,31294000
+2024-08-04,GOOGL,164.50,166.80,163.85,165.90,29102000
+2024-08-05,GOOGL,165.70,167.20,164.50,166.45,27638000
+2024-08-06,GOOGL,166.80,169.30,166.20,168.75,33572000
+2024-08-07,GOOGL,168.90,171.45,168.30,170.90,35847000
+2024-08-08,GOOGL,170.75,172.60,169.85,171.25,32194000
+2024-08-09,GOOGL,171.50,173.20,170.40,172.80,30685000
+2024-08-10,GOOGL,172.60,174.95,172.10,174.30,34729000
+2024-08-11,GOOGL,174.50,176.80,173.95,176.20,37591000
+2024-08-12,GOOGL,176.40,178.20,175.80,177.65,33847000
+2024-08-13,GOOGL,177.80,180.15,177.25,179.45,36293000
+2024-08-14,GOOGL,179.60,181.90,178.95,180.75,34562000
+2024-08-15,GOOGL,180.90,183.40,180.30,182.85,38174000
+2024-08-01,TSLA,235.80,240.20,234.50,238.90,78392000
+2024-08-02,TSLA,239.20,242.75,237.80,241.50,82451000
+2024-08-03,TSLA,241.80,245.60,240.90,244.20,89637000
+2024-08-04,TSLA,244.50,247.30,242.80,245.75,75284000
+2024-08-05,TSLA,245.90,248.40,243.20,246.85,71956000
+2024-08-06,TSLA,247.20,251.80,246.50,250.30,86742000
+2024-08-07,TSLA,250.60,254.90,249.80,253.45,94587000
+2024-08-08,TSLA,253.70,256.20,251.40,254.90,81639000
+2024-08-09,TSLA,254.50,257.80,252.90,255.60,78294000
+2024-08-10,TSLA,255.90,259.40,254.70,258.75,85731000
+2024-08-11,TSLA,259.00,262.80,257.90,261.50,92846000
+2024-08-12,TSLA,261.80,264.50,260.20,263.25,87359000
+2024-08-13,TSLA,263.50,267.90,262.80,266.40,91582000
+2024-08-14,TSLA,266.70,270.20,265.50,268.85,88473000
+2024-08-15,TSLA,269.10,273.60,268.40,272.30,95627000

data/examples/stock_trading_advanced.rb

@@ -0,0 +1,469 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kbs'
+
+class AdvancedStockTradingSystem
+  def initialize
+    @engine = KBS::ReteEngine.new
+    @portfolio = {
+      cash: 100000,
+      positions: {},
+      total_value: 100000
+    }
+    @market_data = {}
+    setup_rules
+  end
+  
+  def setup_rules
+    golden_cross = KBS::Rule.new(
+      "golden_cross",
+      conditions: [
+        KBS::Condition.new(:technical, {
+          indicator: "ma_crossover",
+          ma50: ->(v) { v > 0 },
+          ma200: ->(v) { v > 0 }
+        }),
+        KBS::Condition.new(:stock, {
+          volume: ->(v) { v > 1000000 }
+        }),
+        KBS::Condition.new(:position, { status: "open" }, negated: true)
+      ],
+      action: lambda do |facts, bindings|
+        tech = facts.find { |f| f.type == :technical }
+        stock = facts.find { |f| f.type == :stock }
+        if tech && stock && tech[:ma50] > tech[:ma200] && tech[:ma50_prev] <= tech[:ma200_prev]
+          puts "📈 GOLDEN CROSS: #{stock[:symbol]}"
+          puts "   50-MA: $#{tech[:ma50].round(2)}, 200-MA: $#{tech[:ma200].round(2)}"
+          puts "   Volume: #{stock[:volume].to_s.reverse.scan(/\d{1,3}/).join(',').reverse}"
+          puts "   ACTION: Strong BUY signal"
+        end
+      end,
+      priority: 15
+    )
+    
+    momentum_breakout = KBS::Rule.new(
+      "momentum_breakout",
+      conditions: [
+        KBS::Condition.new(:stock, {
+          price_change: ->(v) { v > 3 },
+          volume_ratio: ->(v) { v > 1.5 },
+          rsi: ->(v) { v.between?(40, 70) }
+        }),
+        KBS::Condition.new(:market, { sentiment: ->(s) { ["bullish", "neutral"].include?(s) } })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        puts "🚀 MOMENTUM BREAKOUT: #{stock[:symbol]}"
+        puts "   Price Change: +#{stock[:price_change]}%"
+        puts "   Volume Spike: #{stock[:volume_ratio]}x average"
+        puts "   RSI: #{stock[:rsi]}"
+        puts "   ACTION: Momentum BUY"
+      end,
+      priority: 12
+    )
+    
+    oversold_bounce = KBS::Rule.new(
+      "oversold_bounce",
+      conditions: [
+        KBS::Condition.new(:stock, {
+          rsi: ->(v) { v < 30 },
+          price: ->(p) { p > 0 }
+        }),
+        KBS::Condition.new(:support, {
+          level: ->(l) { l > 0 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        support = facts.find { |f| f.type == :support }
+        if stock && support && stock[:price] >= support[:level] * 0.98
+          puts "🔄 OVERSOLD REVERSAL: #{stock[:symbol]}"
+          puts "   RSI: #{stock[:rsi]} (oversold)"
+          puts "   Price: $#{stock[:price]} near support $#{support[:level].round(2)}"
+          puts "   ACTION: Reversal BUY opportunity"
+        end
+      end,
+      priority: 10
+    )
+    
+    trailing_stop = KBS::Rule.new(
+      "trailing_stop",
+      conditions: [
+        KBS::Condition.new(:position, {
+          status: "open",
+          profit_pct: ->(p) { p > 5 }
+        }),
+        KBS::Condition.new(:stock, {
+          price: ->(p) { p > 0 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        position = facts.find { |f| f.type == :position }
+        stock = facts.find { |f| f.type == :stock }
+        if position && stock
+          trailing_stop = position[:high_water] * 0.95
+          if stock[:price] <= trailing_stop
+            puts "🛑 TRAILING STOP: #{position[:symbol]}"
+            puts "   Entry: $#{position[:entry_price]}"
+            puts "   Current: $#{stock[:price]}"
+            puts "   Stop: $#{trailing_stop.round(2)}"
+            puts "   Profit: #{position[:profit_pct].round(1)}%"
+            puts "   ACTION: SELL to lock profits"
+          end
+        end
+      end,
+      priority: 18
+    )
+    
+    position_sizing = KBS::Rule.new(
+      "position_sizing",
+      conditions: [
+        KBS::Condition.new(:signal, {
+          action: "buy",
+          confidence: ->(c) { c > 0.6 }
+        }),
+        KBS::Condition.new(:portfolio, {
+          cash: ->(c) { c > 1000 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        signal = facts.find { |f| f.type == :signal }
+        portfolio = facts.find { |f| f.type == :portfolio }
+        if signal && portfolio
+          kelly = (signal[:confidence] * signal[:expected_return] - (1 - signal[:confidence])) / signal[:expected_return]
+          position_size = portfolio[:cash] * [kelly * 0.25, 0.1].min
+          puts "📊 POSITION SIZING: #{signal[:symbol]}"
+          puts "   Confidence: #{(signal[:confidence] * 100).round}%"
+          puts "   Kelly %: #{(kelly * 100).round(1)}%"
+          puts "   Suggested Size: $#{position_size.round(0)}"
+        end
+      end,
+      priority: 8
+    )
+    
+    earnings_play = KBS::Rule.new(
+      "earnings_play",
+      conditions: [
+        KBS::Condition.new(:earnings, {
+          days_until: ->(d) { d.between?(1, 5) },
+          expected_move: ->(m) { m > 5 }
+        }),
+        KBS::Condition.new(:options, {
+          iv: ->(v) { v > 30 },
+          iv_rank: ->(r) { r > 50 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        earnings = facts.find { |f| f.type == :earnings }
+        options = facts.find { |f| f.type == :options }
+        puts "💰 EARNINGS PLAY: #{earnings[:symbol]}"
+        puts "   Days to Earnings: #{earnings[:days_until]}"
+        puts "   Expected Move: ±#{earnings[:expected_move]}%"
+        puts "   IV: #{options[:iv]}% (Rank: #{options[:iv_rank]})"
+        puts "   ACTION: Consider volatility strategy"
+      end,
+      priority: 11
+    )
+    
+    sector_rotation = KBS::Rule.new(
+      "sector_rotation",
+      conditions: [
+        KBS::Condition.new(:sector, {
+          performance: ->(p) { p > 1.1 },
+          trend: "up"
+        }),
+        KBS::Condition.new(:position, {
+          sector: ->(s) { s != nil },
+          profit_pct: ->(p) { p < 2 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        strong_sector = facts.find { |f| f.type == :sector }
+        weak_position = facts.find { |f| f.type == :position }
+        if strong_sector && weak_position && strong_sector[:name] != weak_position[:sector]
+          puts "🔄 SECTOR ROTATION"
+          puts "   From: #{weak_position[:sector]} (underperforming)"
+          puts "   To: #{strong_sector[:name]} (RS: #{strong_sector[:performance]})"
+          puts "   ACTION: Rotate portfolio allocation"
+        end
+      end,
+      priority: 7
+    )
+    
+    risk_alert = KBS::Rule.new(
+      "risk_concentration",
+      conditions: [
+        KBS::Condition.new(:portfolio_metrics, {
+          concentration: ->(c) { c > 0.3 }
+        }),
+        KBS::Condition.new(:market, {
+          volatility: ->(v) { v > 25 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        metrics = facts.find { |f| f.type == :portfolio_metrics }
+        puts "⚠️  RISK CONCENTRATION ALERT"
+        puts "   Top Position: #{(metrics[:concentration] * 100).round}% of portfolio"
+        puts "   Market Volatility: Elevated"
+        puts "   ACTION: Reduce position sizes for risk management"
+      end,
+      priority: 16
+    )
+    
+    vwap_reversion = KBS::Rule.new(
+      "vwap_reversion",
+      conditions: [
+        KBS::Condition.new(:intraday, {
+          distance_from_vwap: ->(d) { d.abs > 2 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        intraday = facts.find { |f| f.type == :intraday }
+        direction = intraday[:distance_from_vwap] > 0 ? "OVERBOUGHT" : "OVERSOLD"
+        puts "📊 VWAP REVERSION: #{intraday[:symbol]}"
+        puts "   Status: #{direction}"
+        puts "   Distance: #{intraday[:distance_from_vwap].round(1)} std devs"
+        puts "   Current: $#{intraday[:price]}"
+        puts "   VWAP: $#{intraday[:vwap].round(2)}"
+        puts "   ACTION: Mean reversion trade"
+      end,
+      priority: 9
+    )
+    
+    news_sentiment = KBS::Rule.new(
+      "news_sentiment",
+      conditions: [
+        KBS::Condition.new(:news, {
+          sentiment: ->(s) { s.abs > 0.7 },
+          volume: ->(v) { v > 10 }
+        }),
+        KBS::Condition.new(:stock, {
+          price_change: ->(p) { p.abs < 2 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        news = facts.find { |f| f.type == :news }
+        stock = facts.find { |f| f.type == :stock }
+        sentiment = news[:sentiment] > 0 ? "POSITIVE" : "NEGATIVE"
+        action = news[:sentiment] > 0 ? "BUY" : "SELL"
+        puts "📰 NEWS CATALYST: #{stock[:symbol]}"
+        puts "   Sentiment: #{sentiment} (#{news[:sentiment].round(2)})"
+        puts "   News Volume: #{news[:volume]} articles"
+        puts "   Price Reaction: #{stock[:price_change].round(1)}% (lagging)"
+        puts "   ACTION: #{action} on sentiment divergence"
+      end,
+      priority: 13
+    )
+    
+    correlation_hedge = KBS::Rule.new(
+      "correlation_warning",
+      conditions: [
+        KBS::Condition.new(:correlation, {
+          value: ->(v) { v > 0.8 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        corr = facts.find { |f| f.type == :correlation }
+        puts "⚠️  HIGH CORRELATION"
+        puts "   Pairs: #{corr[:symbol1]} <-> #{corr[:symbol2]}"
+        puts "   Correlation: #{corr[:value].round(2)}"
+        puts "   ACTION: Diversify or hedge positions"
+      end,
+      priority: 6
+    )
+    
+    gap_fade = KBS::Rule.new(
+      "gap_fade",
+      conditions: [
+        KBS::Condition.new(:gap, {
+          size: ->(s) { s.abs > 2 }
+        }),
+        KBS::Condition.new(:stock, {
+          atr: ->(a) { a > 0 }
+        })
+      ],
+      action: lambda do |facts, bindings|
+        gap = facts.find { |f| f.type == :gap }
+        stock = facts.find { |f| f.type == :stock }
+        if gap && stock
+          gap_multiple = gap[:size].abs / (stock[:atr] / stock[:price] * 100)
+          if gap_multiple > 2
+            direction = gap[:size] > 0 ? "SHORT" : "LONG"
+            puts "📉 GAP FADE: #{stock[:symbol]}"
+            puts "   Gap: #{gap[:size].round(1)}%"
+            puts "   ATR Multiple: #{gap_multiple.round(1)}x"
+            puts "   ACTION: #{direction} fade trade"
+          end
+        end
+      end,
+      priority: 8
+    )
+    
+    @engine.add_rule(golden_cross)
+    @engine.add_rule(momentum_breakout)
+    @engine.add_rule(oversold_bounce)
+    @engine.add_rule(trailing_stop)
+    @engine.add_rule(position_sizing)
+    @engine.add_rule(earnings_play)
+    @engine.add_rule(sector_rotation)
+    @engine.add_rule(risk_alert)
+    @engine.add_rule(vwap_reversion)
+    @engine.add_rule(news_sentiment)
+    @engine.add_rule(correlation_hedge)
+    @engine.add_rule(gap_fade)
+  end
+  
+  def simulate_market_tick(symbols)
+    symbols.each do |symbol|
+      @market_data[symbol] ||= {
+        price: 100 + rand(50),
+        ma50: 100,
+        ma200: 100,
+        volume: 1000000,
+        rsi: 50,
+        high_water: 100
+      }
+      
+      data = @market_data[symbol]
+      
+      price_change = rand(-5.0..5.0)
+      data[:price] = (data[:price] * (1 + price_change / 100)).round(2)
+      data[:ma50] = (data[:ma50] * 0.98 + data[:price] * 0.02).round(2)
+      data[:ma200] = (data[:ma200] * 0.995 + data[:price] * 0.005).round(2)
+      data[:volume] = (1000000 * (0.5 + rand * 2)).to_i
+      data[:rsi] = [[data[:rsi] + rand(-10..10), 0].max, 100].min
+      data[:high_water] = [data[:high_water], data[:price]].max
+      
+      @engine.add_fact(:stock, {
+        symbol: symbol,
+        price: data[:price],
+        volume: data[:volume],
+        rsi: data[:rsi],
+        price_change: price_change,
+        volume_ratio: data[:volume] / 1000000.0,
+        atr: rand(1.0..3.0)
+      })
+      
+      @engine.add_fact(:technical, {
+        symbol: symbol,
+        indicator: "ma_crossover",
+        ma50: data[:ma50],
+        ma200: data[:ma200],
+        ma50_prev: data[:ma50] - rand(-1.0..1.0),
+        ma200_prev: data[:ma200] - rand(-0.5..0.5)
+      })
+      
+      @engine.add_fact(:support, {
+        symbol: symbol,
+        level: data[:price] * 0.95
+      })
+      
+      if rand > 0.7
+        @engine.add_fact(:intraday, {
+          symbol: symbol,
+          price: data[:price],
+          vwap: data[:price] + rand(-2.0..2.0),
+          distance_from_vwap: rand(-3.0..3.0)
+        })
+      end
+      
+      if rand > 0.8
+        @engine.add_fact(:news, {
+          symbol: symbol,
+          sentiment: rand(-1.0..1.0),
+          volume: rand(5..50)
+        })
+      end
+      
+      if rand > 0.85
+        @engine.add_fact(:earnings, {
+          symbol: symbol,
+          days_until: rand(1..10),
+          expected_move: rand(3.0..15.0)
+        })
+        
+        @engine.add_fact(:options, {
+          symbol: symbol,
+          iv: rand(20..80),
+          iv_rank: rand(0..100)
+        })
+      end
+      
+      if rand > 0.9
+        @engine.add_fact(:gap, {
+          symbol: symbol,
+          size: rand(-5.0..5.0)
+        })
+      end
+    end
+    
+    @engine.add_fact(:market, {
+      sentiment: ["bullish", "neutral", "bearish"].sample,
+      volatility: rand(10..40)
+    })
+    
+    if @portfolio[:positions].any?
+      total_value = @portfolio[:cash] + @portfolio[:positions].values.sum { |p| p[:value] }
+      max_position = @portfolio[:positions].values.map { |p| p[:value] }.max || 0
+      @engine.add_fact(:portfolio_metrics, {
+        concentration: max_position.to_f / total_value
+      })
+    end
+    
+    @engine.add_fact(:portfolio, {
+      cash: @portfolio[:cash],
+      risk_tolerance: 0.5
+    })
+    
+    if rand > 0.85
+      symbols_pair = symbols.sample(2)
+      @engine.add_fact(:correlation, {
+        symbol1: symbols_pair[0],
+        symbol2: symbols_pair[1],
+        value: rand(0.5..0.95)
+      })
+    end
+    
+    sectors = ["Technology", "Healthcare", "Finance", "Energy", "Consumer"]
+    @engine.add_fact(:sector, {
+      name: sectors.sample,
+      performance: rand(0.8..1.3),
+      trend: ["up", "down", "sideways"].sample
+    })
+  end
+  
+  def run_simulation(symbols: ["AAPL", "GOOGL", "MSFT", "NVDA"], iterations: 10)
+    puts "\n" + "=" * 80
+    puts "ADVANCED STOCK TRADING SYSTEM"
+    puts "=" * 80
+    puts "Initial Capital: $100,000"
+    puts "Symbols: #{symbols.join(', ')}"
+    puts "Rules: #{@engine.rules.size} active trading strategies"
+    puts "=" * 80
+    
+    iterations.times do |i|
+      puts "\n⏰ MARKET TICK #{i + 1} - #{Time.now.strftime('%H:%M:%S')}"
+      puts "-" * 60
+      
+      @engine.working_memory.facts.clear
+      
+      simulate_market_tick(symbols)
+      
+      @engine.run
+      
+      sleep(0.3) if i < iterations - 1
+    end
+    
+    puts "\n" + "=" * 80
+    puts "SIMULATION COMPLETE"
+    puts "=" * 80
+  end
+end
+
+if __FILE__ == $0
+  system = AdvancedStockTradingSystem.new
+  system.run_simulation(
+    symbols: ["AAPL", "GOOGL", "MSFT", "NVDA", "TSLA", "META", "AMZN"],
+    iterations: 12
+  )
+end