lex-agentic-inference 0.1.0

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module CausalReasoning
+          module Runners
+            module CausalReasoning
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_causal_variable(name:, domain: :general, **)
+                if graph.variable_exists?(name)
+                  Legion::Logging.warn "[causal] add_variable duplicate: name=#{name}"
+                  return { success: false, reason: :limit_or_duplicate, name: name }
+                end
+
+                variable = graph.add_variable(name: name, domain: domain)
+                if variable
+                  Legion::Logging.debug "[causal] add_variable: name=#{name} domain=#{domain}"
+                  { success: true, variable: variable }
+                else
+                  Legion::Logging.warn "[causal] add_variable failed (limit): name=#{name}"
+                  { success: false, reason: :limit_or_duplicate, name: name }
+                end
+              end
+
+              def add_causal_edge(cause:, effect:, edge_type:, domain: :general,
+                                  strength: Helpers::Constants::DEFAULT_STRENGTH, **)
+                edge = graph.add_edge(cause: cause, effect: effect,
+                                      edge_type: edge_type, domain: domain, strength: strength)
+                if edge
+                  str = edge.strength.round(2)
+                  Legion::Logging.debug "[causal] add_edge: #{cause}->#{effect} type=#{edge_type} str=#{str}"
+                  { success: true, edge: edge.to_h }
+                else
+                  Legion::Logging.warn "[causal] add_edge failed: cause=#{cause} effect=#{effect} type=#{edge_type}"
+                  { success: false, reason: :limit_or_invalid_type, cause: cause, effect: effect }
+                end
+              end
+
+              def find_causes(variable:, **)
+                edges = graph.causes_of(variable: variable)
+                Legion::Logging.debug "[causal] find_causes: variable=#{variable} count=#{edges.size}"
+                { success: true, variable: variable, causes: edges.map(&:to_h), count: edges.size }
+              end
+
+              def find_effects(variable:, **)
+                edges = graph.effects_of(variable: variable)
+                Legion::Logging.debug "[causal] find_effects: variable=#{variable} count=#{edges.size}"
+                { success: true, variable: variable, effects: edges.map(&:to_h), count: edges.size }
+              end
+
+              def trace_causal_chain(from:, to:, max_depth: 5, **)
+                paths = graph.causal_chain(from: from, to: to, max_depth: max_depth)
+                Legion::Logging.debug "[causal] trace_chain: from=#{from} to=#{to} paths=#{paths.size}"
+                { success: true, from: from, to: to, paths: paths, path_count: paths.size }
+              end
+
+              def causal_intervention(variable:, value:, **)
+                result = graph.intervene(variable: variable, value: value)
+                count = result[:downstream_effects].size
+                Legion::Logging.info "[causal] intervention: do(#{variable}=#{value}) downstream=#{count}"
+                { success: true }.merge(result)
+              end
+
+              def find_confounders(var_a:, var_b:, **)
+                common = graph.confounders(var_a: var_a, var_b: var_b)
+                Legion::Logging.debug "[causal] confounders: #{var_a} <-> #{var_b} count=#{common.size}"
+                { success: true, var_a: var_a, var_b: var_b, confounders: common, count: common.size }
+              end
+
+              def add_causal_evidence(edge_id:, **)
+                edge = graph.add_evidence(edge_id: edge_id)
+                if edge
+                  cnt = edge.evidence_count
+                  str = edge.strength.round(2)
+                  Legion::Logging.debug "[causal] add_evidence: edge=#{edge_id} count=#{cnt} strength=#{str}"
+                  { success: true, edge_id: edge_id, evidence_count: edge.evidence_count, strength: edge.strength }
+                else
+                  Legion::Logging.warn "[causal] add_evidence failed: edge=#{edge_id} not found"
+                  { success: false, reason: :edge_not_found, edge_id: edge_id }
+                end
+              end
+
+              def update_causal_reasoning(**)
+                decayed = graph.decay_all
+                pruned  = graph.prune_weak
+                Legion::Logging.debug "[causal] update: decayed=#{decayed} pruned=#{pruned}"
+                { success: true, decayed: decayed, pruned: pruned }
+              end
+
+              def causal_reasoning_stats(**)
+                stats = graph.to_h
+                Legion::Logging.debug "[causal] stats: #{stats.inspect}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def graph
+                @graph ||= Helpers::CausalGraph.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_reasoning/version'
+require 'legion/extensions/agentic/inference/causal_reasoning/helpers/constants'
+require 'legion/extensions/agentic/inference/causal_reasoning/helpers/causal_edge'
+require 'legion/extensions/agentic/inference/causal_reasoning/helpers/causal_graph'
+require 'legion/extensions/agentic/inference/causal_reasoning/runners/causal_reasoning'
+require 'legion/extensions/agentic/inference/causal_reasoning/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module CausalReasoning
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/coherence/helpers/constants'
+require 'legion/extensions/agentic/inference/coherence/helpers/proposition'
+require 'legion/extensions/agentic/inference/coherence/helpers/coherence_engine'
+require 'legion/extensions/agentic/inference/coherence/runners/cognitive_coherence'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+          class Client
+            include Runners::CognitiveCoherence
+
+            def initialize(**)
+              @engine = Helpers::CoherenceEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/coherence/helpers/coherence_engine.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+          module Helpers
+            class CoherenceEngine
+              include Constants
+
+              attr_reader :propositions, :history
+
+              def initialize
+                @propositions = {}
+                @history      = []
+              end
+
+              def add_proposition(content:, domain: :general, acceptance: DEFAULT_ACCEPTANCE)
+                return nil if @propositions.size >= MAX_PROPOSITIONS
+
+                prop = Proposition.new(content: content, domain: domain, acceptance: acceptance)
+                @propositions[prop.id] = prop
+                record_history(:add_proposition, { id: prop.id, domain: domain })
+                prop.id
+              end
+
+              def add_constraint(prop_a_id:, prop_b_id:, constraint_type:, positive: true)
+                prop_a = @propositions[prop_a_id]
+                prop_b = @propositions[prop_b_id]
+                return { success: false, reason: :proposition_not_found } unless prop_a && prop_b
+
+                unless CONSTRAINT_TYPES.include?(constraint_type)
+                  return { success: false,
+                           reason:  :invalid_constraint_type }
+                end
+
+                if positive
+                  prop_a.add_positive_constraint(proposition_id: prop_b_id)
+                  prop_b.add_positive_constraint(proposition_id: prop_a_id)
+                else
+                  prop_a.add_negative_constraint(proposition_id: prop_b_id)
+                  prop_b.add_negative_constraint(proposition_id: prop_a_id)
+                end
+
+                record_history(:add_constraint,
+                               { prop_a: prop_a_id, prop_b: prop_b_id, type: constraint_type, positive: positive })
+                { success: true, constraint_type: constraint_type, positive: positive }
+              end
+
+              def compute_coherence(proposition_id:)
+                prop = @propositions[proposition_id]
+                return 0.0 unless prop
+
+                positive_sum = prop.positive_constraints.sum do |pid|
+                  neighbor = @propositions[pid]
+                  neighbor ? neighbor.acceptance * COHERENCE_WEIGHT : 0.0
+                end
+
+                negative_sum = prop.negative_constraints.sum do |pid|
+                  neighbor = @propositions[pid]
+                  neighbor ? neighbor.acceptance * INCOHERENCE_PENALTY : 0.0
+                end
+
+                (prop.acceptance + positive_sum - negative_sum).clamp(0.0, 1.0)
+              end
+
+              def maximize_coherence
+                return { success: true, iterations: 0, proposition_count: 0 } if @propositions.empty?
+
+                @propositions.each_value { |prop| adjust_proposition(prop) }
+
+                record_history(:maximize_coherence, { overall: overall_coherence })
+                {
+                  success:           true,
+                  iterations:        1,
+                  proposition_count: @propositions.size,
+                  overall_coherence: overall_coherence
+                }
+              end
+
+              def overall_coherence
+                return 0.0 if @propositions.empty?
+
+                total = @propositions.values.sum { |prop| compute_coherence(proposition_id: prop.id) }
+                total / @propositions.size
+              end
+
+              def coherence_label
+                val = overall_coherence
+                COHERENCE_LABELS.find { |range, _| range.cover?(val) }&.last || :unknown
+              end
+
+              def find_contradictions
+                accepted = @propositions.values.select(&:accepted?)
+                pairs    = []
+                accepted.each { |prop| collect_contradiction_pairs(prop, pairs) }
+                pairs
+              end
+
+              def partition
+                result = { accepted: [], rejected: [], undecided: [] }
+                @propositions.each_value { |prop| result[prop.state] << prop.to_h }
+                result
+              end
+
+              def by_domain(domain:)
+                @propositions.values.select { |prop| prop.domain == domain }.map(&:to_h)
+              end
+
+              def decay_all
+                count = 0
+                @propositions.each_value do |prop|
+                  next if prop.acceptance == DEFAULT_ACCEPTANCE
+
+                  delta = (DEFAULT_ACCEPTANCE - prop.acceptance) * DECAY_RATE
+                  prop.adjust_acceptance(amount: delta) unless delta.abs < 0.0001
+                  count += 1
+                end
+                { success: true, decayed_count: count }
+              end
+
+              def to_h
+                {
+                  proposition_count: @propositions.size,
+                  overall_coherence: overall_coherence,
+                  coherence_label:   coherence_label,
+                  partition:         partition,
+                  history_size:      @history.size
+                }
+              end
+
+              private
+
+              def adjust_proposition(prop)
+                positive_pull = prop.positive_constraints.sum do |pid|
+                  neighbor = @propositions[pid]
+                  neighbor ? neighbor.acceptance * COHERENCE_WEIGHT : 0.0
+                end
+
+                negative_push = prop.negative_constraints.sum do |pid|
+                  neighbor = @propositions[pid]
+                  neighbor ? neighbor.acceptance * INCOHERENCE_PENALTY : 0.0
+                end
+
+                delta = positive_pull - negative_push
+                prop.adjust_acceptance(amount: delta) unless delta.abs < 0.001
+              end
+
+              def collect_contradiction_pairs(prop, pairs)
+                prop.negative_constraints.each do |neg_id|
+                  neighbor = @propositions[neg_id]
+                  next unless neighbor&.accepted?
+                  next if pairs.any? { |pair| pair[:prop_b] == prop.id && pair[:prop_a] == neg_id }
+
+                  pairs << { prop_a: prop.id, prop_b: neg_id }
+                end
+              end
+
+              def record_history(event, data)
+                @history << { event: event, data: data, at: Time.now.utc }
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+          module Helpers
+            module Constants
+              MAX_PROPOSITIONS   = 200
+              MAX_CONSTRAINTS    = 500
+              MAX_HISTORY        = 300
+              DEFAULT_ACCEPTANCE = 0.5
+              ACCEPTANCE_THRESHOLD = 0.6
+              COHERENCE_WEIGHT = 0.1
+              INCOHERENCE_PENALTY = 0.15
+              DECAY_RATE         = 0.01
+
+              CONSTRAINT_TYPES = %i[explanatory deductive analogical perceptual conceptual deliberative].freeze
+              PROPOSITION_STATES = %i[accepted rejected undecided].freeze
+
+              COHERENCE_LABELS = {
+                (0.8..)     => :highly_coherent,
+                (0.6...0.8) => :coherent,
+                (0.4...0.6) => :mixed,
+                (0.2...0.4) => :incoherent,
+                (..0.2)     => :contradictory
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/coherence/helpers/proposition.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+          module Helpers
+            class Proposition
+              include Constants
+
+              attr_reader :id, :content, :domain, :acceptance,
+                          :positive_constraints, :negative_constraints,
+                          :evidence_count, :created_at, :updated_at
+
+              def initialize(content:, domain: :general, acceptance: DEFAULT_ACCEPTANCE)
+                @id                  = SecureRandom.uuid
+                @content             = content
+                @domain              = domain
+                @acceptance          = acceptance.clamp(0.0, 1.0)
+                @positive_constraints = []
+                @negative_constraints = []
+                @evidence_count      = 0
+                @created_at          = Time.now.utc
+                @updated_at          = Time.now.utc
+              end
+
+              def state
+                if @acceptance >= ACCEPTANCE_THRESHOLD
+                  :accepted
+                elsif @acceptance < (1.0 - ACCEPTANCE_THRESHOLD)
+                  :rejected
+                else
+                  :undecided
+                end
+              end
+
+              def accepted?
+                state == :accepted
+              end
+
+              def rejected?
+                state == :rejected
+              end
+
+              def undecided?
+                state == :undecided
+              end
+
+              def add_positive_constraint(proposition_id:)
+                return false if @positive_constraints.include?(proposition_id)
+
+                @positive_constraints << proposition_id
+                @updated_at = Time.now.utc
+                true
+              end
+
+              def add_negative_constraint(proposition_id:)
+                return false if @negative_constraints.include?(proposition_id)
+
+                @negative_constraints << proposition_id
+                @updated_at = Time.now.utc
+                true
+              end
+
+              def adjust_acceptance(amount:)
+                @acceptance = (@acceptance + amount).clamp(0.0, 1.0)
+                @updated_at = Time.now.utc
+                @acceptance
+              end
+
+              def add_evidence
+                @evidence_count += 1
+                @updated_at = Time.now.utc
+                @evidence_count
+              end
+
+              def to_h
+                {
+                  id:                   @id,
+                  content:              @content,
+                  domain:               @domain,
+                  acceptance:           @acceptance,
+                  state:                state,
+                  positive_constraints: @positive_constraints.dup,
+                  negative_constraints: @negative_constraints.dup,
+                  evidence_count:       @evidence_count,
+                  created_at:           @created_at,
+                  updated_at:           @updated_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/coherence/runners/cognitive_coherence.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+          module Runners
+            module CognitiveCoherence
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_coherence_proposition(content:, domain: :general, acceptance: Helpers::Constants::DEFAULT_ACCEPTANCE,
+                                            **)
+                return { success: false, reason: :missing_content } if content.nil? || content.empty?
+
+                prop_id = engine.add_proposition(content: content, domain: domain, acceptance: acceptance)
+                if prop_id
+                  Legion::Logging.debug "[cognitive_coherence] add_proposition domain=#{domain} id=#{prop_id[0..7]}"
+                  { success: true, proposition_id: prop_id, domain: domain, acceptance: acceptance }
+                else
+                  Legion::Logging.warn '[cognitive_coherence] add_proposition failed: max propositions reached'
+                  { success: false, reason: :max_propositions_reached }
+                end
+              end
+
+              def add_coherence_constraint(prop_a_id:, prop_b_id:, constraint_type:, positive: true, **)
+                unless Helpers::Constants::CONSTRAINT_TYPES.include?(constraint_type)
+                  return { success: false, reason: :invalid_constraint_type,
+                           valid_types: Helpers::Constants::CONSTRAINT_TYPES }
+                end
+
+                result = engine.add_constraint(
+                  prop_a_id:       prop_a_id,
+                  prop_b_id:       prop_b_id,
+                  constraint_type: constraint_type,
+                  positive:        positive
+                )
+
+                Legion::Logging.debug "[cognitive_coherence] add_constraint type=#{constraint_type} " \
+                                      "positive=#{positive} success=#{result[:success]}"
+                result
+              end
+
+              def compute_proposition_coherence(proposition_id:, **)
+                score = engine.compute_coherence(proposition_id: proposition_id)
+                prop  = engine.propositions[proposition_id]
+
+                unless prop
+                  Legion::Logging.debug "[cognitive_coherence] compute_coherence: #{proposition_id[0..7]} not found"
+                  return { success: false, reason: :not_found }
+                end
+
+                Legion::Logging.debug '[cognitive_coherence] compute_coherence ' \
+                                      "id=#{proposition_id[0..7]} score=#{score.round(3)}"
+                { success: true, proposition_id: proposition_id, coherence_score: score, state: prop.state }
+              end
+
+              def maximize_coherence(**)
+                result = engine.maximize_coherence
+                overall = result[:overall_coherence]&.round(3)
+                Legion::Logging.info '[cognitive_coherence] maximize_coherence ' \
+                                     "overall=#{overall} props=#{result[:proposition_count]}"
+                result
+              end
+
+              def find_contradictions(**)
+                pairs = engine.find_contradictions
+                Legion::Logging.debug "[cognitive_coherence] find_contradictions count=#{pairs.size}"
+                { success: true, contradictions: pairs, count: pairs.size }
+              end
+
+              def coherence_partition(**)
+                result = engine.partition
+                totals = result.transform_values(&:size)
+                Legion::Logging.debug "[cognitive_coherence] partition accepted=#{totals[:accepted]} " \
+                                      "rejected=#{totals[:rejected]} undecided=#{totals[:undecided]}"
+                { success: true, partition: result, counts: totals }
+              end
+
+              def update_cognitive_coherence(**)
+                coherence_result = engine.maximize_coherence
+                decay_result     = engine.decay_all
+
+                overall = coherence_result[:overall_coherence]&.round(3)
+                Legion::Logging.info "[cognitive_coherence] update overall=#{overall} " \
+                                     "decayed=#{decay_result[:decayed_count]}"
+                {
+                  success:           true,
+                  overall_coherence: coherence_result[:overall_coherence],
+                  coherence_label:   engine.coherence_label,
+                  decayed_count:     decay_result[:decayed_count]
+                }
+              end
+
+              def cognitive_coherence_stats(**)
+                part   = engine.partition
+                counts = part.transform_values(&:size)
+                Legion::Logging.debug "[cognitive_coherence] stats propositions=#{engine.propositions.size} " \
+                                      "coherence=#{engine.overall_coherence.round(3)}"
+                {
+                  success:             true,
+                  proposition_count:   engine.propositions.size,
+                  overall_coherence:   engine.overall_coherence,
+                  coherence_label:     engine.coherence_label,
+                  partition_counts:    counts,
+                  contradiction_count: engine.find_contradictions.size,
+                  history_size:        engine.history.size
+                }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::CoherenceEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/coherence/version'
+require 'legion/extensions/agentic/inference/coherence/helpers/constants'
+require 'legion/extensions/agentic/inference/coherence/helpers/proposition'
+require 'legion/extensions/agentic/inference/coherence/helpers/coherence_engine'
+require 'legion/extensions/agentic/inference/coherence/runners/cognitive_coherence'
+require 'legion/extensions/agentic/inference/coherence/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Coherence
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Counterfactual
+          class Client
+            include Runners::Counterfactual
+
+            def initialize(**opts)
+              @engine = opts[:engine] if opts[:engine]
+            end
+          end
+        end
+      end
+    end
+  end
+end