lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/affordance/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/affordance/helpers/constants'
+require 'legion/extensions/agentic/inference/affordance/helpers/affordance_item'
+require 'legion/extensions/agentic/inference/affordance/helpers/affordance_field'
+require 'legion/extensions/agentic/inference/affordance/runners/affordance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          class Client
+            include Runners::Affordance
+
+            def initialize(field: nil, **)
+              @field = field || Helpers::AffordanceField.new
+            end
+
+            private
+
+            attr_reader :field
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance/helpers/affordance_field.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          module Helpers
+            class AffordanceField
+              include Constants
+
+              attr_reader :affordances, :capabilities, :environment
+
+              def initialize
+                @affordances   = {}
+                @capabilities  = {}
+                @environment   = {}
+                @counter       = 0
+                @history       = []
+              end
+
+              def register_capability(name:, domain: :general, level: 1.0)
+                return nil if @capabilities.size >= MAX_CAPABILITIES
+
+                @capabilities[name] = { domain: domain, level: level.to_f.clamp(0.0, 1.0) }
+              end
+
+              def set_environment(property:, value:, domain: :general)
+                return nil if @environment.size >= MAX_ENVIRONMENT_PROPS && !@environment.key?(property)
+
+                @environment[property] = { value: value, domain: domain, updated_at: Time.now.utc }
+              end
+
+              def detect_affordance(action:, domain:, affordance_type:, requires: [], relevance: DEFAULT_RELEVANCE)
+                return nil unless AFFORDANCE_TYPES.include?(affordance_type)
+                return nil if @affordances.size >= MAX_AFFORDANCES
+
+                @counter += 1
+                aff_id = :"aff_#{@counter}"
+                aff = AffordanceItem.new(
+                  id: aff_id, action: action, domain: domain,
+                  affordance_type: affordance_type, requires: requires, relevance: relevance
+                )
+                @affordances[aff_id] = aff
+                record_detection(aff)
+                aff
+              end
+
+              def evaluate_action(action:, domain:)
+                matching = @affordances.values.select { |a| a.action == action && a.domain == domain }
+                return { feasible: false, reason: :no_affordance } if matching.empty?
+
+                check_blockers(matching) || build_evaluation(matching)
+              end
+
+              def actionable_affordances
+                @affordances.values.select(&:actionable?).sort_by { |a| -a.relevance }.map(&:to_h)
+              end
+
+              def threats
+                @affordances.values.select(&:threatening?).map(&:to_h)
+              end
+
+              def affordances_in(domain:)
+                @affordances.values.select { |a| a.domain == domain }.map(&:to_h)
+              end
+
+              def decay_all
+                @affordances.each_value(&:decay)
+                @affordances.reject! { |_, a| a.faded? }
+              end
+
+              def to_h
+                {
+                  affordance_count:  @affordances.size,
+                  capability_count:  @capabilities.size,
+                  environment_props: @environment.size,
+                  actionable_count:  @affordances.values.count(&:actionable?),
+                  blocked_count:     @affordances.values.count(&:blocked?),
+                  threat_count:      @affordances.values.count(&:threatening?),
+                  history_size:      @history.size
+                }
+              end
+
+              private
+
+              def check_blockers(matching)
+                blockers = matching.select(&:blocked?)
+                return nil if blockers.empty?
+
+                { feasible: false, reason: :blocked, blockers: blockers.map(&:to_h) }
+              end
+
+              def build_evaluation(matching)
+                capabilities_met = check_requirements(matching)
+                {
+                  feasible:         capabilities_met,
+                  reason:           capabilities_met ? :capable : :missing_capabilities,
+                  risks:            matching.select(&:risky?).map(&:to_h),
+                  relevance:        matching.map(&:relevance).max,
+                  affordance_count: matching.size
+                }
+              end
+
+              def check_requirements(affordances)
+                required = affordances.flat_map(&:requires).uniq
+                return true if required.empty?
+
+                required.all? { |r| @capabilities.key?(r) }
+              end
+
+              def record_detection(affordance)
+                @history << { id: affordance.id, action: affordance.action, type: affordance.affordance_type,
+                              at: Time.now.utc }
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance/helpers/affordance_item.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          module Helpers
+            class AffordanceItem
+              include Constants
+
+              attr_reader :id, :action, :domain, :affordance_type, :requires, :detected_at
+              attr_accessor :relevance
+
+              def initialize(id:, action:, domain:, affordance_type:, requires: [], relevance: DEFAULT_RELEVANCE)
+                @id              = id
+                @action          = action
+                @domain          = domain
+                @affordance_type = affordance_type
+                @requires        = Array(requires)
+                @relevance       = relevance.to_f.clamp(0.0, 1.0)
+                @detected_at     = Time.now.utc
+              end
+
+              def actionable?
+                %i[action_possible resource_available opportunity].include?(@affordance_type) &&
+                  @relevance >= ACTIONABLE_THRESHOLD
+              end
+
+              def blocked?
+                @affordance_type == :action_blocked
+              end
+
+              def risky?
+                @affordance_type == :action_risky
+              end
+
+              def threatening?
+                @affordance_type == :threat
+              end
+
+              def decay
+                @relevance = [@relevance - RELEVANCE_DECAY, 0.0].max
+              end
+
+              def faded?
+                @relevance <= RELEVANCE_FLOOR
+              end
+
+              def relevance_label
+                RELEVANCE_LABELS.each { |range, lbl| return lbl if range.cover?(@relevance) }
+                :negligible
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  action:          @action,
+                  domain:          @domain,
+                  affordance_type: @affordance_type,
+                  requires:        @requires,
+                  relevance:       @relevance.round(4),
+                  relevance_label: relevance_label,
+                  actionable:      actionable?,
+                  blocked:         blocked?,
+                  risky:           risky?
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance/helpers/constants.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          module Helpers
+            module Constants
+              MAX_AFFORDANCES       = 200
+              MAX_CAPABILITIES      = 50
+              MAX_ENVIRONMENT_PROPS = 100
+              MAX_HISTORY           = 200
+
+              RELEVANCE_FLOOR       = 0.05
+              RELEVANCE_DECAY       = 0.01
+              DEFAULT_RELEVANCE     = 0.5
+              URGENCY_BOOST         = 0.2
+
+              CAPABILITY_MATCH_THRESHOLD = 0.3
+              ACTIONABLE_THRESHOLD       = 0.5
+
+              AFFORDANCE_TYPES = %i[
+                action_possible action_blocked action_risky
+                resource_available resource_depleted
+                opportunity threat neutral
+              ].freeze
+
+              RELEVANCE_LABELS = {
+                (0.8..)     => :critical,
+                (0.6...0.8) => :important,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :minor,
+                (..0.2)     => :negligible
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance/runners/affordance.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          module Runners
+            module Affordance
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_capability(name:, domain: :general, level: 1.0, **)
+                Legion::Logging.debug "[affordance] capability: #{name} domain=#{domain}"
+                cap = field.register_capability(name: name, domain: domain, level: level)
+                if cap
+                  { success: true, capability: name, capabilities: field.capabilities.size }
+                else
+                  { success: false, reason: :limit_reached }
+                end
+              end
+
+              def set_environment(property:, value:, domain: :general, **)
+                Legion::Logging.debug "[affordance] env: #{property}=#{value}"
+                result = field.set_environment(property: property, value: value, domain: domain)
+                if result
+                  { success: true, property: property }
+                else
+                  { success: false, reason: :limit_reached }
+                end
+              end
+
+              def detect_affordance(action:, domain:, affordance_type:, requires: [], relevance: nil, **)
+                rel = relevance || Helpers::Constants::DEFAULT_RELEVANCE
+                Legion::Logging.debug "[affordance] detect: #{action} type=#{affordance_type}"
+                aff = field.detect_affordance(
+                  action: action, domain: domain, affordance_type: affordance_type.to_sym,
+                  requires: requires, relevance: rel
+                )
+                if aff
+                  { success: true, affordance: aff.to_h }
+                else
+                  { success: false, reason: :invalid_or_full }
+                end
+              end
+
+              def evaluate_action(action:, domain:, **)
+                result = field.evaluate_action(action: action, domain: domain)
+                Legion::Logging.debug "[affordance] evaluate: #{action} feasible=#{result[:feasible]}"
+                { success: true, **result }
+              end
+
+              def actionable_affordances(**)
+                items = field.actionable_affordances
+                { success: true, affordances: items, count: items.size }
+              end
+
+              def current_threats(**)
+                items = field.threats
+                { success: true, threats: items, count: items.size }
+              end
+
+              def affordances_in_domain(domain:, **)
+                items = field.affordances_in(domain: domain)
+                { success: true, affordances: items, count: items.size }
+              end
+
+              def update_affordances(**)
+                Legion::Logging.debug '[affordance] tick'
+                field.decay_all
+                { success: true, remaining: field.affordances.size }
+              end
+
+              def affordance_stats(**)
+                Legion::Logging.debug '[affordance] stats'
+                { success: true, stats: field.to_h }
+              end
+
+              private
+
+              def field
+                @field ||= Helpers::AffordanceField.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+          VERSION = '0.1.2'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/affordance.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/affordance/version'
+require 'legion/extensions/agentic/inference/affordance/helpers/constants'
+require 'legion/extensions/agentic/inference/affordance/helpers/affordance_item'
+require 'legion/extensions/agentic/inference/affordance/helpers/affordance_field'
+require 'legion/extensions/agentic/inference/affordance/runners/affordance'
+require 'legion/extensions/agentic/inference/affordance/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Affordance
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/analogical/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/analogical/helpers/constants'
+require 'legion/extensions/agentic/inference/analogical/helpers/structure_map'
+require 'legion/extensions/agentic/inference/analogical/helpers/analogy_engine'
+require 'legion/extensions/agentic/inference/analogical/runners/analogical_reasoning'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+          class Client
+            include Runners::AnalogicalReasoning
+
+            def initialize(engine: nil, **)
+              @engine = engine || Helpers::AnalogyEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/analogical/helpers/analogy_engine.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+          module Helpers
+            class AnalogyEngine
+              include Constants
+
+              attr_reader :history
+
+              def initialize
+                @analogies = {}
+                @domains   = Set.new
+                @history   = []
+              end
+
+              def create_analogy(source_domain:, target_domain:, mappings:, mapping_type:, strength: nil)
+                evict_oldest_analogy if @analogies.size >= Constants::MAX_ANALOGIES
+
+                analogy = StructureMap.new(
+                  source_domain: source_domain,
+                  target_domain: target_domain,
+                  mappings:      mappings,
+                  mapping_type:  mapping_type,
+                  strength:      strength
+                )
+
+                @analogies[analogy.id] = analogy
+                register_domain(source_domain)
+                register_domain(target_domain)
+                record_history(:created, analogy.id)
+
+                analogy
+              end
+
+              def find_analogies(domain:)
+                @analogies.values.select do |analogy|
+                  analogy.source_domain == domain || analogy.target_domain == domain
+                end
+              end
+
+              def apply_analogy(analogy_id:, source_element:)
+                analogy = @analogies[analogy_id]
+                return { found: false } unless analogy
+
+                target_element = analogy.mappings[source_element]
+                return { found: true, mapped: false } unless target_element
+
+                analogy.use!
+                record_history(:applied, analogy_id)
+
+                {
+                  found:          true,
+                  mapped:         true,
+                  source_element: source_element,
+                  target_element: target_element,
+                  confidence:     analogy.strength,
+                  analogy_id:     analogy_id
+                }
+              end
+
+              def evaluate_similarity(source:, target:)
+                return 0.0 if source.empty? || target.empty?
+
+                structural = structural_overlap(source, target)
+                surface    = surface_overlap(source, target)
+                (Constants::STRUCTURAL_WEIGHT * structural) + (Constants::SURFACE_WEIGHT * surface)
+              end
+
+              def cross_domain_transfer(analogy_id:, source_knowledge:)
+                analogy = @analogies[analogy_id]
+                return { transferred: false, reason: :not_found } unless analogy
+
+                transferred = {}
+                source_knowledge.each do |key, value|
+                  mapped_key = analogy.mappings.fetch(key, nil)
+                  transferred[mapped_key] = value if mapped_key
+                end
+
+                analogy.use!
+                record_history(:transferred, analogy_id)
+
+                {
+                  transferred:   true,
+                  analogy_id:    analogy_id,
+                  source_domain: analogy.source_domain,
+                  target_domain: analogy.target_domain,
+                  result:        transferred,
+                  coverage:      coverage_ratio(source_knowledge, transferred)
+                }
+              end
+
+              def reinforce_analogy(analogy_id:, success:)
+                analogy = @analogies[analogy_id]
+                return { reinforced: false, reason: :not_found } unless analogy
+
+                if success
+                  analogy.reinforce
+                  record_history(:reinforced, analogy_id)
+                else
+                  analogy.weaken
+                  record_history(:weakened, analogy_id)
+                end
+
+                { reinforced: true, analogy_id: analogy_id, strength: analogy.strength, state: analogy.state }
+              end
+
+              def productive_analogies
+                @analogies.values.select(&:productive?)
+              end
+
+              def by_domain(domain:)
+                find_analogies(domain: domain)
+              end
+
+              def by_type(type:)
+                @analogies.values.select { |analogy| analogy.mapping_type == type }
+              end
+
+              def decay_all
+                @analogies.each_value(&:decay)
+              end
+
+              def prune_stale
+                stale_ids = @analogies.select { |_id, analogy| analogy.state == :stale }.keys
+                stale_ids.each { |id| @analogies.delete(id) }
+                stale_ids.size
+              end
+
+              def to_h
+                {
+                  total_analogies:  @analogies.size,
+                  total_domains:    @domains.size,
+                  productive_count: productive_analogies.size,
+                  history_count:    @history.size,
+                  domains:          @domains.to_a,
+                  analogy_states:   state_counts
+                }
+              end
+
+              private
+
+              def register_domain(domain)
+                @domains.add(domain)
+                evict_oldest_domain if @domains.size > Constants::MAX_DOMAINS
+              end
+
+              def evict_oldest_analogy
+                oldest_id = @analogies.min_by { |_id, analogy| analogy.last_used_at }&.first
+                @analogies.delete(oldest_id) if oldest_id
+              end
+
+              def evict_oldest_domain
+                @domains.delete(@domains.first)
+              end
+
+              def record_history(event, analogy_id)
+                entry = { event: event, analogy_id: analogy_id, at: Time.now.utc }
+                @history << entry
+                @history.shift while @history.size > Constants::MAX_HISTORY
+              end
+
+              def structural_overlap(source, target)
+                source_keys = source.keys.to_set(&:to_s)
+                target_keys = target.keys.to_set(&:to_s)
+                union = source_keys | target_keys
+                return 0.0 if union.empty?
+
+                (source_keys & target_keys).size.to_f / union.size
+              end
+
+              def surface_overlap(source, target)
+                common = source.keys.to_set(&:to_s) & target.keys.to_set(&:to_s)
+                surface_match_ratio(common, source, target)
+              end
+
+              def surface_match_ratio(common_keys, source, target)
+                return 0.0 if common_keys.empty?
+
+                matches = common_keys.count do |key|
+                  sym     = key.to_sym
+                  src_val = source.fetch(sym) { source[key] }
+                  tgt_val = target.fetch(sym) { target[key] }
+                  src_val == tgt_val && !src_val.nil?
+                end
+                matches.to_f / common_keys.size
+              end
+
+              def coverage_ratio(source_knowledge, transferred)
+                return 0.0 if source_knowledge.empty?
+
+                transferred.size.to_f / source_knowledge.size
+              end
+
+              def state_counts
+                @analogies.values.each_with_object(Hash.new(0)) do |analogy, counts|
+                  counts[analogy.state] += 1
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/analogical/helpers/constants.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+          module Helpers
+            module Constants
+              MAX_ANALOGIES  = 200
+              MAX_DOMAINS    = 50
+              MAX_HISTORY    = 300
+
+              SIMILARITY_THRESHOLD = 0.4
+              STRUCTURAL_WEIGHT    = 0.7
+              SURFACE_WEIGHT       = 0.3
+
+              DEFAULT_STRENGTH    = 0.5
+              STRENGTH_FLOOR      = 0.05
+              STRENGTH_CEILING    = 0.95
+
+              REINFORCEMENT_RATE = 0.1
+              DECAY_RATE         = 0.01
+
+              MAPPING_TYPES   = %i[attribute relational system].freeze
+              ANALOGY_STATES  = %i[candidate validated productive stale].freeze
+              STATE_THRESHOLDS = {
+                productive: 0.75,
+                validated:  0.5,
+                candidate:  0.25
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end