kbs 0.0.1

data/examples/working_demo.rb

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kbs'
+
+class WorkingTradingDemo
+  def initialize
+    @engine = KBS::ReteEngine.new
+    setup_simple_rules
+  end
+  
+  def setup_simple_rules
+    # Rule 1: Simple stock momentum
+    momentum_rule = KBS::Rule.new(
+      "momentum_buy",
+      conditions: [
+        KBS::Condition.new(:stock, { symbol: "AAPL" })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        puts "🚀 MOMENTUM SIGNAL: #{stock[:symbol]}"
+        puts "   Price: $#{stock[:price]}"
+        puts "   Volume: #{stock[:volume].to_s.reverse.scan(/\d{1,3}/).join(',').reverse}"
+        puts "   Recommendation: BUY"
+      end
+    )
+    
+    # Rule 2: High volume alert
+    volume_rule = KBS::Rule.new(
+      "high_volume",
+      conditions: [
+        KBS::Condition.new(:stock, { volume: ->(v) { v && v > 1000000 } })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        puts "📊 HIGH VOLUME ALERT: #{stock[:symbol]}"
+        puts "   Volume: #{stock[:volume].to_s.reverse.scan(/\d{1,3}/).join(',').reverse}"
+        puts "   Above 1M shares traded"
+      end
+    )
+    
+    # Rule 3: Price movement
+    price_rule = KBS::Rule.new(
+      "price_movement",
+      conditions: [
+        KBS::Condition.new(:stock, { price_change: ->(p) { p && p.abs > 2 } })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        direction = stock[:price_change] > 0 ? "UP" : "DOWN"
+        puts "📈 SIGNIFICANT MOVE: #{stock[:symbol]} #{direction}"
+        puts "   Change: #{stock[:price_change] > 0 ? '+' : ''}#{stock[:price_change]}%"
+      end
+    )
+    
+    # Rule 4: RSI signals
+    rsi_rule = KBS::Rule.new(
+      "rsi_signal",
+      conditions: [
+        KBS::Condition.new(:stock, { rsi: ->(r) { r && (r < 30 || r > 70) } })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        condition = stock[:rsi] < 30 ? "OVERSOLD" : "OVERBOUGHT"
+        action = stock[:rsi] < 30 ? "BUY" : "SELL"
+        puts "⚡ RSI SIGNAL: #{stock[:symbol]} #{condition}"
+        puts "   RSI: #{stock[:rsi].round(1)}"
+        puts "   Recommendation: #{action}"
+      end
+    )
+    
+    # Rule 5: Multi-condition golden cross
+    golden_cross_rule = KBS::Rule.new(
+      "golden_cross_complete",
+      conditions: [
+        KBS::Condition.new(:stock, { symbol: "AAPL" }),
+        KBS::Condition.new(:ma_signal, { type: "golden_cross" })
+      ],
+      action: lambda do |facts, bindings|
+        stock = facts.find { |f| f.type == :stock }
+        signal = facts.find { |f| f.type == :ma_signal }
+        puts "🌟 GOLDEN CROSS CONFIRMED: #{stock[:symbol]}"
+        puts "   50-day MA crossed above 200-day MA"
+        puts "   Price: $#{stock[:price]}"
+        puts "   Recommendation: STRONG BUY"
+      end
+    )
+    
+    @engine.add_rule(momentum_rule)
+    @engine.add_rule(volume_rule)
+    @engine.add_rule(price_rule)
+    @engine.add_rule(rsi_rule)
+    @engine.add_rule(golden_cross_rule)
+  end
+  
+  def run_scenarios
+    puts "🏦 STOCK TRADING EXPERT SYSTEM"
+    puts "=" * 50
+    
+    # Scenario 1: Apple momentum
+    puts "\n📊 SCENARIO 1: Apple with High Volume"
+    puts "-" * 30
+    @engine.working_memory.facts.clear
+    @engine.add_fact(:stock, {
+      symbol: "AAPL",
+      price: 185.50,
+      volume: 1_500_000,
+      price_change: 3.2,
+      rsi: 68
+    })
+    @engine.run
+    
+    # Scenario 2: Google big move
+    puts "\n📊 SCENARIO 2: Google Big Price Move"
+    puts "-" * 30
+    @engine.working_memory.facts.clear
+    @engine.add_fact(:stock, {
+      symbol: "GOOGL",
+      price: 142.80,
+      volume: 800_000,
+      price_change: -4.1,
+      rsi: 75
+    })
+    @engine.run
+    
+    # Scenario 3: Tesla oversold
+    puts "\n📊 SCENARIO 3: Tesla Oversold"
+    puts "-" * 30
+    @engine.working_memory.facts.clear
+    @engine.add_fact(:stock, {
+      symbol: "TSLA",
+      price: 195.40,
+      volume: 2_200_000,
+      price_change: -1.8,
+      rsi: 25
+    })
+    @engine.run
+    
+    # Scenario 4: Apple Golden Cross
+    puts "\n📊 SCENARIO 4: Apple Golden Cross"
+    puts "-" * 30
+    @engine.working_memory.facts.clear
+    @engine.add_fact(:stock, {
+      symbol: "AAPL",
+      price: 190.25,
+      volume: 1_100_000,
+      price_change: 2.1,
+      rsi: 55
+    })
+    @engine.add_fact(:ma_signal, {
+      symbol: "AAPL",
+      type: "golden_cross"
+    })
+    @engine.run
+    
+    # Scenario 5: Multiple signals
+    puts "\n📊 SCENARIO 5: NVIDIA Multiple Signals"
+    puts "-" * 30
+    @engine.working_memory.facts.clear
+    @engine.add_fact(:stock, {
+      symbol: "NVDA",
+      price: 425.80,
+      volume: 3_500_000,
+      price_change: 8.7,
+      rsi: 78
+    })
+    @engine.run
+    
+    puts "\n" + "=" * 50
+    puts "DEMONSTRATION COMPLETE"
+  end
+end
+
+if __FILE__ == $0
+  demo = WorkingTradingDemo.new
+  demo.run_scenarios
+end

data/lib/kbs/alpha_memory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module KBS
+  class AlphaMemory
+    attr_accessor :items, :successors, :pattern
+    attr_reader :linked
+
+    def initialize(pattern = {})
+      @items = []
+      @successors = []
+      @pattern = pattern
+      @linked = true
+    end
+
+    def unlink!
+      @linked = false
+      @successors.each { |s| s.right_unlink! if s.respond_to?(:right_unlink!) }
+    end
+
+    def relink!
+      @linked = true
+      @successors.each { |s| s.right_relink! if s.respond_to?(:right_relink!) }
+    end
+
+    def activate(fact)
+      return unless @linked
+      @items << fact
+      @successors.each { |s| s.right_activate(fact) }
+    end
+
+    def deactivate(fact)
+      return unless @linked
+      @items.delete(fact)
+      @successors.each { |s| s.right_deactivate(fact) if s.respond_to?(:right_deactivate) }
+    end
+  end
+end

data/lib/kbs/beta_memory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module KBS
+  class BetaMemory
+    attr_accessor :tokens, :successors
+    attr_reader :linked
+
+    def initialize
+      @tokens = []
+      @successors = []
+      @linked = true
+    end
+
+    def unlink!
+      @linked = false
+      @successors.each { |s| s.left_unlink! if s.respond_to?(:left_unlink!) }
+    end
+
+    def relink!
+      @linked = true
+      @successors.each { |s| s.left_relink! if s.respond_to?(:left_relink!) }
+    end
+
+    def activate(token)
+      add_token(token)
+      @successors.each do |s|
+        if s.respond_to?(:left_activate)
+          s.left_activate(token)
+        elsif s.respond_to?(:activate)
+          s.activate(token)
+        end
+      end
+    end
+
+    def deactivate(token)
+      remove_token(token)
+      @successors.each do |s|
+        if s.respond_to?(:left_deactivate)
+          s.left_deactivate(token)
+        elsif s.respond_to?(:deactivate)
+          s.deactivate(token)
+        end
+      end
+    end
+
+    def add_token(token)
+      @tokens << token
+      unlink! if @tokens.empty?
+      relink! if @tokens.size == 1
+    end
+
+    def remove_token(token)
+      @tokens.delete(token)
+      unlink! if @tokens.empty?
+    end
+  end
+end

data/lib/kbs/blackboard/audit_log.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module KBS
+  module Blackboard
+    class AuditLog
+      def initialize(db, session_id)
+        @db = db
+        @session_id = session_id
+        setup_tables
+      end
+
+      def setup_tables
+        @db.execute_batch <<-SQL
+          CREATE TABLE IF NOT EXISTS fact_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            fact_uuid TEXT NOT NULL,
+            fact_type TEXT NOT NULL,
+            attributes TEXT NOT NULL,
+            action TEXT NOT NULL,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            session_id TEXT
+          );
+
+          CREATE TABLE IF NOT EXISTS rules_fired (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            rule_name TEXT NOT NULL,
+            fact_uuids TEXT NOT NULL,
+            bindings TEXT,
+            fired_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            session_id TEXT
+          );
+        SQL
+
+        @db.execute_batch <<-SQL
+          CREATE INDEX IF NOT EXISTS idx_fact_history_uuid ON fact_history(fact_uuid);
+          CREATE INDEX IF NOT EXISTS idx_rules_fired_session ON rules_fired(session_id);
+        SQL
+      end
+
+      def log_fact_change(fact_uuid, fact_type, attributes, action)
+        attributes_json = attributes.is_a?(String) ? attributes : JSON.generate(attributes)
+
+        @db.execute(
+          "INSERT INTO fact_history (fact_uuid, fact_type, attributes, action, session_id) VALUES (?, ?, ?, ?, ?)",
+          [fact_uuid, fact_type.to_s, attributes_json, action, @session_id]
+        )
+      end
+
+      def log_rule_firing(rule_name, fact_uuids, bindings = {})
+        @db.execute(
+          "INSERT INTO rules_fired (rule_name, fact_uuids, bindings, session_id) VALUES (?, ?, ?, ?)",
+          [rule_name, JSON.generate(fact_uuids), JSON.generate(bindings), @session_id]
+        )
+      end
+
+      def fact_history(fact_uuid = nil, limit: 100)
+        if fact_uuid
+          results = @db.execute(
+            "SELECT * FROM fact_history WHERE fact_uuid = ? ORDER BY timestamp DESC, id DESC LIMIT ?",
+            [fact_uuid, limit]
+          )
+        else
+          results = @db.execute(
+            "SELECT * FROM fact_history ORDER BY timestamp DESC, id DESC LIMIT ?",
+            [limit]
+          )
+        end
+
+        results.map do |row|
+          {
+            fact_uuid: row['fact_uuid'],
+            fact_type: row['fact_type'].to_sym,
+            attributes: JSON.parse(row['attributes'], symbolize_names: true),
+            action: row['action'],
+            timestamp: Time.parse(row['timestamp']),
+            session_id: row['session_id']
+          }
+        end
+      end
+
+      def rule_firings(rule_name = nil, limit: 100)
+        if rule_name
+          results = @db.execute(
+            "SELECT * FROM rules_fired WHERE rule_name = ? ORDER BY fired_at DESC LIMIT ?",
+            [rule_name, limit]
+          )
+        else
+          results = @db.execute(
+            "SELECT * FROM rules_fired ORDER BY fired_at DESC LIMIT ?",
+            [limit]
+          )
+        end
+
+        results.map do |row|
+          {
+            rule_name: row['rule_name'],
+            fact_uuids: JSON.parse(row['fact_uuids']),
+            bindings: row['bindings'] ? JSON.parse(row['bindings'], symbolize_names: true) : {},
+            fired_at: Time.parse(row['fired_at']),
+            session_id: row['session_id']
+          }
+        end
+      end
+
+      def stats
+        {
+          rules_fired: @db.get_first_value("SELECT COUNT(*) FROM rules_fired")
+        }
+      end
+    end
+  end
+end

data/lib/kbs/blackboard/engine.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../rete_engine'
+require_relative 'memory'
+
+module KBS
+  module Blackboard
+    # RETE engine integrated with Blackboard memory
+    class Engine < ReteEngine
+      attr_reader :blackboard
+
+      def initialize(db_path: ':memory:', store: nil)
+        super()
+        @blackboard = Memory.new(db_path: db_path, store: store)
+        @working_memory = @blackboard
+        @blackboard.add_observer(self)
+      end
+
+      def add_fact(type, attributes = {})
+        @blackboard.add_fact(type, attributes)
+      end
+
+      def remove_fact(fact)
+        @blackboard.remove_fact(fact)
+      end
+
+      def update(action, fact)
+        if action == :add
+          @alpha_memories.each do |pattern, memory|
+            memory.activate(fact) if fact.matches?(pattern)
+          end
+        elsif action == :remove
+          @alpha_memories.each do |pattern, memory|
+            memory.deactivate(fact) if fact.matches?(pattern)
+          end
+        end
+      end
+
+      def run
+        @production_nodes.values.each do |node|
+          node.tokens.each do |token|
+            # Only fire if not already fired
+            next if token.fired?
+
+            fact_uuids = token.facts.map { |f| f.respond_to?(:uuid) ? f.uuid : f.object_id.to_s }
+            bindings = extract_bindings_from_token(token, node.rule)
+
+            @blackboard.log_rule_firing(node.rule.name, fact_uuids, bindings)
+            node.fire_rule(token)
+          end
+        end
+      end
+
+      def post_message(sender, topic, content, priority: 0)
+        @blackboard.post_message(sender, topic, content, priority: priority)
+      end
+
+      def consume_message(topic, consumer)
+        @blackboard.consume_message(topic, consumer)
+      end
+
+      def stats
+        @blackboard.stats
+      end
+
+      private
+
+      def extract_bindings_from_token(token, rule)
+        bindings = {}
+        rule.conditions.each_with_index do |condition, index|
+          next if condition.negated
+          fact = token.facts[index]
+          if fact && condition.respond_to?(:variable_bindings)
+            condition.variable_bindings.each do |var, field|
+              bindings[var] = fact.attributes[field] if fact.respond_to?(:attributes)
+            end
+          end
+        end
+        bindings
+      end
+    end
+  end
+end

data/lib/kbs/blackboard/fact.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module KBS
+  module Blackboard
+    # A fact in the blackboard with persistence capabilities
+    class Fact
+      attr_reader :uuid, :type, :attributes
+
+      def initialize(uuid, type, attributes, blackboard = nil)
+        @uuid = uuid
+        @type = type
+        @attributes = attributes
+        @blackboard = blackboard
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def []=(key, value)
+        @attributes[key] = value
+        @blackboard.update_fact(self, @attributes) if @blackboard
+      end
+
+      def update(new_attributes)
+        @attributes.merge!(new_attributes)
+        @blackboard.update_fact(self, @attributes) if @blackboard
+      end
+
+      def retract
+        @blackboard.remove_fact(self) if @blackboard
+      end
+
+      def matches?(pattern)
+        return false if pattern[:type] && pattern[:type] != @type
+
+        pattern.each do |key, value|
+          next if key == :type
+
+          if value.is_a?(Proc)
+            return false unless @attributes[key] && value.call(@attributes[key])
+          elsif value.is_a?(Symbol) && value.to_s.start_with?('?')
+            next
+          else
+            return false unless @attributes[key] == value
+          end
+        end
+
+        true
+      end
+
+      def to_s
+        "#{@type}(#{@uuid[0..7]}...: #{@attributes.map { |k, v| "#{k}=#{v}" }.join(', ')})"
+      end
+
+      def to_h
+        {
+          uuid: @uuid,
+          type: @type,
+          attributes: @attributes
+        }
+      end
+    end
+  end
+end