lex-agentic-inference 0.1.0

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+          module Helpers
+            class StructureMap
+              include Constants
+
+              attr_reader :id, :source_domain, :target_domain, :mappings, :mapping_type, :times_used, :created_at,
+                          :last_used_at, :strength
+
+              def initialize(source_domain:, target_domain:, mappings:, mapping_type:, strength: nil)
+                @id            = SecureRandom.uuid
+                @source_domain = source_domain
+                @target_domain = target_domain
+                @mappings      = mappings
+                @mapping_type  = mapping_type
+                @strength      = (strength || Constants::DEFAULT_STRENGTH).clamp(
+                  Constants::STRENGTH_FLOOR,
+                  Constants::STRENGTH_CEILING
+                )
+                @times_used    = 0
+                @created_at    = Time.now.utc
+                @last_used_at  = Time.now.utc
+              end
+
+              def structural_score
+                return 0.0 if mappings.empty?
+
+                relational_count = mappings.count { |_src, tgt| tgt.is_a?(Hash) && tgt[:type] == :relational }
+                relational_count.to_f / mappings.size
+              end
+
+              def surface_score
+                return 0.0 if mappings.empty?
+
+                attribute_count = mappings.count { |_src, tgt| !(tgt.is_a?(Hash) && tgt[:type] == :relational) }
+                attribute_count.to_f / mappings.size
+              end
+
+              def similarity_score
+                (Constants::STRUCTURAL_WEIGHT * structural_score) +
+                  (Constants::SURFACE_WEIGHT * surface_score)
+              end
+
+              def use!
+                @times_used   += 1
+                @last_used_at  = Time.now.utc
+                reinforce(amount: Constants::REINFORCEMENT_RATE * 0.5)
+                self
+              end
+
+              def reinforce(amount: Constants::REINFORCEMENT_RATE)
+                @strength = (@strength + amount).clamp(Constants::STRENGTH_FLOOR, Constants::STRENGTH_CEILING)
+                self
+              end
+
+              def weaken(amount: Constants::REINFORCEMENT_RATE)
+                @strength = (@strength - amount).clamp(Constants::STRENGTH_FLOOR, Constants::STRENGTH_CEILING)
+                self
+              end
+
+              def decay
+                @strength = (@strength - Constants::DECAY_RATE).clamp(Constants::STRENGTH_FLOOR, Constants::STRENGTH_CEILING)
+                self
+              end
+
+              def state
+                thresholds = Constants::STATE_THRESHOLDS
+                if @strength >= thresholds[:productive]
+                  :productive
+                elsif @strength >= thresholds[:validated]
+                  :validated
+                elsif @strength >= thresholds[:candidate]
+                  :candidate
+                else
+                  :stale
+                end
+              end
+
+              def productive?
+                state == :productive
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  source_domain:    @source_domain,
+                  target_domain:    @target_domain,
+                  mappings:         @mappings,
+                  mapping_type:     @mapping_type,
+                  strength:         @strength,
+                  structural_score: structural_score,
+                  surface_score:    surface_score,
+                  similarity_score: similarity_score,
+                  state:            state,
+                  times_used:       @times_used,
+                  created_at:       @created_at,
+                  last_used_at:     @last_used_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/analogical/runners/analogical_reasoning.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+          module Runners
+            module AnalogicalReasoning
+              def create_analogy(source_domain:, target_domain:, mappings:, mapping_type: :relational, strength: nil, **)
+                unless Helpers::Constants::MAPPING_TYPES.include?(mapping_type)
+                  return { success: false, error: :invalid_mapping_type,
+                           valid_types: Helpers::Constants::MAPPING_TYPES }
+                end
+
+                analogy = engine.create_analogy(
+                  source_domain: source_domain,
+                  target_domain: target_domain,
+                  mappings:      mappings,
+                  mapping_type:  mapping_type,
+                  strength:      strength
+                )
+
+                Legion::Logging.debug "[analogical_reasoning] created analogy id=#{analogy.id[0..7]} " \
+                                      "#{source_domain}->#{target_domain} type=#{mapping_type}"
+
+                { success: true, analogy_id: analogy.id, source_domain: source_domain,
+                  target_domain: target_domain, mapping_type: mapping_type,
+                  strength: analogy.strength, state: analogy.state }
+              end
+
+              def find_analogies(domain:, **)
+                analogies = engine.find_analogies(domain: domain)
+                Legion::Logging.debug "[analogical_reasoning] find domain=#{domain} count=#{analogies.size}"
+                { success: true, domain: domain, analogies: analogies.map(&:to_h), count: analogies.size }
+              end
+
+              def apply_analogy(analogy_id:, source_element:, **)
+                result = engine.apply_analogy(analogy_id: analogy_id, source_element: source_element)
+
+                Legion::Logging.debug "[analogical_reasoning] apply id=#{analogy_id[0..7]} " \
+                                      "element=#{source_element} mapped=#{result[:mapped]}"
+
+                { success: true }.merge(result)
+              end
+
+              def evaluate_similarity(source:, target:, **)
+                score = engine.evaluate_similarity(source: source, target: target)
+                above_threshold = score >= Helpers::Constants::SIMILARITY_THRESHOLD
+
+                Legion::Logging.debug "[analogical_reasoning] similarity=#{score.round(3)} " \
+                                      "above_threshold=#{above_threshold}"
+
+                { success: true, similarity_score: score, above_threshold: above_threshold,
+                  threshold: Helpers::Constants::SIMILARITY_THRESHOLD }
+              end
+
+              def cross_domain_transfer(analogy_id:, source_knowledge:, **)
+                result = engine.cross_domain_transfer(analogy_id: analogy_id, source_knowledge: source_knowledge)
+
+                Legion::Logging.debug "[analogical_reasoning] transfer id=#{analogy_id[0..7]} " \
+                                      "transferred=#{result[:transferred]} coverage=#{result[:coverage]&.round(2)}"
+
+                { success: true }.merge(result)
+              end
+
+              def reinforce_analogy(analogy_id:, success:, **)
+                result = engine.reinforce_analogy(analogy_id: analogy_id, success: success)
+
+                Legion::Logging.debug "[analogical_reasoning] reinforce id=#{analogy_id[0..7]} " \
+                                      "success=#{success} new_state=#{result[:state]}"
+
+                { success: true }.merge(result)
+              end
+
+              def productive_analogies(**)
+                analogies = engine.productive_analogies
+                Legion::Logging.debug "[analogical_reasoning] productive count=#{analogies.size}"
+                { success: true, analogies: analogies.map(&:to_h), count: analogies.size }
+              end
+
+              def update_analogical_reasoning(**)
+                engine.decay_all
+                pruned = engine.prune_stale
+                Legion::Logging.debug "[analogical_reasoning] decay+prune pruned=#{pruned}"
+                { success: true, pruned: pruned }
+              end
+
+              def analogical_reasoning_stats(**)
+                stats = engine.to_h
+                Legion::Logging.debug "[analogical_reasoning] stats total=#{stats[:total_analogies]}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::AnalogyEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/analogical/version'
+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'
+require 'legion/extensions/agentic/inference/analogical/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Analogical
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'runners/argument_mapping'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+          class Client
+            include Runners::ArgumentMapping
+
+            def initialize(**); end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/argument_mapping/helpers/argument.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+          module Helpers
+            class Argument
+              include Constants
+
+              attr_reader :id, :claim, :grounds, :warrant, :backing,
+                          :qualifier, :rebuttals, :created_at, :domain
+
+              def initialize(id:, claim:, domain: :general, warrant: nil, qualifier: :presumably)
+                @id         = id
+                @claim      = claim
+                @domain     = domain
+                @warrant    = warrant
+                @qualifier  = qualifier
+                @grounds    = []
+                @backing    = []
+                @rebuttals  = []
+                @created_at = Time.now.utc
+              end
+
+              def add_ground(ground:)
+                @grounds << ground
+              end
+
+              def add_backing(backing:)
+                @backing << backing
+              end
+
+              def add_rebuttal(content:, impact: 0.5)
+                @rebuttals << { content: content, impact: impact.clamp(0.0, 1.0) }
+              end
+
+              def strength
+                raw = (ground_score * GROUND_WEIGHT) +
+                      (warrant_score * WARRANT_WEIGHT) +
+                      (backing_score * BACKING_WEIGHT) -
+                      (rebuttal_score * REBUTTAL_PENALTY)
+                raw.clamp(0.0, 1.0)
+              end
+
+              def strength_label
+                ARGUMENT_STRENGTHS.find { |range, _| range.cover?(strength) }&.last
+              end
+
+              def sound?
+                strength >= 0.6 && !@warrant.nil? && !@grounds.empty?
+              end
+
+              def rebutted?
+                @rebuttals.any? { |r| r[:impact] > 0.5 }
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  claim:          @claim,
+                  domain:         @domain,
+                  grounds:        @grounds,
+                  warrant:        @warrant,
+                  backing:        @backing,
+                  qualifier:      @qualifier,
+                  rebuttals:      @rebuttals,
+                  strength:       strength,
+                  strength_label: strength_label,
+                  sound:          sound?,
+                  rebutted:       rebutted?,
+                  created_at:     @created_at
+                }
+              end
+
+              private
+
+              def ground_score
+                [@grounds.size / 3.0, 1.0].min
+              end
+
+              def warrant_score
+                @warrant.nil? ? 0.0 : 0.8
+              end
+
+              def backing_score
+                [@backing.size / 2.0, 1.0].min
+              end
+
+              def rebuttal_score
+                return 0.0 if @rebuttals.empty?
+
+                @rebuttals.sum { |r| r[:impact] } / @rebuttals.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/argument_mapping/helpers/argument_engine.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+          module Helpers
+            class ArgumentEngine
+              include Constants
+
+              attr_reader :arguments, :history
+
+              def initialize
+                @arguments = {}
+                @history   = []
+              end
+
+              def create_argument(claim:, domain: :general, warrant: nil, qualifier: :presumably)
+                return { success: false, reason: :max_arguments_reached } if @arguments.size >= MAX_ARGUMENTS
+
+                id       = generate_id('arg')
+                argument = Argument.new(id: id, claim: claim, domain: domain,
+                                        warrant: warrant, qualifier: qualifier)
+                @arguments[id] = argument
+                add_history(type: :created, argument_id: id, claim: claim, domain: domain)
+                { success: true, argument: argument.to_h }
+              end
+
+              def add_ground(argument_id:, ground:)
+                argument = @arguments[argument_id]
+                return { success: false, reason: :not_found } unless argument
+
+                argument.add_ground(ground: ground)
+                add_history(type: :ground_added, argument_id: argument_id)
+                { success: true, argument: argument.to_h }
+              end
+
+              def add_backing(argument_id:, backing:)
+                argument = @arguments[argument_id]
+                return { success: false, reason: :not_found } unless argument
+
+                argument.add_backing(backing: backing)
+                add_history(type: :backing_added, argument_id: argument_id)
+                { success: true, argument: argument.to_h }
+              end
+
+              def add_rebuttal(argument_id:, content:, impact: 0.5)
+                argument = @arguments[argument_id]
+                return { success: false, reason: :not_found } unless argument
+
+                argument.add_rebuttal(content: content, impact: impact)
+                add_history(type: :rebuttal_added, argument_id: argument_id, impact: impact)
+                { success: true, argument: argument.to_h }
+              end
+
+              def assess_argument(argument_id:)
+                argument = @arguments[argument_id]
+                return { success: false, reason: :not_found } unless argument
+
+                {
+                  success:        true,
+                  argument_id:    argument_id,
+                  claim:          argument.claim,
+                  domain:         argument.domain,
+                  strength:       argument.strength,
+                  strength_label: argument.strength_label,
+                  sound:          argument.sound?,
+                  rebutted:       argument.rebutted?,
+                  ground_count:   argument.grounds.size,
+                  backing_count:  argument.backing.size,
+                  rebuttal_count: argument.rebuttals.size
+                }
+              end
+
+              def sound_arguments
+                @arguments.values.select(&:sound?)
+              end
+
+              def rebutted_arguments
+                @arguments.values.select(&:rebutted?)
+              end
+
+              def arguments_by_domain(domain:)
+                @arguments.values.select { |a| a.domain == domain }
+              end
+
+              def strongest_arguments(limit: 5)
+                @arguments.values.sort_by { |a| -a.strength }.first(limit)
+              end
+
+              def weakest_arguments(limit: 5)
+                @arguments.values.sort_by(&:strength).first(limit)
+              end
+
+              def decay_all
+                @arguments.each_value do |argument|
+                  next unless argument.instance_variable_defined?(:@base_strength)
+
+                  current = argument.instance_variable_get(:@base_strength)
+                  argument.instance_variable_set(:@base_strength, [current - DECAY_RATE, 0.0].max)
+                end
+                @arguments.size
+              end
+
+              def to_h
+                {
+                  total_arguments:    @arguments.size,
+                  sound_arguments:    sound_arguments.size,
+                  rebutted_arguments: rebutted_arguments.size,
+                  history_entries:    @history.size
+                }
+              end
+
+              private
+
+              def add_history(entry)
+                @history << entry.merge(timestamp: Time.now.utc)
+                @history.shift if @history.size > MAX_HISTORY
+              end
+
+              def generate_id(prefix)
+                "#{prefix}_#{Time.now.utc.to_f}_#{rand(10_000)}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+          module Helpers
+            module Constants
+              ARGUMENT_STRENGTHS = {
+                (0.8..)     => :compelling,
+                (0.6...0.8) => :strong,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :weak,
+                (..0.2)     => :fallacious
+              }.freeze
+
+              QUALIFIER_TYPES = %i[certainly presumably probably possibly apparently].freeze
+
+              REBUTTAL_IMPACT_LABELS = {
+                (0.8..)     => :devastating,
+                (0.6...0.8) => :significant,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :minor,
+                (..0.2)     => :negligible
+              }.freeze
+
+              MAX_ARGUMENTS = 200
+              MAX_HISTORY   = 500
+
+              DEFAULT_STRENGTH  = 0.5
+              GROUND_WEIGHT     = 0.3
+              WARRANT_WEIGHT    = 0.3
+              BACKING_WEIGHT    = 0.2
+              REBUTTAL_PENALTY  = 0.2
+
+              DECAY_RATE = 0.02
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+          module Runners
+            module ArgumentMapping
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_argument(claim:, domain: :general, warrant: nil, qualifier: :presumably, **)
+                Legion::Logging.info "[argument_mapping] create_argument: claim=#{claim} domain=#{domain}"
+                engine.create_argument(claim: claim, domain: domain, warrant: warrant, qualifier: qualifier)
+              end
+
+              def add_argument_ground(argument_id:, ground:, **)
+                Legion::Logging.debug "[argument_mapping] add_ground: id=#{argument_id}"
+                engine.add_ground(argument_id: argument_id, ground: ground)
+              end
+
+              def add_argument_backing(argument_id:, backing:, **)
+                Legion::Logging.debug "[argument_mapping] add_backing: id=#{argument_id}"
+                engine.add_backing(argument_id: argument_id, backing: backing)
+              end
+
+              def add_argument_rebuttal(argument_id:, content:, impact: 0.5, **)
+                Legion::Logging.info "[argument_mapping] add_rebuttal: id=#{argument_id} impact=#{impact}"
+                engine.add_rebuttal(argument_id: argument_id, content: content, impact: impact)
+              end
+
+              def assess_argument_strength(argument_id:, **)
+                Legion::Logging.debug "[argument_mapping] assess: id=#{argument_id}"
+                engine.assess_argument(argument_id: argument_id)
+              end
+
+              def sound_arguments_report(**)
+                Legion::Logging.debug '[argument_mapping] sound_arguments_report'
+                arguments = engine.sound_arguments
+                { success: true, arguments: arguments.map(&:to_h), count: arguments.size }
+              end
+
+              def rebutted_arguments_report(**)
+                Legion::Logging.debug '[argument_mapping] rebutted_arguments_report'
+                arguments = engine.rebutted_arguments
+                { success: true, arguments: arguments.map(&:to_h), count: arguments.size }
+              end
+
+              def strongest_arguments_report(limit: 5, **)
+                Legion::Logging.debug "[argument_mapping] strongest_arguments: limit=#{limit}"
+                arguments = engine.strongest_arguments(limit: limit)
+                { success: true, arguments: arguments.map(&:to_h), count: arguments.size }
+              end
+
+              def update_argument_mapping(**)
+                Legion::Logging.debug '[argument_mapping] decay_all'
+                decayed = engine.decay_all
+                { success: true, arguments_processed: decayed }
+              end
+
+              def argument_mapping_stats(**)
+                Legion::Logging.debug '[argument_mapping] stats'
+                { success: true }.merge(engine.to_h)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::ArgumentEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'argument_mapping/version'
+require_relative 'argument_mapping/helpers/constants'
+require_relative 'argument_mapping/helpers/argument'
+require_relative 'argument_mapping/helpers/argument_engine'
+require_relative 'argument_mapping/runners/argument_mapping'
+require_relative 'argument_mapping/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module ArgumentMapping
+        end
+      end
+    end
+  end
+end