lex-argument-mapping 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee2b8b06421ea9635bf67560d2ed64c9294e13f081ed9d018e0c06234c2bc16d
+  data.tar.gz: a1cc040fe37b5da71c9732db6b305b200f5c07aecb0da077bec9aaa37d574c84
+SHA512:
+  metadata.gz: 6720dd8283e689b26b6039aa75dbc0ecf2a650b054903e5b07021be556dae64bbf79755b2299b4b864b4bd27941f384c937944dd4ca8313c8a1700c5689c5bfc
+  data.tar.gz: 4d62f7b556c652ecc930f369c0cae717d9a1091f986531052fdbf33ae766d487fc82d27ae2ecaec077c5a7abf668ad0f8864422b0c3825e738b520afbf0739c5

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

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

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

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

data/lib/legion/extensions/argument_mapping.rb

@@ -0,0 +1,16 @@
+# 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 ArgumentMapping
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-argument-mapping
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+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: Toulmin-model argument mapping for LegionIO — claim/grounds/warrant/backing/qualifier/rebuttal
+  argument construction, strength assessment, and soundness evaluation
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/argument_mapping.rb
+- lib/legion/extensions/argument_mapping/client.rb
+- lib/legion/extensions/argument_mapping/helpers/argument.rb
+- lib/legion/extensions/argument_mapping/helpers/argument_engine.rb
+- lib/legion/extensions/argument_mapping/helpers/constants.rb
+- lib/legion/extensions/argument_mapping/runners/argument_mapping.rb
+- lib/legion/extensions/argument_mapping/version.rb
+homepage: https://github.com/LegionIO/lex-argument-mapping
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-argument-mapping
+  source_code_uri: https://github.com/LegionIO/lex-argument-mapping
+  documentation_uri: https://github.com/LegionIO/lex-argument-mapping
+  changelog_uri: https://github.com/LegionIO/lex-argument-mapping
+  bug_tracker_uri: https://github.com/LegionIO/lex-argument-mapping/issues
+  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 argument mapping extension
+test_files: []