lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/intuition/helpers/intuition_engine.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          module Helpers
+            class IntuitionEngine
+              include Constants
+
+              attr_reader :patterns, :heuristics, :history
+
+              def initialize
+                @patterns       = {}
+                @heuristics     = {}
+                @pattern_count  = 0
+                @heuristic_count = 0
+                @history = []
+              end
+
+              def learn_pattern(cue:, response:, domain: :general, strength: DEFAULT_CONFIDENCE)
+                return nil if @patterns.size >= MAX_PATTERNS
+
+                @pattern_count += 1
+                pattern = Pattern.new(
+                  id:       :"pat_#{@pattern_count}",
+                  cue:      cue,
+                  response: response,
+                  domain:   domain,
+                  strength: strength
+                )
+                @patterns[pattern.id] = pattern
+                record_event(:learn, pattern_id: pattern.id)
+                pattern
+              end
+
+              def recognize(input_cue:, domain: nil)
+                candidates = domain ? domain_patterns(domain) : @patterns.values
+                matches = candidates.filter_map do |p|
+                  score = p.match_score(input_cue)
+                  { pattern: p, score: score } if score >= RECOGNITION_THRESHOLD
+                end
+                matches.sort_by { |m| -m[:score] }
+              end
+
+              def intuit(input_cue:, domain: nil)
+                matches = recognize(input_cue: input_cue, domain: domain)
+                return nil if matches.empty?
+
+                best = matches.first
+                record_event(:intuit, pattern_id: best[:pattern].id, score: best[:score])
+                {
+                  response:   best[:pattern].response,
+                  pattern_id: best[:pattern].id,
+                  confidence: best[:pattern].strength,
+                  match:      best[:score],
+                  mode:       intuition_mode(best)
+                }
+              end
+
+              def reinforce_pattern(pattern_id:, success:)
+                pattern = @patterns[pattern_id]
+                return nil unless pattern
+
+                pattern.reinforce(success: success)
+                record_event(:reinforce, pattern_id: pattern_id, success: success)
+                pattern.strength
+              end
+
+              def add_heuristic(name:, heuristic_type:, domain: :general)
+                return nil if @heuristics.size >= MAX_HEURISTICS
+
+                @heuristic_count += 1
+                heuristic = Heuristic.new(
+                  id:             :"heur_#{@heuristic_count}",
+                  name:           name,
+                  heuristic_type: heuristic_type,
+                  domain:         domain
+                )
+                @heuristics[heuristic.id] = heuristic
+                heuristic
+              end
+
+              def apply_heuristic(heuristic_id:)
+                heuristic = @heuristics[heuristic_id]
+                return nil unless heuristic
+
+                heuristic.apply
+                record_event(:apply_heuristic, heuristic_id: heuristic_id)
+                heuristic.to_h
+              end
+
+              def record_heuristic_outcome(heuristic_id:, success:)
+                heuristic = @heuristics[heuristic_id]
+                return nil unless heuristic
+
+                heuristic.record_outcome(success: success)
+              end
+
+              def reliable_patterns
+                @patterns.values.select(&:reliable?).map(&:to_h)
+              end
+
+              def expert_patterns
+                @patterns.values.select(&:expert?).map(&:to_h)
+              end
+
+              def effective_heuristics
+                @heuristics.values.select(&:effective?).map(&:to_h)
+              end
+
+              def patterns_in(domain:)
+                domain_patterns(domain).map(&:to_h)
+              end
+
+              def decay_all
+                @patterns.each_value(&:decay)
+              end
+
+              def to_h
+                {
+                  pattern_count:             @patterns.size,
+                  heuristic_count:           @heuristics.size,
+                  reliable_pattern_count:    @patterns.values.count(&:reliable?),
+                  expert_pattern_count:      @patterns.values.count(&:expert?),
+                  effective_heuristic_count: @heuristics.values.count(&:effective?),
+                  history_size:              @history.size
+                }
+              end
+
+              private
+
+              def domain_patterns(domain)
+                @patterns.values.select { |p| p.domain == domain }
+              end
+
+              def intuition_mode(match)
+                pattern = match[:pattern]
+                return :compiled_expertise if pattern.expert?
+                return :pattern_match if pattern.reliable?
+                return :recognition_primed if match[:score] >= 0.8
+
+                :gut_feeling
+              end
+
+              def record_event(type, **details)
+                @history << { type: type, at: Time.now.utc }.merge(details)
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/intuition/helpers/pattern.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          module Helpers
+            class Pattern
+              include Constants
+
+              attr_reader :id, :cue, :domain, :response, :strength,
+                          :encounters, :successes, :state
+
+              def initialize(id:, cue:, response:, domain: :general, strength: DEFAULT_CONFIDENCE)
+                @id         = id
+                @cue        = cue
+                @response   = response
+                @domain     = domain
+                @strength   = strength.to_f.clamp(CONFIDENCE_FLOOR, CONFIDENCE_CEILING)
+                @encounters = 0
+                @successes  = 0
+                @state      = compute_state
+              end
+
+              def match_score(input_cue)
+                return 0.0 unless input_cue.is_a?(Hash) && @cue.is_a?(Hash)
+
+                shared = @cue.keys & input_cue.keys
+                return 0.0 if shared.empty?
+
+                matches = shared.count { |k| @cue[k] == input_cue[k] }
+                matches.to_f / [@cue.size, input_cue.size].max
+              end
+
+              def recognized?(input_cue)
+                match_score(input_cue) >= RECOGNITION_THRESHOLD
+              end
+
+              def reinforce(success:)
+                @encounters += 1
+                @successes += 1 if success
+                shift = success ? REINFORCEMENT_RATE : -REINFORCEMENT_RATE
+                @strength = (@strength + shift).clamp(CONFIDENCE_FLOOR, CONFIDENCE_CEILING)
+                @state = compute_state
+                @strength
+              end
+
+              def decay
+                @strength = (@strength - DECAY_RATE).clamp(CONFIDENCE_FLOOR, CONFIDENCE_CEILING)
+                @state = compute_state
+              end
+
+              def success_rate
+                return 0.0 if @encounters.zero?
+
+                @successes.to_f / @encounters
+              end
+
+              def reliable?
+                @strength >= STATE_THRESHOLDS[:reliable] && @encounters >= 3
+              end
+
+              def expert?
+                @strength >= STATE_THRESHOLDS[:expert] && @encounters >= 10
+              end
+
+              def confidence_label
+                CONFIDENCE_LABELS.each { |range, lbl| return lbl if range.cover?(@strength) }
+                :noise
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  cue:              @cue,
+                  response:         @response,
+                  domain:           @domain,
+                  strength:         @strength.round(4),
+                  encounters:       @encounters,
+                  successes:        @successes,
+                  success_rate:     success_rate.round(4),
+                  state:            @state,
+                  confidence_label: confidence_label,
+                  reliable:         reliable?,
+                  expert:           expert?
+                }
+              end
+
+              private
+
+              def compute_state
+                return :expert if @strength >= STATE_THRESHOLDS[:expert]
+                return :reliable if @strength >= STATE_THRESHOLDS[:reliable]
+                return :developing if @strength >= STATE_THRESHOLDS[:developing]
+
+                :nascent
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          module Runners
+            module Intuition
+              include Helpers::Constants
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def learn_intuitive_pattern(cue:, response:, domain: :general, strength: DEFAULT_CONFIDENCE, **)
+                pattern = engine.learn_pattern(cue: cue, response: response, domain: domain, strength: strength)
+                return { success: false, reason: :limit_reached } unless pattern
+
+                { success: true, pattern_id: pattern.id, strength: pattern.strength }
+              end
+
+              def intuitive_recognize(input_cue:, domain: nil, **)
+                matches = engine.recognize(input_cue: input_cue, domain: domain)
+                {
+                  success: true,
+                  matches: matches.map { |m| { pattern_id: m[:pattern].id, score: m[:score].round(4) } },
+                  count:   matches.size
+                }
+              end
+
+              def intuit_response(input_cue:, domain: nil, **)
+                result = engine.intuit(input_cue: input_cue, domain: domain)
+                return { success: false, reason: :no_match } unless result
+
+                { success: true }.merge(result)
+              end
+
+              def reinforce_intuition(pattern_id:, success:, **)
+                result = engine.reinforce_pattern(pattern_id: pattern_id, success: success)
+                return { success: false, reason: :not_found } unless result
+
+                { success: true, pattern_id: pattern_id, strength: result.round(4) }
+              end
+
+              def add_intuitive_heuristic(name:, heuristic_type:, domain: :general, **)
+                heuristic = engine.add_heuristic(name: name, heuristic_type: heuristic_type, domain: domain)
+                return { success: false, reason: :limit_reached } unless heuristic
+
+                { success: true, heuristic_id: heuristic.id }
+              end
+
+              def apply_intuitive_heuristic(heuristic_id:, **)
+                result = engine.apply_heuristic(heuristic_id: heuristic_id)
+                return { success: false, reason: :not_found } unless result
+
+                { success: true }.merge(result)
+              end
+
+              def reliable_intuitions(**)
+                patterns = engine.reliable_patterns
+                { success: true, patterns: patterns, count: patterns.size }
+              end
+
+              def expert_intuitions(**)
+                patterns = engine.expert_patterns
+                { success: true, patterns: patterns, count: patterns.size }
+              end
+
+              def update_intuition(**)
+                engine.decay_all
+                { success: true }.merge(engine.to_h)
+              end
+
+              def intuition_stats(**)
+                { success: true }.merge(engine.to_h)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::IntuitionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/intuition/version'
+require 'legion/extensions/agentic/inference/intuition/helpers/constants'
+require 'legion/extensions/agentic/inference/intuition/helpers/pattern'
+require 'legion/extensions/agentic/inference/intuition/helpers/heuristic'
+require 'legion/extensions/agentic/inference/intuition/helpers/intuition_engine'
+require 'legion/extensions/agentic/inference/intuition/runners/intuition'
+require 'legion/extensions/agentic/inference/intuition/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/magnet/helpers/constants'
+require 'legion/extensions/agentic/inference/magnet/helpers/pole'
+require 'legion/extensions/agentic/inference/magnet/helpers/field'
+require 'legion/extensions/agentic/inference/magnet/helpers/magnet_engine'
+require 'legion/extensions/agentic/inference/magnet/runners/cognitive_magnet'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Magnet
+          class Client
+            include Runners::CognitiveMagnet
+
+            def initialize(**)
+              @magnet_engine = Helpers::MagnetEngine.new
+            end
+
+            private
+
+            attr_reader :magnet_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Magnet
+          module Helpers
+            module Constants
+              POLARITY_TYPES   = %i[positive negative neutral bipolar].freeze
+              MATERIAL_TYPES   = %i[iron cobalt nickel lodestone ferrite].freeze
+              MAX_POLES        = 500
+              MAX_FIELDS       = 50
+              ATTRACTION_RATE  = 0.08
+              REPULSION_RATE   = 0.06
+              DECAY_RATE       = 0.02
+
+              STRENGTH_LABELS = {
+                (0.0..0.1) => :negligible,
+                (0.1..0.3) => :faint,
+                (0.3..0.5) => :moderate,
+                (0.5..0.7) => :strong,
+                (0.7..0.9) => :intense,
+                (0.9..1.0) => :overwhelming
+              }.freeze
+
+              ALIGNMENT_LABELS = {
+                (0.0..0.2) => :chaotic,
+                (0.2..0.4) => :discordant,
+                (0.4..0.6) => :neutral,
+                (0.6..0.8) => :coherent,
+                (0.8..1.0) => :perfect
+              }.freeze
+
+              module_function
+
+              def label_for(table, value)
+                table.each do |range, label|
+                  return label if range.cover?(value)
+                end
+                :unknown
+              end
+
+              def valid_polarity?(polarity)
+                POLARITY_TYPES.include?(polarity)
+              end
+
+              def valid_material?(material)
+                MATERIAL_TYPES.include?(material)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/magnet/helpers/field.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Magnet
+          module Helpers
+            class Field
+              attr_reader :id, :name, :pole_ids, :alignment, :flux_density, :created_at
+
+              def initialize(name:)
+                @id          = SecureRandom.uuid
+                @name        = name
+                @pole_ids    = []
+                @alignment   = 0.0
+                @flux_density = 0.0
+                @created_at  = Time.now.utc
+              end
+
+              def add_pole(pole_id)
+                return false if @pole_ids.include?(pole_id)
+
+                @pole_ids << pole_id
+                true
+              end
+
+              def remove_pole(pole_id)
+                removed = @pole_ids.delete(pole_id)
+                !removed.nil?
+              end
+
+              def calculate_alignment!(poles)
+                field_poles = poles.values.select { |p| @pole_ids.include?(p.id) }
+                return self if field_poles.empty?
+
+                @flux_density = field_poles.sum(&:strength) / field_poles.size.to_f
+                @alignment    = compute_alignment(field_poles).round(10)
+                self
+              end
+
+              def coherent?
+                @alignment >= 0.6
+              end
+
+              def chaotic?
+                @alignment < 0.2
+              end
+
+              def alignment_label
+                Constants.label_for(Constants::ALIGNMENT_LABELS, @alignment)
+              end
+
+              def pole_count
+                @pole_ids.size
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  name:            @name,
+                  pole_ids:        @pole_ids.dup,
+                  alignment:       @alignment,
+                  flux_density:    @flux_density,
+                  pole_count:      pole_count,
+                  coherent:        coherent?,
+                  chaotic:         chaotic?,
+                  alignment_label: alignment_label,
+                  created_at:      @created_at
+                }
+              end
+
+              private
+
+              def compute_alignment(field_poles)
+                return 0.0 if field_poles.size < 2
+
+                total_pairs    = 0
+                aligned_weight = 0.0
+
+                field_poles.combination(2) do |a, b|
+                  total_pairs += 1
+                  pair_weight  = (a.strength + b.strength) / 2.0
+
+                  if a.attracts?(b)
+                    aligned_weight += pair_weight
+                  elsif a.repels?(b)
+                    aligned_weight -= pair_weight * 0.5
+                  end
+                end
+
+                return 0.5 if total_pairs.zero?
+
+                raw = aligned_weight / total_pairs.to_f
+                ((raw + 1.0) / 2.0).clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end