kbs 0.0.1 → 0.1.0

data/examples/redis_trading_demo_dsl.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 (raw API since Blackboard::Engine doesn't use DSL)
+  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 (raw API since Blackboard::Engine doesn't use DSL)
+  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/run_all.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run all example files in the examples directory
+
+require 'pathname'
+
+# Get the directory where this script is located
+examples_dir = Pathname.new(__FILE__).dirname
+
+# Find all Ruby files except this one
+example_files = Dir.glob(examples_dir.join('*.rb'))
+                   .reject { |f| File.basename(f).start_with? 'run_all' }
+                   .reject { |f| File.basename(f).end_with? '_dsl.rb' }
+                   .sort
+
+puts
+puts "Running #{example_files.size} examples from #{examples_dir}"
+puts
+puts
+
+example_files.each_with_index do |file, index|
+  filename = File.basename(file)
+  filename_size = filename.size + 6
+
+  STDERR.puts "Running example #{index + 1}/#{example_files.size}: #{filename} ..."
+
+  puts
+  puts "=" * filename_size
+  puts "## #{filename} ##"
+  puts "=" * filename_size
+  puts
+
+  # Run the example
+  system("ruby", file)
+
+  exit_status = $?.exitstatus
+
+  if exit_status != 0
+    puts
+    puts "⚠️  Example #{filename} exited with status #{exit_status}"
+  end
+
+  puts
+end
+
+puts
+puts
+puts "Completed running all #{example_files.size} examples"
+puts

data/examples/run_all_dsl.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run all example DSL files in the examples directory
+
+require 'pathname'
+
+# Get the directory where this script is located
+examples_dir = Pathname.new(__FILE__).dirname
+
+# Find all Ruby files except this one
+example_files = Dir.glob(examples_dir.join('*_dsl.rb'))
+                   .reject { |f| File.basename(f).start_with? 'run_all' }
+                   .sort
+
+puts
+puts "Running #{example_files.size} examples from #{examples_dir}"
+puts
+puts
+
+example_files.each_with_index do |file, index|
+  filename = File.basename(file)
+  filename_size = filename.size + 6
+
+  STDERR.puts "Running example #{index + 1}/#{example_files.size}: #{filename} ..."
+
+  puts
+  puts "=" * filename_size
+  puts "## #{filename} ##"
+  puts "=" * filename_size
+  puts
+
+  # Run the example
+  system("ruby", file)
+
+  exit_status = $?.exitstatus
+
+  if exit_status != 0
+    puts
+    puts "⚠️  Example #{filename} exited with status #{exit_status}"
+  end
+
+  puts
+end
+
+puts
+puts
+puts "Completed running all #{example_files.size} examples"
+puts

data/examples/stock_trading_advanced.rb

@@ -4,7 +4,7 @@ require_relative '../lib/kbs'
 
 class AdvancedStockTradingSystem
   def initialize
-    @engine = KBS::ReteEngine.new
+    @engine = KBS::Engine.new
     @portfolio = {
       cash: 100000,
       positions: {},

data/examples/stock_trading_advanced_dsl.rb

@@ -0,0 +1,404 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kbs/dsl'
+
+class AdvancedStockTradingSystem
+  include KBS::DSL::ConditionHelpers
+
+  def initialize
+    @kb = nil
+    @portfolio = {
+      cash: 100000,
+      positions: {},
+      total_value: 100000
+    }
+    @market_data = {}
+    setup_rules
+  end
+
+  def setup_rules
+    @kb = KBS.knowledge_base do
+      rule "golden_cross" do
+        priority 15
+        on :technical,
+          indicator: "ma_crossover",
+          ma50: satisfies { |v| v > 0 },
+          ma200: satisfies { |v| v > 0 }
+        on :stock, volume: satisfies { |v| v > 1000000 }
+        without.on :position, status: "open"
+
+        perform do |facts|
+          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
+      end
+
+      rule "momentum_breakout" do
+        priority 12
+        on :stock,
+          price_change: satisfies { |v| v > 3 },
+          volume_ratio: satisfies { |v| v > 1.5 },
+          rsi: satisfies { |v| v.between?(40, 70) }
+        on :market, sentiment: satisfies { |s| ["bullish", "neutral"].include?(s) }
+
+        perform do |facts|
+          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
+      end
+
+      rule "oversold_bounce" do
+        priority 10
+        on :stock,
+          rsi: satisfies { |v| v < 30 },
+          price: satisfies { |p| p > 0 }
+        on :support, level: satisfies { |l| l > 0 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "trailing_stop" do
+        priority 18
+        on :position,
+          status: "open",
+          profit_pct: satisfies { |p| p > 5 }
+        on :stock, price: satisfies { |p| p > 0 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "position_sizing" do
+        priority 8
+        on :signal,
+          action: "buy",
+          confidence: satisfies { |c| c > 0.6 }
+        on :portfolio, cash: satisfies { |c| c > 1000 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "earnings_play" do
+        priority 11
+        on :earnings,
+          days_until: satisfies { |d| d.between?(1, 5) },
+          expected_move: satisfies { |m| m > 5 }
+        on :options,
+          iv: satisfies { |v| v > 30 },
+          iv_rank: satisfies { |r| r > 50 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "sector_rotation" do
+        priority 7
+        on :sector,
+          performance: satisfies { |p| p > 1.1 },
+          trend: "up"
+        on :position,
+          sector: satisfies { |s| s != nil },
+          profit_pct: satisfies { |p| p < 2 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "risk_concentration" do
+        priority 16
+        on :portfolio_metrics, concentration: satisfies { |c| c > 0.3 }
+        on :market, volatility: satisfies { |v| v > 25 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "vwap_reversion" do
+        priority 9
+        on :intraday, distance_from_vwap: satisfies { |d| d.abs > 2 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "news_sentiment" do
+        priority 13
+        on :news,
+          sentiment: satisfies { |s| s.abs > 0.7 },
+          volume: satisfies { |v| v > 10 }
+        on :stock, price_change: satisfies { |p| p.abs < 2 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "correlation_warning" do
+        priority 6
+        on :correlation, value: satisfies { |v| v > 0.8 }
+
+        perform do |facts|
+          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
+      end
+
+      rule "gap_fade" do
+        priority 8
+        on :gap, size: satisfies { |s| s.abs > 2 }
+        on :stock, atr: satisfies { |a| a > 0 }
+
+        perform do |facts|
+          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
+      end
+    end
+  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
+
+      @kb.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)
+      }
+
+      @kb.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)
+      }
+
+      @kb.fact :support, {
+        symbol: symbol,
+        level: data[:price] * 0.95
+      }
+
+      if rand > 0.7
+        @kb.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
+        @kb.fact :news, {
+          symbol: symbol,
+          sentiment: rand(-1.0..1.0),
+          volume: rand(5..50)
+        }
+      end
+
+      if rand > 0.85
+        @kb.fact :earnings, {
+          symbol: symbol,
+          days_until: rand(1..10),
+          expected_move: rand(3.0..15.0)
+        }
+
+        @kb.fact :options, {
+          symbol: symbol,
+          iv: rand(20..80),
+          iv_rank: rand(0..100)
+        }
+      end
+
+      if rand > 0.9
+        @kb.fact :gap, {
+          symbol: symbol,
+          size: rand(-5.0..5.0)
+        }
+      end
+    end
+
+    @kb.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
+      @kb.fact :portfolio_metrics, {
+        concentration: max_position.to_f / total_value
+      }
+    end
+
+    @kb.fact :portfolio, {
+      cash: @portfolio[:cash],
+      risk_tolerance: 0.5
+    }
+
+    if rand > 0.85
+      symbols_pair = symbols.sample(2)
+      @kb.fact :correlation, {
+        symbol1: symbols_pair[0],
+        symbol2: symbols_pair[1],
+        value: rand(0.5..0.95)
+      }
+    end
+
+    sectors = ["Technology", "Healthcare", "Finance", "Energy", "Consumer"]
+    @kb.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: #{@kb.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
+
+      @kb.reset
+
+      simulate_market_tick(symbols)
+
+      @kb.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