lex-moral-reasoning 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c500a79fb70b329c9bf3838fefa3f63b158f9c8b71c63d14284350f8003b4aa3
+  data.tar.gz: 5a09f5ff1d011912e60cbf414e3201f10efdaea0bc0103df2ebdf30439a903ef
+SHA512:
+  metadata.gz: 7dda3845893fe4eb6d8ad7d34e66040cb6a273072fd9f1ca28408218ebe3dcfc028dc6781f1686b06389abb2cc5f0ce069ccda9bb2c2e29e05f03219c219f14f
+  data.tar.gz: 0ba52f923c31347ce52ce8f65c9cd55f49fcf948a625a51eed49a5280aedcf28167fc6ea3947d630f1ef83e0d231ed925064d83fcb48d7f77c1e666470ae86db

data/lib/legion/extensions/moral_reasoning/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'runners/moral_reasoning'
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      class Client
+        include Runners::MoralReasoning
+
+        def initialize(**); end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/helpers/constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Helpers
+        module Constants
+          MAX_DILEMMAS = 100
+          MAX_PRINCIPLES = 50
+          MAX_HISTORY = 300
+
+          DEFAULT_WEIGHT    = 0.5
+          WEIGHT_FLOOR      = 0.1
+          WEIGHT_CEILING    = 1.0
+          REINFORCEMENT_RATE = 0.1
+          DECAY_RATE        = 0.01
+
+          # Haidt's 6 Moral Foundations
+          MORAL_FOUNDATIONS = %i[care fairness loyalty authority sanctity liberty].freeze
+
+          # Kohlberg's 6 Stages (grouped into 3 levels)
+          KOHLBERG_STAGES = %i[obedience self_interest conformity law_and_order social_contract universal_ethics].freeze
+
+          KOHLBERG_LEVELS = {
+            preconventional:  %i[obedience self_interest],
+            conventional:     %i[conformity law_and_order],
+            postconventional: %i[social_contract universal_ethics]
+          }.freeze
+
+          # Ethical frameworks for dilemma resolution
+          ETHICAL_FRAMEWORKS = %i[utilitarian deontological virtue care justice rights].freeze
+
+          # Dilemma severity labels keyed by endless/beginless ranges
+          SEVERITY_LABELS = {
+            (0.8..)     => :critical,
+            (0.6...0.8) => :serious,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :minor,
+            (..0.2)     => :trivial
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/helpers/dilemma.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Helpers
+        class Dilemma
+          include Constants
+
+          attr_reader :id, :description, :domain, :severity, :options,
+                      :chosen_option, :reasoning, :framework_used,
+                      :created_at, :resolved_at
+
+          def initialize(id:, description:, options:, domain: :general, severity: 0.5)
+            @id           = id
+            @description  = description
+            @domain       = domain
+            @severity     = severity.clamp(0.0, 1.0)
+            @options      = options
+            @chosen_option = nil
+            @reasoning = nil
+            @framework_used = nil
+            @resolved     = false
+            @created_at   = Time.now.utc
+            @resolved_at  = nil
+          end
+
+          def severity_label
+            SEVERITY_LABELS.find { |range, _| range.cover?(@severity) }&.last
+          end
+
+          def resolve(option_id:, reasoning:, framework:)
+            @chosen_option  = option_id
+            @reasoning      = reasoning
+            @framework_used = framework
+            @resolved       = true
+            @resolved_at    = Time.now.utc
+          end
+
+          def resolved?
+            @resolved
+          end
+
+          def to_h
+            {
+              id:             @id,
+              description:    @description,
+              domain:         @domain,
+              severity:       @severity,
+              severity_label: severity_label,
+              options:        @options,
+              chosen_option:  @chosen_option,
+              reasoning:      @reasoning,
+              framework_used: @framework_used,
+              resolved:       @resolved,
+              created_at:     @created_at,
+              resolved_at:    @resolved_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/helpers/llm_enhancer.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Helpers
+        module LlmEnhancer
+          SYSTEM_PROMPT = <<~PROMPT
+            You are the moral reasoning engine for an autonomous AI agent built on LegionIO.
+            You apply ethical frameworks to evaluate actions and resolve dilemmas.
+            Be rigorous, analytical, and fair. Consider multiple perspectives.
+            Output structured reasoning, not opinions. Be concise.
+          PROMPT
+
+          module_function
+
+          def available?
+            !!(defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?)
+          rescue StandardError
+            false
+          end
+
+          def evaluate_action(action:, description:, foundations:)
+            response = llm_ask(build_evaluate_action_prompt(action: action, description: description,
+                                                            foundations: foundations))
+            parse_evaluate_action_response(response)
+          rescue StandardError => e
+            Legion::Logging.warn "[moral_reasoning:llm] evaluate_action failed: #{e.message}"
+            nil
+          end
+
+          def resolve_dilemma(dilemma_description:, options:, framework:)
+            response = llm_ask(build_resolve_dilemma_prompt(dilemma_description: dilemma_description,
+                                                            options: options, framework: framework))
+            parse_resolve_dilemma_response(response)
+          rescue StandardError => e
+            Legion::Logging.warn "[moral_reasoning:llm] resolve_dilemma failed: #{e.message}"
+            nil
+          end
+
+          def llm_ask(prompt)
+            chat = Legion::LLM.chat
+            chat.with_instructions(SYSTEM_PROMPT)
+            chat.ask(prompt)
+          end
+          private_class_method :llm_ask
+
+          def build_evaluate_action_prompt(action:, description:, foundations:)
+            foundation_lines = foundations.map { |name, strength| "  #{name}: #{strength.round(3)}" }.join("\n")
+            desc = description.to_s.empty? ? 'no description' : description
+            <<~PROMPT
+              Evaluate this action using moral foundations theory.
+
+              ACTION: #{action}
+              DESCRIPTION: #{desc}
+
+              Current foundation strengths:
+              #{foundation_lines}
+
+              For each foundation, estimate the moral impact of this action (-1.0 to 1.0).
+              Negative = harmful to that foundation, Positive = reinforces that foundation.
+
+              Format EXACTLY as:
+              REASONING: <1-2 paragraph analysis>
+              IMPACT: care=<float> | fairness=<float> | loyalty=<float> | authority=<float> | sanctity=<float> | liberty=<float>
+            PROMPT
+          end
+          private_class_method :build_evaluate_action_prompt
+
+          def parse_evaluate_action_response(response)
+            return nil unless response&.content
+
+            text            = response.content
+            reasoning_match = text.match(/REASONING:\s*(.+?)(?=\nIMPACT:|\z)/im)
+            impact_match    = text.match(/IMPACT:\s*(.+)/i)
+            return nil unless reasoning_match && impact_match
+
+            foundation_impacts = parse_impact_string(impact_match.captures.first.strip)
+            return nil if foundation_impacts.empty?
+
+            { reasoning: reasoning_match.captures.first.strip, foundation_impacts: foundation_impacts }
+          end
+          private_class_method :parse_evaluate_action_response
+
+          def parse_impact_string(impact_str)
+            impact_str.split('|').each_with_object({}) do |pair, hash|
+              key, val = pair.strip.split('=')
+              hash[key.strip.to_sym] = val.strip.to_f.clamp(-1.0, 1.0) if key && val
+            end
+          end
+          private_class_method :parse_impact_string
+
+          def build_resolve_dilemma_prompt(dilemma_description:, options:, framework:)
+            option_lines = options.map do |opt|
+              foundations_str = opt.fetch(:foundations, []).join(', ')
+              "- #{opt[:id] || opt[:action]}: #{opt[:description]} (foundations: #{foundations_str})"
+            end.join("\n")
+            <<~PROMPT
+              Resolve this moral dilemma using the #{framework} ethical framework.
+
+              DILEMMA: #{dilemma_description}
+
+              OPTIONS:
+              #{option_lines}
+
+              Apply #{framework} reasoning to select the best option.
+
+              Format EXACTLY as:
+              CHOSEN: <option label>
+              CONFIDENCE: <0.0-1.0>
+              REASONING: <1-2 paragraph justification using the specified framework>
+            PROMPT
+          end
+          private_class_method :build_resolve_dilemma_prompt
+
+          def parse_resolve_dilemma_response(response)
+            return nil unless response&.content
+
+            text             = response.content
+            chosen_match     = text.match(/CHOSEN:\s*(.+)/i)
+            confidence_match = text.match(/CONFIDENCE:\s*([\d.]+)/i)
+            reasoning_match  = text.match(/REASONING:\s*(.+)/im)
+            return nil unless chosen_match && confidence_match && reasoning_match
+
+            {
+              chosen_option: chosen_match.captures.first.strip,
+              confidence:    confidence_match.captures.first.strip.to_f.clamp(0.0, 1.0),
+              reasoning:     reasoning_match.captures.first.strip
+            }
+          end
+          private_class_method :parse_resolve_dilemma_response
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/helpers/moral_engine.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Helpers
+        module FrameworkEvaluators
+          CARE_FOUNDATIONS     = %i[care fairness sanctity].freeze
+          DUTY_FOUNDATIONS     = %i[authority loyalty].freeze
+          JUSTICE_FOUNDATIONS  = %i[fairness liberty].freeze
+          RIGHTS_FOUNDATIONS   = %i[liberty fairness authority].freeze
+
+          private
+
+          def evaluate_by_utility(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).sum { |fid| @foundations[fid]&.weight.to_f }
+            end
+          end
+
+          def evaluate_by_duty(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).count { |fid| DUTY_FOUNDATIONS.include?(fid) }.to_f
+            end
+          end
+
+          def evaluate_by_virtue(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).count { |fid| CARE_FOUNDATIONS.include?(fid) }.to_f
+            end
+          end
+
+          def evaluate_by_care(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).count { |fid| fid == :care }.to_f
+            end
+          end
+
+          def evaluate_by_justice(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).count { |fid| JUSTICE_FOUNDATIONS.include?(fid) }.to_f
+            end
+          end
+
+          def evaluate_by_rights(dilemma)
+            rank_options(dilemma) do |option|
+              option.fetch(:foundations, []).count { |fid| RIGHTS_FOUNDATIONS.include?(fid) }.to_f
+            end
+          end
+
+          def rank_options(dilemma)
+            scored = dilemma.options.map do |option|
+              score = yield(option)
+              { id: option[:id], description: option[:description], score: score }
+            end
+            scored.sort_by { |r| -r[:score] }
+          end
+        end
+
+        class MoralEngine
+          include Constants
+          include FrameworkEvaluators
+
+          KOHLBERG_STAGE_DESCRIPTIONS = {
+            obedience:        'Avoid punishment; obey authority unconditionally',
+            self_interest:    'Act for direct reward; reciprocal exchange',
+            conformity:       'Conform to social norms; be a good person',
+            law_and_order:    'Follow rules, laws, and authority to maintain social order',
+            social_contract:  'Uphold democratic principles; greatest good for greatest number',
+            universal_ethics: 'Follow self-chosen universal ethical principles'
+          }.freeze
+
+          FRAMEWORK_STRATEGIES = {
+            utilitarian:   :evaluate_by_utility,
+            deontological: :evaluate_by_duty,
+            virtue:        :evaluate_by_virtue,
+            care:          :evaluate_by_care,
+            justice:       :evaluate_by_justice,
+            rights:        :evaluate_by_rights
+          }.freeze
+
+          attr_reader :stage, :dilemmas, :principles, :history
+
+          def initialize
+            @foundations = MORAL_FOUNDATIONS.to_h { |f| [f, MoralFoundation.new(id: f)] }
+            @principles  = []
+            @dilemmas    = {}
+            @stage       = :social_contract
+            @history     = []
+          end
+
+          def evaluate_action(action:, affected_foundations:, domain: :general)
+            score = score_foundations(affected_foundations)
+            normalized = affected_foundations.empty? ? 0.0 : score / affected_foundations.size
+            add_history(type: :evaluation, action: action, domain: domain, score: normalized)
+            { action: action, domain: domain, score: normalized, foundations: affected_foundations }
+          end
+
+          def pose_dilemma(description:, options:, domain: :general, severity: 0.5)
+            return { success: false, reason: :max_dilemmas_reached } if @dilemmas.size >= MAX_DILEMMAS
+
+            id = generate_id('dilemma')
+            dilemma = Dilemma.new(id: id, description: description, options: options,
+                                  domain: domain, severity: severity)
+            @dilemmas[id] = dilemma
+            { success: true, dilemma: dilemma.to_h }
+          end
+
+          def resolve_dilemma(dilemma_id:, option_id:, reasoning:, framework:)
+            dilemma = @dilemmas[dilemma_id]
+            return { success: false, reason: :not_found } unless dilemma
+            return { success: false, reason: :already_resolved } if dilemma.resolved?
+
+            chosen = dilemma.options.find { |o| o[:id] == option_id }
+            return { success: false, reason: :invalid_option } unless chosen
+
+            dilemma.resolve(option_id: option_id, reasoning: reasoning, framework: framework)
+            reinforce_chosen_foundations(chosen)
+            weaken_unchosen_foundations(dilemma.options, option_id)
+            add_history(type: :resolution, dilemma_id: dilemma_id, option_id: option_id,
+                        framework: framework, severity: dilemma.severity)
+            { success: true, dilemma: dilemma.to_h }
+          end
+
+          def apply_framework(dilemma_id:, framework:)
+            dilemma = @dilemmas[dilemma_id]
+            return { success: false, reason: :not_found } unless dilemma
+            return { success: false, reason: :unknown_framework } unless ETHICAL_FRAMEWORKS.include?(framework)
+
+            strategy  = FRAMEWORK_STRATEGIES.fetch(framework)
+            rankings  = send(strategy, dilemma)
+            { success: true, dilemma_id: dilemma_id, framework: framework, rankings: rankings }
+          end
+
+          def add_principle(name:, description:, foundation:, weight: DEFAULT_WEIGHT)
+            return { success: false, reason: :max_principles_reached } if @principles.size >= MAX_PRINCIPLES
+            return { success: false, reason: :unknown_foundation } unless MORAL_FOUNDATIONS.include?(foundation)
+
+            principle = {
+              id:          generate_id('principle'),
+              name:        name,
+              description: description,
+              foundation:  foundation,
+              weight:      weight.clamp(WEIGHT_FLOOR, WEIGHT_CEILING),
+              created_at:  Time.now.utc
+            }
+            @principles << principle
+            { success: true, principle: principle }
+          end
+
+          def moral_development
+            resolved = resolved_dilemmas
+            return { advanced: false, stage: @stage, reason: :insufficient_resolutions } if resolved.size < 3
+
+            avg_severity = resolved.sum(&:severity) / resolved.size.to_f
+            complexity_met = avg_severity >= 0.4 && resolved.size >= 5
+            current_idx = KOHLBERG_STAGES.index(@stage)
+
+            if complexity_met && current_idx < KOHLBERG_STAGES.size - 1
+              @stage = KOHLBERG_STAGES[current_idx + 1]
+              { advanced: true, stage: @stage, previous_stage: KOHLBERG_STAGES[current_idx] }
+            else
+              { advanced: false, stage: @stage, reason: :complexity_threshold_not_met }
+            end
+          end
+
+          def foundation_profile
+            @foundations.transform_values(&:to_h)
+          end
+
+          def stage_info
+            level = KOHLBERG_LEVELS.find { |_, stages| stages.include?(@stage) }&.first
+            { stage: @stage, level: level, description: KOHLBERG_STAGE_DESCRIPTIONS.fetch(@stage, 'Unknown') }
+          end
+
+          def unresolved_dilemmas
+            @dilemmas.values.reject(&:resolved?)
+          end
+
+          def resolved_dilemmas
+            @dilemmas.values.select(&:resolved?)
+          end
+
+          def decay_all
+            @foundations.each_value(&:decay)
+          end
+
+          def to_h
+            {
+              stage:               @stage,
+              total_dilemmas:      @dilemmas.size,
+              resolved_dilemmas:   resolved_dilemmas.size,
+              unresolved_dilemmas: unresolved_dilemmas.size,
+              principles:          @principles.size,
+              history_entries:     @history.size,
+              foundation_profile:  foundation_profile
+            }
+          end
+
+          private
+
+          def score_foundations(affected_foundations)
+            affected_foundations.sum do |fid|
+              foundation = @foundations.fetch(fid, nil)
+              next 0.0 unless foundation
+
+              foundation.weight * foundation.sensitivity
+            end
+          end
+
+          def reinforce_chosen_foundations(chosen_option)
+            chosen_option.fetch(:foundations, []).each do |fid|
+              @foundations[fid]&.reinforce(amount: chosen_option.fetch(:severity, 1.0))
+            end
+          end
+
+          def weaken_unchosen_foundations(options, chosen_id)
+            options.reject { |o| o[:id] == chosen_id }.each do |option|
+              option.fetch(:foundations, []).each { |fid| @foundations[fid]&.weaken(amount: 0.5) }
+            end
+          end
+
+          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(1000)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/helpers/moral_foundation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Helpers
+        class MoralFoundation
+          include Constants
+
+          attr_reader :id, :weight, :sensitivity
+
+          def initialize(id:, weight: DEFAULT_WEIGHT, sensitivity: DEFAULT_WEIGHT)
+            @id          = id
+            @weight      = weight.clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+            @sensitivity = sensitivity.clamp(0.0, 1.0)
+          end
+
+          def reinforce(amount: 1.0)
+            @weight = (@weight + (amount * REINFORCEMENT_RATE)).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+          end
+
+          def weaken(amount: 1.0)
+            @weight = (@weight - (amount * REINFORCEMENT_RATE)).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+          end
+
+          def decay
+            @weight = (@weight - DECAY_RATE).clamp(WEIGHT_FLOOR, WEIGHT_CEILING)
+          end
+
+          def to_h
+            {
+              id:          @id,
+              weight:      @weight,
+              sensitivity: @sensitivity
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/runners/moral_reasoning.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      module Runners
+        module MoralReasoning
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def evaluate_moral_action(action:, affected_foundations:, domain: :general, description: nil, **)
+            Legion::Logging.debug "[moral_reasoning] evaluate_action: action=#{action} domain=#{domain}"
+
+            if Helpers::LlmEnhancer.available?
+              current_foundations = engine.foundation_profile.transform_values { |f| f[:weight] }
+              llm_result = Helpers::LlmEnhancer.evaluate_action(
+                action:      action,
+                description: description.to_s,
+                foundations: current_foundations
+              )
+              if llm_result
+                Legion::Logging.debug "[moral_reasoning] using LLM evaluation for action=#{action}"
+                result = engine.evaluate_action(
+                  action:               action,
+                  affected_foundations: affected_foundations,
+                  domain:               domain
+                )
+                return { success: true, source: :llm, reasoning: llm_result[:reasoning],
+                         foundation_impacts: llm_result[:foundation_impacts] }.merge(result)
+              end
+            end
+
+            result = engine.evaluate_action(action: action, affected_foundations: affected_foundations, domain: domain)
+            { success: true, source: :mechanical }.merge(result)
+          end
+
+          def pose_moral_dilemma(description:, options:, domain: :general, severity: 0.5, **)
+            Legion::Logging.info "[moral_reasoning] pose_dilemma: domain=#{domain} severity=#{severity}"
+            engine.pose_dilemma(description: description, options: options, domain: domain, severity: severity)
+          end
+
+          def resolve_moral_dilemma(dilemma_id:, option_id:, reasoning:, framework:, **)
+            Legion::Logging.info "[moral_reasoning] resolve_dilemma: id=#{dilemma_id} framework=#{framework}"
+
+            if Helpers::LlmEnhancer.available?
+              dilemma = engine.dilemmas[dilemma_id]
+              if dilemma && !dilemma.resolved?
+                llm_result = Helpers::LlmEnhancer.resolve_dilemma(
+                  dilemma_description: dilemma.description,
+                  options:             dilemma.options,
+                  framework:           framework
+                )
+                if llm_result
+                  Legion::Logging.debug "[moral_reasoning] using LLM resolution for dilemma=#{dilemma_id}"
+                  result = engine.resolve_dilemma(
+                    dilemma_id: dilemma_id,
+                    option_id:  option_id,
+                    reasoning:  llm_result[:reasoning],
+                    framework:  framework
+                  )
+                  return result.merge(source: :llm, llm_chosen: llm_result[:chosen_option],
+                                      llm_confidence: llm_result[:confidence])
+                end
+              end
+            end
+
+            engine.resolve_dilemma(dilemma_id: dilemma_id, option_id: option_id,
+                                   reasoning: reasoning, framework: framework)
+          end
+
+          def apply_ethical_framework(dilemma_id:, framework:, **)
+            Legion::Logging.debug "[moral_reasoning] apply_framework: id=#{dilemma_id} framework=#{framework}"
+            engine.apply_framework(dilemma_id: dilemma_id, framework: framework)
+          end
+
+          def add_moral_principle(name:, description:, foundation:, weight: Helpers::Constants::DEFAULT_WEIGHT, **)
+            Legion::Logging.info "[moral_reasoning] add_principle: name=#{name} foundation=#{foundation}"
+            engine.add_principle(name: name, description: description, foundation: foundation, weight: weight)
+          end
+
+          def check_moral_development(**)
+            Legion::Logging.debug '[moral_reasoning] check_moral_development'
+            result = engine.moral_development
+            { success: true }.merge(result)
+          end
+
+          def moral_foundation_profile(**)
+            Legion::Logging.debug '[moral_reasoning] foundation_profile'
+            { success: true, foundations: engine.foundation_profile }
+          end
+
+          def moral_stage_info(**)
+            Legion::Logging.debug '[moral_reasoning] stage_info'
+            { success: true }.merge(engine.stage_info)
+          end
+
+          def update_moral_reasoning(**)
+            Legion::Logging.debug '[moral_reasoning] decay_all'
+            engine.decay_all
+            { success: true, foundations: engine.foundation_profile }
+          end
+
+          def moral_reasoning_stats(**)
+            Legion::Logging.debug '[moral_reasoning] stats'
+            { success: true }.merge(engine.to_h)
+          end
+
+          private
+
+          def engine
+            @engine ||= Helpers::MoralEngine.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      VERSION = '0.1.1'
+    end
+  end
+end

data/lib/legion/extensions/moral_reasoning.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'moral_reasoning/version'
+require_relative 'moral_reasoning/helpers/constants'
+require_relative 'moral_reasoning/helpers/moral_foundation'
+require_relative 'moral_reasoning/helpers/dilemma'
+require_relative 'moral_reasoning/helpers/moral_engine'
+require_relative 'moral_reasoning/helpers/llm_enhancer'
+require_relative 'moral_reasoning/runners/moral_reasoning'
+require_relative 'moral_reasoning/client'
+
+module Legion
+  module Extensions
+    module MoralReasoning
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-moral-reasoning
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Moral reasoning for LegionIO — Kohlberg stages, Haidt moral foundations,
+  ethical framework evaluation, and dilemma resolution
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/moral_reasoning.rb
+- lib/legion/extensions/moral_reasoning/client.rb
+- lib/legion/extensions/moral_reasoning/helpers/constants.rb
+- lib/legion/extensions/moral_reasoning/helpers/dilemma.rb
+- lib/legion/extensions/moral_reasoning/helpers/llm_enhancer.rb
+- lib/legion/extensions/moral_reasoning/helpers/moral_engine.rb
+- lib/legion/extensions/moral_reasoning/helpers/moral_foundation.rb
+- lib/legion/extensions/moral_reasoning/runners/moral_reasoning.rb
+- lib/legion/extensions/moral_reasoning/version.rb
+homepage: https://github.com/LegionIO/lex-moral-reasoning
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-moral-reasoning
+  source_code_uri: https://github.com/LegionIO/lex-moral-reasoning
+  changelog_uri: https://github.com/LegionIO/lex-moral-reasoning/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LegionIO moral reasoning extension
+test_files: []