superinstance-equipment-consensus-engine 1.0.0

data/lib/equipment/consensus_engine/tripartite_deliberation.rb

@@ -0,0 +1,645 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+
+module SuperInstance
+  module Equipment
+    module ConsensusEngine
+      # TripartiteDeliberation - Pathos/Logos/Ethos 3-agent deliberation
+      #
+      # Implements the classical rhetorical framework for argumentation
+      # through three fundamental modes of persuasion.
+      #
+      # The tripartite framework originates from Aristotle's Rhetoric and provides
+      # a comprehensive approach to argumentation:
+      #
+      # - **Pathos**: Appeals to emotion, intent, and human experience
+      # - **Logos**: Appeals to logic, reason, and rational argument
+      # - **Ethos**: Appeals to ethics, credibility, and moral character
+      #
+      # @example
+      #   deliberation = SuperInstance::Equipment::ConsensusEngine::TripartiteDeliberation.new
+      #
+      #   pathos_analysis = deliberation.analyze(
+      #     :pathos,
+      #     'Should we reduce work hours?',
+      #     'A company is considering a 4-day work week'
+      #   )
+      class TripartiteDeliberation
+        # Creates a new TripartiteDeliberation instance
+        def initialize
+          @perspective_configs = {
+            pathos: { threshold: 0.6, style: :collaborative },
+            logos: { threshold: 0.7, style: :inquisitive },
+            ethos: { threshold: 0.75, style: :adversarial }
+          }
+        end
+
+        # Analyzes a proposition from a specific perspective
+        # @param perspective [Symbol] The perspective to analyze from
+        # @param proposition [String] The proposition to analyze
+        # @param context [String] The context for deliberation
+        # @param previous_opinions [Array<Hash>] Opinions from previous rounds
+        # @return [Hash] The perspective's analysis
+        def analyze(perspective, proposition, context, previous_opinions = [])
+          case perspective
+          when :pathos
+            analyze_from_pathos(proposition, context, previous_opinions)
+          when :logos
+            analyze_from_logos(proposition, context, previous_opinions)
+          when :ethos
+            analyze_from_ethos(proposition, context, previous_opinions)
+          else
+            raise ArgumentError, "Unknown perspective: #{perspective}"
+          end
+        end
+
+        # Sets the configuration for a perspective
+        # @param perspective [Symbol] The perspective to configure
+        # @param config [Hash] Configuration options { threshold: Float, style: Symbol }
+        def set_perspective_config(perspective, config)
+          current = @perspective_configs[perspective]
+          return unless current
+
+          @perspective_configs[perspective] = {
+            threshold: config[:threshold] || current[:threshold],
+            style: config[:style] || current[:style]
+          }
+        end
+
+        # Gets the configuration for a perspective
+        # @param perspective [Symbol] The perspective to get config for
+        # @return [Hash] Configuration { threshold: Float, style: Symbol }
+        def get_perspective_config(perspective)
+          config = @perspective_configs[perspective]
+          raise ArgumentError, "Unknown perspective: #{perspective}" unless config
+          config.dup
+        end
+
+        private
+
+        # Analyzes from the Pathos perspective (emotion/intent)
+        def analyze_from_pathos(proposition, context, previous_opinions)
+          # Extract emotional dimensions
+          characteristics = extract_pathos_characteristics(proposition, context)
+
+          # Consider previous emotional arguments
+          previous_pathos = previous_opinions.find { |op| op[:perspective] == :pathos }
+
+          # Generate emotional analysis
+          verdict = generate_pathos_verdict(proposition, characteristics, previous_pathos)
+          confidence = calculate_pathos_confidence(characteristics, previous_opinions)
+          arguments = generate_pathos_arguments(characteristics)
+          concerns = identify_pathos_concerns(characteristics)
+
+          {
+            perspective: :pathos,
+            verdict: verdict,
+            confidence: confidence,
+            arguments: arguments,
+            concerns: concerns,
+            emotional_tone: characteristics[:primary_emotion],
+            suggestions: generate_pathos_suggestions(characteristics)
+          }
+        end
+
+        # Analyzes from the Logos perspective (logic/reason)
+        def analyze_from_logos(proposition, context, previous_opinions)
+          # Extract logical structure
+          characteristics = extract_logos_characteristics(proposition, context)
+
+          # Consider previous logical arguments
+          previous_logos = previous_opinions.find { |op| op[:perspective] == :logos }
+
+          # Generate logical analysis
+          verdict = generate_logos_verdict(proposition, characteristics, previous_logos)
+          confidence = calculate_logos_confidence(characteristics, previous_opinions)
+          arguments = generate_logos_arguments(characteristics)
+          concerns = identify_logos_concerns(characteristics)
+          logical_validity = assess_logical_validity(characteristics)
+
+          {
+            perspective: :logos,
+            verdict: verdict,
+            confidence: confidence,
+            arguments: arguments,
+            concerns: concerns,
+            logical_validity: logical_validity,
+            suggestions: generate_logos_suggestions(characteristics)
+          }
+        end
+
+        # Analyzes from the Ethos perspective (ethics/truth)
+        def analyze_from_ethos(proposition, context, previous_opinions)
+          # Extract ethical dimensions
+          characteristics = extract_ethos_characteristics(proposition, context)
+
+          # Consider previous ethical arguments
+          previous_ethos = previous_opinions.find { |op| op[:perspective] == :ethos }
+
+          # Generate ethical analysis
+          verdict = generate_ethos_verdict(proposition, characteristics, previous_ethos)
+          confidence = calculate_ethos_confidence(characteristics, previous_opinions)
+          arguments = generate_ethos_arguments(characteristics)
+          concerns = identify_ethos_concerns(characteristics)
+          ethical_alignment = assess_ethical_alignment(characteristics)
+
+          {
+            perspective: :ethos,
+            verdict: verdict,
+            confidence: confidence,
+            arguments: arguments,
+            concerns: concerns,
+            ethical_alignment: ethical_alignment,
+            suggestions: generate_ethos_suggestions(characteristics)
+          }
+        end
+
+        # Extracts pathos characteristics from proposition and context
+        def extract_pathos_characteristics(proposition, context)
+          combined = "#{proposition} #{context}".downcase
+
+          # Detect primary emotion
+          emotions = %w[hope fear joy anger sadness surprise trust anticipation]
+          detected_emotions = emotions.select { |e| combined.include?(e) }
+          primary_emotion = detected_emotions[0] || 'neutral'
+
+          # Calculate emotional intensity based on emotional words
+          emotional_words = %w[urgent critical important essential vital crucial]
+          intensity = emotional_words.sum do |word|
+            combined.include?(word) ? 0.15 : 0
+          end
+          intensity = [intensity + 0.3, 1.0].min
+
+          # Identify stakeholders
+          stakeholders = identify_stakeholders(combined)
+
+          # Identify emotional risks
+          emotional_risks = identify_emotional_risks(combined)
+
+          {
+            primary_emotion: primary_emotion,
+            intensity: intensity,
+            stakeholders: stakeholders,
+            emotional_risks: emotional_risks
+          }
+        end
+
+        # Extracts logos characteristics from proposition and context
+        def extract_logos_characteristics(proposition, context)
+          combined = "#{proposition} #{context}".downcase
+
+          # Determine logical structure
+          logical_structure = :inductive
+          if combined.include?('therefore') || combined.include?('thus') || combined.include?('must')
+            logical_structure = :deductive
+          elsif combined.include?('likely') || combined.include?('probably') || combined.include?('suggests')
+            logical_structure = :abductive
+          elsif combined.include?('like') || combined.include?('similar') || combined.include?('comparable')
+            logical_structure = :analogical
+          end
+
+          # Extract premises
+          premises = extract_premises(combined)
+
+          # Identify assumptions
+          assumptions = identify_assumptions(combined)
+
+          # Identify logical risks
+          logical_risks = identify_logical_risks(combined)
+
+          {
+            logical_structure: logical_structure,
+            premises: premises,
+            assumptions: assumptions,
+            logical_risks: logical_risks
+          }
+        end
+
+        # Extracts ethos characteristics from proposition and context
+        def extract_ethos_characteristics(proposition, context)
+          combined = "#{proposition} #{context}".downcase
+
+          # Determine ethical framework
+          ethical_framework = :utilitarian
+          if combined.include?('rights') || combined.include?('duty') || combined.include?('obligation')
+            ethical_framework = :deontological
+          elsif combined.include?('virtue') || combined.include?('character') || combined.include?('integrity')
+            ethical_framework = :virtue_ethics
+          elsif combined.include?('care') || combined.include?('relationship') || combined.include?('empathy')
+            ethical_framework = :care_ethics
+          end
+
+          # Identify principles
+          principles = identify_principles(combined)
+
+          # Identify values at stake
+          values_at_stake = identify_values_at_stake(combined)
+
+          # Identify ethical risks
+          ethical_risks = identify_ethical_risks(combined)
+
+          {
+            ethical_framework: ethical_framework,
+            principles: principles,
+            values_at_stake: values_at_stake,
+            ethical_risks: ethical_risks
+          }
+        end
+
+        # Helper methods for pathos analysis
+        def identify_stakeholders(text)
+          stakeholders = []
+          if text.include?('employee') || text.include?('worker') || text.include?('staff')
+            stakeholders << 'employees'
+          end
+          if text.include?('customer') || text.include?('client') || text.include?('user')
+            stakeholders << 'customers'
+          end
+          if text.include?('community') || text.include?('society') || text.include?('public')
+            stakeholders << 'community'
+          end
+          if text.include?('environment') || text.include?('nature') || text.include?('ecosystem')
+            stakeholders << 'environment'
+          end
+          stakeholders.any? ? stakeholders : ['affected parties']
+        end
+
+        def identify_emotional_risks(text)
+          risks = []
+          if text.include?('change') || text.include?('transform')
+            risks << 'Resistance to change'
+          end
+          if text.include?('reduce') || text.include?('cut') || text.include?('decrease')
+            risks << 'Anxiety about loss'
+          end
+          if text.include?('increase') || text.include?('expand') || text.include?('grow')
+            risks << 'Fear of overwhelm'
+          end
+          risks.any? ? risks : ['Unknown emotional impact']
+        end
+
+        def generate_pathos_verdict(proposition, characteristics, previous_pathos)
+          emotional_appeal = characteristics[:intensity] > 0.6 ? 'strong' : 'moderate'
+          stakeholder_count = characteristics[:stakeholders].length
+
+          if previous_pathos
+            return "After reconsideration, the emotional impact on #{characteristics[:stakeholders].join(', ')} remains a key factor. The proposition has #{emotional_appeal} emotional appeal with #{characteristics[:primary_emotion]} as the primary emotion. Proceeding with caution is advised."
+          end
+
+          "From an emotional standpoint, this proposition affects #{stakeholder_count} stakeholder groups: #{characteristics[:stakeholders].join(', ')}. The primary emotion of #{characteristics[:primary_emotion]} with #{emotional_appeal} intensity suggests #{characteristics[:intensity] > 0.5 ? 'proceeding with empathetic consideration' : 'the emotional impact may be manageable'}."
+        end
+
+        def calculate_pathos_confidence(characteristics, previous_opinions)
+          confidence = 0.5
+
+          # Higher confidence with more identified stakeholders
+          confidence += [0.2, characteristics[:stakeholders].length * 0.05].min
+
+          # Higher confidence with clear emotional signal
+          if characteristics[:primary_emotion] != 'neutral'
+            confidence += 0.1
+          end
+
+          # Consider previous logos agreement
+          previous_logos = previous_opinions.find { |op| op[:perspective] == :logos }
+          if previous_logos && previous_logos[:confidence] > 0.6
+            confidence += 0.05
+          end
+
+          [confidence, 1.0].min
+        end
+
+        def generate_pathos_arguments(characteristics)
+          args = []
+
+          args << "Addresses emotional needs of #{characteristics[:stakeholders].join(' and ')}"
+
+          if characteristics[:intensity] > 0.6
+            args << "Strong emotional engagement through #{characteristics[:primary_emotion]}"
+          end
+
+          if characteristics[:emotional_risks].any?
+            args << "Requires managing: #{characteristics[:emotional_risks].join(', ')}"
+          end
+
+          args
+        end
+
+        def identify_pathos_concerns(characteristics)
+          concerns = []
+
+          if characteristics[:intensity] > 0.7
+            concerns << 'High emotional intensity may cloud rational judgment'
+          end
+
+          if characteristics[:stakeholders].length > 3
+            concerns << 'Multiple stakeholder groups may have conflicting emotional needs'
+          end
+
+          if characteristics[:emotional_risks].any? { |r| r.include?('Resistance') || r.include?('Anxiety') }
+            concerns << 'Potential for emotional resistance that needs addressing'
+          end
+
+          concerns.any? ? concerns : ['Emotional impact appears manageable']
+        end
+
+        def generate_pathos_suggestions(characteristics)
+          suggestions = []
+
+          suggestions << "Consider communication strategy for #{characteristics[:stakeholders].join(' and ')}"
+
+          if characteristics[:primary_emotion] != 'neutral'
+            suggestions << "Address the #{characteristics[:primary_emotion]} emotion directly in implementation"
+          end
+
+          suggestions
+        end
+
+        # Helper methods for logos analysis
+        def extract_premises(text)
+          premises = []
+
+          if text.include?('because') || text.include?('since')
+            premises << 'Causal reasoning detected in argument'
+          end
+          if text.include?('data') || text.include?('evidence') || text.include?('research')
+            premises << 'Empirical evidence cited'
+          end
+          if text.include?('experience') || text.include?('history') || text.include?('track record')
+            premises << 'Historical precedent referenced'
+          end
+
+          premises.any? ? premises : ['Implicit premises require examination']
+        end
+
+        def identify_assumptions(text)
+          assumptions = []
+
+          if text.include?('will') || text.include?('going to')
+            assumptions << 'Future prediction assumed certain'
+          end
+          if text.include?('always') || text.include?('never')
+            assumptions << 'Absolute statements may oversimplify'
+          end
+          if text.include?('everyone') || text.include?('nobody')
+            assumptions << 'Universal claims need verification'
+          end
+
+          assumptions.any? ? assumptions : ['Standard assumptions apply']
+        end
+
+        def identify_logical_risks(text)
+          risks = []
+
+          if text.include?('all') && text.include?('must')
+            risks << 'Potential hasty generalization'
+          end
+          if text.include?('either') && text.include?('or')
+            risks << 'Possible false dichotomy'
+          end
+          if text.include?('because') && text.include?('popular')
+            risks << 'Potential appeal to popularity'
+          end
+
+          risks.any? ? risks : ['Logical structure appears sound']
+        end
+
+        def generate_logos_verdict(proposition, characteristics, previous_logos)
+          structure_desc = {
+            deductive: 'following a deductive structure from general principles',
+            inductive: 'building from specific observations to general conclusions',
+            abductive: 'inferring the most likely explanation',
+            analogical: 'drawing parallels from comparable situations'
+          }
+
+          if previous_logos
+            return "Upon re-examination, the #{characteristics[:logical_structure]} reasoning remains valid with #{characteristics[:premises].length} supporting premises. The logical risks (#{characteristics[:logical_risks].join(', ')}) should be monitored."
+          end
+
+          "The proposition presents #{structure_desc[characteristics[:logical_structure]]}. #{characteristics[:premises].length} premises have been identified. The argument's logical foundation is #{characteristics[:assumptions].length > 1 ? 'subject to several assumptions that warrant scrutiny' : 'relatively straightforward'}."
+        end
+
+        def calculate_logos_confidence(characteristics, previous_opinions)
+          confidence = 0.5
+
+          # More premises increase confidence
+          confidence += [0.2, characteristics[:premises].length * 0.05].min
+
+          # Fewer assumptions is better
+          confidence -= [0.15, characteristics[:assumptions].length * 0.03].min
+
+          # Fewer logical risks is better
+          confidence -= [0.1, characteristics[:logical_risks].length * 0.02].min
+
+          # Consider previous ethos agreement
+          previous_ethos = previous_opinions.find { |op| op[:perspective] == :ethos }
+          if previous_ethos && previous_ethos[:confidence] > 0.6
+            confidence += 0.05
+          end
+
+          [[confidence, 1.0].min, 0.0].max
+        end
+
+        def generate_logos_arguments(characteristics)
+          args = []
+
+          args << "Reasoning follows #{characteristics[:logical_structure]} structure"
+
+          characteristics[:premises].each do |premise|
+            args << "Premise: #{premise}"
+          end
+
+          if characteristics[:assumptions].any?
+            args << "Assumptions to verify: #{characteristics[:assumptions].join(', ')}"
+          end
+
+          args
+        end
+
+        def identify_logos_concerns(characteristics)
+          concerns = []
+
+          if characteristics[:assumptions].length > 2
+            concerns << 'Multiple unverified assumptions in the argument'
+          end
+
+          characteristics[:logical_risks].each do |risk|
+            concerns << risk unless risk.include?('appears sound')
+          end
+
+          if characteristics[:premises].any? { |p| p.include?('Implicit') }
+            concerns << 'Implicit premises need explicit articulation'
+          end
+
+          concerns.any? ? concerns : ['Logical structure is sound']
+        end
+
+        def assess_logical_validity(characteristics)
+          validity = 0.7
+
+          validity -= [0.2, characteristics[:logical_risks].length * 0.05].min
+          validity -= [0.1, characteristics[:assumptions].length * 0.02].min
+
+          [[validity, 0.3].max, 1.0].min
+        end
+
+        def generate_logos_suggestions(characteristics)
+          suggestions = []
+
+          characteristics[:assumptions].slice(0, 2).each do |assumption|
+            suggestions << "Verify assumption: #{assumption}"
+          end
+
+          if characteristics[:premises].any? { |p| p.include?('Implicit') }
+            suggestions << 'Make implicit premises explicit for clarity'
+          end
+
+          suggestions
+        end
+
+        # Helper methods for ethos analysis
+        def identify_principles(text)
+          principles = []
+
+          if text.include?('fair') || text.include?('equitable') || text.include?('just')
+            principles << 'Fairness and justice'
+          end
+          if text.include?('honest') || text.include?('transparent') || text.include?('truthful')
+            principles << 'Honesty and transparency'
+          end
+          if text.include?('respect') || text.include?('dignity') || text.include?('worth')
+            principles << 'Respect for dignity'
+          end
+          if text.include?('responsibility') || text.include?('accountable') || text.include?('liable')
+            principles << 'Accountability and responsibility'
+          end
+
+          principles.any? ? principles : ['General ethical principles apply']
+        end
+
+        def identify_values_at_stake(text)
+          values = []
+
+          if text.include?('privacy') || text.include?('confidential') || text.include?('secret')
+            values << 'Privacy rights'
+          end
+          if text.include?('safety') || text.include?('security') || text.include?('protection')
+            values << 'Safety and security'
+          end
+          if text.include?('freedom') || text.include?('autonomy') || text.include?('choice')
+            values << 'Autonomy and freedom'
+          end
+          if text.include?('equality') || text.include?('equal') || text.include?('discriminat')
+            values << 'Equality and non-discrimination'
+          end
+
+          values.any? ? values : ['Standard ethical values']
+        end
+
+        def identify_ethical_risks(text)
+          risks = []
+
+          if text.include?('profit') && !text.include?('people')
+            risks << 'Potential prioritization of profit over people'
+          end
+          if text.include?('secret') || text.include?('hidden') || text.include?('undisclosed')
+            risks << 'Transparency concerns'
+          end
+          if text.include?('minority') || text.include?('vulnerable') || text.include?('disadvantaged')
+            risks << 'Impact on vulnerable populations needs assessment'
+          end
+
+          risks.any? ? risks : ['No significant ethical risks identified']
+        end
+
+        def generate_ethos_verdict(proposition, characteristics, previous_ethos)
+          if previous_ethos
+            significant_risks = characteristics[:ethical_risks].none? { |r| r.include?('No significant') }
+            return "Upon ethical re-evaluation using #{characteristics[:ethical_framework]} framework, the proposition's alignment with #{characteristics[:principles].join(', ')} #{significant_risks ? 'requires attention to identified risks' : 'remains acceptable'}."
+          end
+
+          "From an ethical perspective informed by #{characteristics[:ethical_framework]} principles, this proposition #{characteristics[:values_at_stake].length > 2 ? 'implicates multiple values' : 'has limited ethical implications'}. The key principles at stake are #{characteristics[:principles].slice(0, 2).join(' and ')}."
+        end
+
+        def calculate_ethos_confidence(characteristics, previous_opinions)
+          confidence = 0.6
+
+          # More principles = clearer ethical framework
+          confidence += [0.1, characteristics[:principles].length * 0.02].min
+
+          # Fewer risks = higher confidence
+          if characteristics[:ethical_risks].any? { |r| r.include?('No significant') }
+            confidence += 0.1
+          else
+            confidence -= [0.15, characteristics[:ethical_risks].length * 0.03].min
+          end
+
+          # Consider previous pathos alignment
+          previous_pathos = previous_opinions.find { |op| op[:perspective] == :pathos }
+          if previous_pathos && previous_pathos[:confidence] > 0.6
+            confidence += 0.05
+          end
+
+          [[confidence, 1.0].min, 0.0].max
+        end
+
+        def generate_ethos_arguments(characteristics)
+          args = []
+
+          args << "Ethical framework: #{characteristics[:ethical_framework]}"
+
+          characteristics[:principles].slice(0, 2).each do |principle|
+            args << "Principle invoked: #{principle}"
+          end
+
+          if characteristics[:values_at_stake].any?
+            args << "Values at stake: #{characteristics[:values_at_stake].join(', ')}"
+          end
+
+          args
+        end
+
+        def identify_ethos_concerns(characteristics)
+          concerns = []
+
+          characteristics[:ethical_risks].each do |risk|
+            concerns << risk unless risk.include?('No significant')
+          end
+
+          if characteristics[:values_at_stake].length > 3
+            concerns << 'Multiple values may create ethical tensions'
+          end
+
+          concerns.any? ? concerns : ['Ethical considerations appear manageable']
+        end
+
+        def assess_ethical_alignment(characteristics)
+          alignment = 0.7
+
+          # Reduce for identified risks
+          significant_risks = characteristics[:ethical_risks].count { |r| !r.include?('No significant') }
+          alignment -= [0.2, significant_risks * 0.05].min
+
+          [[alignment, 0.3].max, 1.0].min
+        end
+
+        def generate_ethos_suggestions(characteristics)
+          suggestions = []
+
+          if characteristics[:ethical_risks].any? { |r| !r.include?('No significant') }
+            suggestions << 'Address identified ethical risks before implementation'
+          end
+
+          if characteristics[:values_at_stake].length > 2
+            suggestions << 'Consider ethical trade-offs between competing values'
+          end
+
+          suggestions << "Apply #{characteristics[:ethical_framework]} framework consistently"
+
+          suggestions
+        end
+      end
+    end
+  end
+end