kbs 0.0.1

data/lib/kbs/dsl/pattern_evaluator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module KBS
+  module DSL
+    class PatternEvaluator
+      attr_reader :pattern
+
+      def initialize
+        @pattern = {}
+      end
+
+      def method_missing(method, *args, &block)
+        if args.empty? && !block_given?
+          Variable.new(method)
+        elsif args.length == 1 && !block_given?
+          @pattern[method] = args.first
+        elsif block_given?
+          @pattern[method] = block
+        else
+          super
+        end
+      end
+
+      def >(value)
+        ->(v) { v > value }
+      end
+
+      def <(value)
+        ->(v) { v < value }
+      end
+
+      def >=(value)
+        ->(v) { v >= value }
+      end
+
+      def <=(value)
+        ->(v) { v <= value }
+      end
+
+      def ==(value)
+        value
+      end
+
+      def !=(value)
+        ->(v) { v != value }
+      end
+
+      def between(min, max)
+        ->(v) { v >= min && v <= max }
+      end
+
+      def in(collection)
+        ->(v) { collection.include?(v) }
+      end
+
+      def matches(pattern)
+        ->(v) { v.match?(pattern) }
+      end
+
+      def any(*values)
+        ->(v) { values.include?(v) }
+      end
+
+      def all(*conditions)
+        ->(v) { conditions.all? { |c| c.is_a?(Proc) ? c.call(v) : c == v } }
+      end
+    end
+  end
+end

data/lib/kbs/dsl/rule_builder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module KBS
+  module DSL
+    class RuleBuilder
+      include ConditionHelpers
+
+      attr_reader :name, :description, :conditions, :action_block
+
+      def initialize(name)
+        @name = name
+        @description = nil
+        @priority = 0
+        @conditions = []
+        @action_block = nil
+        @current_condition_group = []
+        @negated = false
+      end
+
+      def desc(description)
+        @description = description
+        self
+      end
+
+      def priority(level = nil)
+        return @priority if level.nil?
+        @priority = level
+        self
+      end
+
+      # Primary DSL keywords (avoid Ruby reserved words)
+      def on(type, pattern = {}, &block)
+        if block_given?
+          pattern = pattern.merge(evaluate_block(&block))
+        end
+        @conditions << Condition.new(type, pattern, negated: @negated)
+        @negated = false
+        self
+      end
+
+      def without(type = nil, pattern = {}, &block)
+        if type
+          # Direct negation: without(:problem)
+          @negated = true
+          on(type, pattern, &block)
+        else
+          # Chaining: without.on(:problem)
+          @negated = true
+          self
+        end
+      end
+
+      def perform(&block)
+        @action_block = block
+        self
+      end
+
+      # Aliases for readability
+      def given(type, pattern = {}, &block)
+        on(type, pattern, &block)
+      end
+
+      def matches(type, pattern = {}, &block)
+        on(type, pattern, &block)
+      end
+
+      def fact(type, pattern = {}, &block)
+        on(type, pattern, &block)
+      end
+
+      def exists(type, pattern = {}, &block)
+        on(type, pattern, &block)
+      end
+
+      def absent(type, pattern = {}, &block)
+        without.on(type, pattern, &block)
+      end
+
+      def missing(type, pattern = {}, &block)
+        without.on(type, pattern, &block)
+      end
+
+      def lacks(type, pattern = {}, &block)
+        without.on(type, pattern, &block)
+      end
+
+      def action(&block)
+        perform(&block)
+      end
+
+      def execute(&block)
+        perform(&block)
+      end
+
+      def then(&block)
+        perform(&block)
+      end
+
+      def build
+        Rule.new(@name,
+          conditions: @conditions,
+          action: @action_block,
+          priority: @priority)
+      end
+
+      private
+
+      def evaluate_block(&block)
+        evaluator = PatternEvaluator.new
+        evaluator.instance_eval(&block)
+        evaluator.pattern
+      end
+    end
+  end
+end

