kbs 0.0.1 → 0.2.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/rule_source_demo.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kbs'
+
+puts "Rule Source Introspection Demo"
+puts "=" * 60
+puts
+puts "KBS can show the source of any rule — whether it was defined"
+puts "in a file (exact source) or built dynamically at runtime"
+puts "(reconstructed from bytecode via KBS::Decompiler)."
+puts
+
+# ── Part 1: File-defined rules ───────────────────────────────
+
+puts "PART 1: File-Defined Rules"
+puts "-" * 60
+puts
+
+kb = KBS.knowledge_base do
+  rule "dead_battery" do
+    on :symptom, problem: "won't start"
+    on :symptom, problem: "no lights"
+
+    perform do |facts, bindings|
+      puts "DIAGNOSIS: Dead battery"
+      puts "RECOMMENDATION: Replace or jump-start the battery"
+    end
+  end
+
+  rule "overheating" do
+    on :symptom, problem: "high temperature"
+    on :symptom, problem: "steam from hood"
+    without :symptom, problem: "coolant leak"
+
+    perform do |facts, bindings|
+      puts "DIAGNOSIS: Engine overheating (no coolant leak)"
+      puts "RECOMMENDATION: Check radiator and cooling system"
+    end
+  end
+end
+
+kb.rules.each_key do |name|
+  puts "Source for '#{name}':"
+  puts
+  kb.print_rule_source(name)
+  puts
+end
+
+# ── Part 2: Dynamically-created rules ────────────────────────
+
+puts
+puts "PART 2: Dynamically-Created Rules"
+puts "-" * 60
+puts
+puts "These rules have no source file — KBS reconstructs them"
+puts "from their internal state using YARV bytecode decompilation."
+puts
+
+# Simulate what an AI agent framework might do: build rules at
+# runtime from configuration data, user input, or LLM output.
+
+dynamic_kb = KBS::DSL::KnowledgeBase.new
+
+# Rule with lambda condition helpers
+builder = KBS::DSL::RuleBuilder.new("high_temp_alert")
+builder.desc "Fire when temperature exceeds safe threshold"
+builder.priority 5
+builder.on :sensor, location: "server_room", temp: ->(v) { v > 85 }
+builder.without :alert, type: :cooling_active
+builder.perform { |facts| puts "ALERT: Server room temperature critical!" }
+
+rule = builder.build
+dynamic_kb.instance_variable_get(:@rule_builders)["high_temp_alert"] = builder
+dynamic_kb.instance_variable_get(:@rules)["high_temp_alert"] = rule
+dynamic_kb.engine.add_rule(rule)
+
+# Rule with multiple proc-based conditions
+builder2 = KBS::DSL::RuleBuilder.new("buy_signal")
+builder2.on :stock, price: ->(v) { v < 150 }, volume: ->(v) { v > 1_000_000 }
+builder2.without :position, status: :open
+builder2.perform { |facts| puts "BUY signal triggered" }
+
+rule2 = builder2.build
+dynamic_kb.instance_variable_get(:@rule_builders)["buy_signal"] = builder2
+dynamic_kb.instance_variable_get(:@rules)["buy_signal"] = rule2
+dynamic_kb.engine.add_rule(rule2)
+
+["high_temp_alert", "buy_signal"].each do |name|
+  puts "Reconstructed source for '#{name}':"
+  puts
+  dynamic_kb.print_rule_source(name)
+  puts
+end
+
+# ── Part 3: Decompiler standalone ─────────────────────────────
+
+puts
+puts "PART 3: KBS::Decompiler Standalone"
+puts "-" * 60
+puts
+puts "The decompiler works on any Proc or Lambda:"
+puts
+
+examples = {
+  "lambda"  => ->(x) { x * 2 + 1 },
+  "proc"    => proc { |a, b| a > b },
+  "complex" => ->(items) { items.select { |x| x > 0 }.map { |x| x * 2 } },
+}
+
+examples.each do |label, pr|
+  puts "  #{label}:"
+  puts "    decompile       => #{KBS::Decompiler.new(pr).decompile}"
+  puts "    decompile_block => #{KBS::Decompiler.new(pr).decompile_block}"
+  puts
+end
+
+# ── Part 4: Unknown rule ──────────────────────────────────────
+
+puts "PART 4: Unknown Rule"
+puts "-" * 60
+puts
+kb.print_rule_source("nonexistent")
+puts "  rule_source returns: #{kb.rule_source('nonexistent').inspect}"

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: {},