data/lib/kbs/dsl/variable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module KBS
+  module DSL
+    class Variable
+      attr_reader :name
+
+      def initialize(name)
+        name_str = name.to_s
+        @name = name_str.start_with?('?') ? name_str.to_sym : "?#{name_str}".to_sym
+      end
+
+      def to_sym
+        @name
+      end
+
+      def to_s
+        @name.to_s
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Variable)
+        @name == other.name
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        @name.hash
+      end
+    end
+  end
+end

data/lib/kbs/dsl.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../kbs'
+
+# DSL components
+require_relative 'dsl/variable'
+require_relative 'dsl/condition_helpers'
+require_relative 'dsl/pattern_evaluator'
+require_relative 'dsl/rule_builder'
+require_relative 'dsl/knowledge_base'
+
+module KBS
+  def self.knowledge_base(&block)
+    kb = DSL::KnowledgeBase.new
+    kb.instance_eval(&block) if block_given?
+    kb
+  end
+end

data/lib/kbs/fact.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module KBS
+  class Fact
+    attr_reader :id, :type, :attributes
+
+    def initialize(type, attributes = {})
+      @id = object_id
+      @type = type
+      @attributes = attributes
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    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}(#{@attributes.map { |k, v| "#{k}: #{v}" }.join(', ')})"
+    end
+  end
+end

data/lib/kbs/join_node.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module KBS
+  class JoinNode
+    attr_accessor :alpha_memory, :beta_memory, :successors, :tests
+    attr_reader :left_linked, :right_linked
+
+    def initialize(alpha_memory, beta_memory, tests = [])
+      @alpha_memory = alpha_memory
+      @beta_memory = beta_memory
+      @successors = []
+      @tests = tests
+      @left_linked = true
+      @right_linked = true
+
+      alpha_memory.successors << self if alpha_memory
+      beta_memory.successors << self if beta_memory
+    end
+
+    def left_unlink!
+      @left_linked = false
+    end
+
+    def left_relink!
+      @left_linked = true
+      @beta_memory.tokens.each { |token| left_activate(token) } if @beta_memory
+    end
+
+    def right_unlink!
+      @right_linked = false
+    end
+
+    def right_relink!
+      @right_linked = true
+      @alpha_memory.items.each { |fact| right_activate(fact) } if @alpha_memory
+    end
+
+    def left_activate(token)
+      # Left activation: a new token from beta memory needs to be joined with facts from alpha memory
+      return unless @left_linked && @right_linked
+
+      @alpha_memory.items.each do |fact|
+        if perform_join_tests(token, fact)
+          new_token = Token.new(token, fact, self)
+          token.children << new_token if token
+          @successors.each { |s| s.activate(new_token) }
+        end
+      end
+    end
+
+    def right_activate(fact)
+      return unless @left_linked && @right_linked
+
+      parent_tokens = @beta_memory ? @beta_memory.tokens : [Token.new(nil, nil, nil)]
+
+      parent_tokens.each do |token|
+        if perform_join_tests(token, fact)
+          new_token = Token.new(token, fact, self)
+          token.children << new_token if token
+          @successors.each { |s| s.activate(new_token) }
+        end
+      end
+    end
+
+    def left_deactivate(token)
+      token.children.each do |child|
+        @successors.each { |s| s.deactivate(child) if s.respond_to?(:deactivate) }
+      end
+      token.children.clear
+    end
+
+    def right_deactivate(fact)
+      tokens_to_remove = []
+
+      if @beta_memory
+        @beta_memory.tokens.each do |token|
+          token.children.select { |child| child.fact == fact }.each do |child|
+            tokens_to_remove << child
+            @successors.each { |s| s.deactivate(child) if s.respond_to?(:deactivate) }
+          end
+        end
+      end
+
+      tokens_to_remove.each { |token| token.parent.children.delete(token) if token.parent }
+    end
+
+    private
+
+    def perform_join_tests(token, fact)
+      @tests.all? do |test|
+        fact_value = fact.attributes[test[:fact_field]]
+
+        # If test has expected_value, compare against that constant
+        if test.key?(:expected_value)
+          if test[:operation] == :eq
+            fact_value == test[:expected_value]
+          elsif test[:operation] == :ne
+            fact_value != test[:expected_value]
+          else
+            true
+          end
+        else
+          # Otherwise compare with token value
+          token_value = token.facts[test[:token_field_index]]&.attributes&.[](test[:token_field])
+
+          if test[:operation] == :eq
+            token_value == fact_value
+          elsif test[:operation] == :ne
+            token_value != fact_value
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kbs/negation_node.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module KBS
+  class NegationNode
+    attr_accessor :alpha_memory, :beta_memory, :successors, :tests
+
+    def initialize(alpha_memory, beta_memory, tests = [])
+      @alpha_memory = alpha_memory
+      @beta_memory = beta_memory
+      @successors = []
+      @tests = tests
+      @tokens_with_matches = Hash.new { |h, k| h[k] = [] }
+
+      alpha_memory.successors << self if alpha_memory
+      beta_memory.successors << self if beta_memory
+    end
+
+    def left_activate(token)
+      matches = @alpha_memory.items.select { |fact| perform_join_tests(token, fact) }
+
+      if matches.empty?
+        new_token = Token.new(token, nil, self)
+        token.children << new_token
+        @successors.each { |s| s.activate(new_token) }
+      else
+        @tokens_with_matches[token] = matches
+      end
+    end
+
+    def right_activate(fact)
+      @beta_memory.tokens.each do |token|
+        if perform_join_tests(token, fact)
+          if @tokens_with_matches[token].empty?
+            token.children.each do |child|
+              @successors.each { |s| s.deactivate(child) if s.respond_to?(:deactivate) }
+            end
+            token.children.clear
+          end
+          @tokens_with_matches[token] << fact
+        end
+      end
+    end
+
+    def right_deactivate(fact)
+      @beta_memory.tokens.each do |token|
+        if @tokens_with_matches[token].include?(fact)
+          @tokens_with_matches[token].delete(fact)
+
+          if @tokens_with_matches[token].empty?
+            new_token = Token.new(token, nil, self)
+            token.children << new_token
+            @successors.each { |s| s.activate(new_token) }
+          end
+        end
+      end
+    end
+
+    private
+
+    def perform_join_tests(token, fact)
+      @tests.all? do |test|
+        fact_value = fact.attributes[test[:fact_field]]
+
+        # If test has expected_value, compare against that constant
+        if test.key?(:expected_value)
+          if test[:operation] == :eq
+            fact_value == test[:expected_value]
+          elsif test[:operation] == :ne
+            fact_value != test[:expected_value]
+          else
+            true
+          end
+        else
+          # Otherwise compare with token value
+          token_value = token.facts[test[:token_field_index]]&.attributes&.[](test[:token_field])
+
+          if test[:operation] == :eq
+            token_value == fact_value
+          elsif test[:operation] == :ne
+            token_value != fact_value
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kbs/production_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module KBS
+  class ProductionNode
+    attr_accessor :rule, :tokens
+
+    def initialize(rule)
+      @rule = rule
+      @tokens = []
+    end
+
+    def activate(token)
+      @tokens << token
+      # Don't fire immediately - wait for run() to fire rules
+      # This allows negation nodes to deactivate tokens before they fire
+    end
+
+    def fire_rule(token)
+      return if token.fired?
+      @rule.fire(token.facts)
+      token.mark_fired!
+    end
+
+    def deactivate(token)
+      @tokens.delete(token)
+    end
+  end
+end

data/lib/kbs/rete_engine.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module KBS
+  class ReteEngine
+    attr_reader :working_memory, :rules, :alpha_memories, :production_nodes
+
+    def initialize
+      @working_memory = WorkingMemory.new
+      @rules = []
+      @alpha_memories = {}
+      @production_nodes = {}
+      @root_beta_memory = BetaMemory.new
+
+      # Add initial dummy token to root beta memory
+      # This represents "no conditions matched yet" and allows the first condition to match
+      @root_beta_memory.add_token(Token.new(nil, nil, nil))
+
+      @working_memory.add_observer(self)
+    end
+
+    def add_rule(rule)
+      @rules << rule
+      build_network_for_rule(rule)
+    end
+
+    def add_fact(type, attributes = {})
+      fact = Fact.new(type, attributes)
+      @working_memory.add_fact(fact)
+      fact
+    end
+
+    def remove_fact(fact)
+      @working_memory.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|
+          node.fire_rule(token)
+        end
+      end
+    end
+
+    private
+
+    def build_network_for_rule(rule)
+      current_beta = @root_beta_memory
+
+      rule.conditions.each_with_index do |condition, index|
+        # Build alpha memory pattern - merge condition type
+        pattern = condition.pattern.merge(type: condition.type)
+        alpha_memory = get_or_create_alpha_memory(pattern)
+
+        # Build join tests - if pattern has :type that differs from condition.type,
+        # add it as an attribute test since it was overwritten in the merge
+        tests = []
+        if condition.pattern[:type] && condition.pattern[:type] != condition.type
+          # The pattern's :type should be checked as an attribute constraint
+          tests << {
+            token_field_index: index,
+            token_field: :type,
+            fact_field: :type,
+            operation: :eq,
+            expected_value: condition.pattern[:type]
+          }
+        end
+
+        if condition.negated
+          negation_node = NegationNode.new(alpha_memory, current_beta, tests)
+          new_beta = BetaMemory.new
+          negation_node.successors << new_beta
+          current_beta = new_beta
+        else
+          join_node = JoinNode.new(alpha_memory, current_beta, tests)
+          new_beta = BetaMemory.new
+          join_node.successors << new_beta
+          current_beta = new_beta
+        end
+      end
+
+      production_node = ProductionNode.new(rule)
+      current_beta.successors << production_node
+      @production_nodes[rule.name] = production_node
+
+      @working_memory.facts.each do |fact|
+        @alpha_memories.each do |pattern, memory|
+          memory.activate(fact) if fact.matches?(pattern)
+        end
+      end
+    end
+
+    def get_or_create_alpha_memory(pattern)
+      @alpha_memories[pattern] ||= AlphaMemory.new(pattern)
+    end
+  end
+end

data/lib/kbs/rule.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module KBS
+  class Rule
+    attr_reader :name, :priority
+    attr_accessor :conditions, :action
+
+    def initialize(name, conditions: [], action: nil, priority: 0, &block)
+      @name = name
+      @conditions = conditions
+      @action = action
+      @priority = priority
+      @fired_count = 0
+
+      yield self if block_given?
+    end
+
+    def fire(facts)
+      @fired_count += 1
+      return unless @action
+
+      bindings = extract_bindings(facts)
+
+      # Support both 1-parameter and 2-parameter actions
+      if @action.arity == 1 || @action.arity == -1
+        @action.call(facts)
+      else
+        @action.call(facts, bindings)
+      end
+    end
+
+    private
+
+    def extract_bindings(facts)
+      bindings = {}
+      @conditions.each_with_index do |condition, index|
+        next if condition.negated
+        fact = facts[index]
+        condition.variable_bindings.each do |var, field|
+          bindings[var] = fact.attributes[field] if fact
+        end
+      end
+      bindings
+    end
+  end
+end

data/lib/kbs/token.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module KBS
+  class Token
+    attr_accessor :parent, :fact, :node, :children
+
+    def initialize(parent, fact, node)
+      @parent = parent
+      @fact = fact
+      @node = node
+      @children = []
+      @fired = false
+    end
+
+    def facts
+      facts = []
+      token = self
+      while token
+        facts.unshift(token.fact) if token.fact
+        token = token.parent
+      end
+      facts
+    end
+
+    def to_s
+      "Token(#{facts.map(&:to_s).join(', ')})"
+    end
+
+    def fired?
+      @fired
+    end
+
+    def mark_fired!
+      @fired = true
+    end
+  end
+end