lex-intuition 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54cf588e11b9e4fa679d51da57b237384f363af32e94ecd858ebab56a8d45c64
+  data.tar.gz: b82d54cbcefe2252f333a2afb9373387cd3b031e33bef9fa110a286483ea7325
+SHA512:
+  metadata.gz: 61e9043b280f39a6df62f982938007d829936bff7d420b1689d60ad49ae6cd8ad1a2835cb8981e11959226f9187d9790709e98e5f7bd99108ef3cb3dd3590221
+  data.tar.gz: d4af55546abe2e93d6d1c4dbd114496ea1f2848516509c62e9133906e39c2b07f3771e742c9d2214e4daf3bae16edde9dadd9e83a3aabeb755ecc21ce3bddc56

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Intuition
+      class Client
+        include Runners::Intuition
+
+        def initialize(engine: nil)
+          @engine = engine || Helpers::IntuitionEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Intuition
+      module Helpers
+        module Constants
+          MAX_PATTERNS = 200
+          MAX_HEURISTICS = 50
+          MAX_HISTORY = 300
+
+          # Recognition threshold: pattern match score needed to trigger recognition
+          RECOGNITION_THRESHOLD = 0.6
+
+          # Confidence: how much the agent trusts its intuitions
+          DEFAULT_CONFIDENCE = 0.5
+          CONFIDENCE_FLOOR = 0.05
+          CONFIDENCE_CEILING = 0.95
+
+          # Reinforcement: how fast patterns strengthen/weaken
+          REINFORCEMENT_RATE = 0.1
+          DECAY_RATE = 0.01
+
+          # Speed advantage: intuition is N times faster than deliberation
+          SPEED_MULTIPLIER = 5
+
+          PATTERN_STATES = %i[nascent developing reliable expert].freeze
+
+          HEURISTIC_TYPES = %i[
+            recognition take_the_best satisficing
+            fast_and_frugal anchored gaze
+          ].freeze
+
+          INTUITION_MODES = %i[
+            gut_feeling pattern_match heuristic_shortcut
+            recognition_primed compiled_expertise
+          ].freeze
+
+          CONFIDENCE_LABELS = {
+            (0.8..)     => :strong_hunch,
+            (0.6...0.8) => :leaning,
+            (0.4...0.6) => :uncertain,
+            (0.2...0.4) => :weak_signal,
+            (..0.2)     => :noise
+          }.freeze
+
+          STATE_THRESHOLDS = {
+            expert:     0.85,
+            reliable:   0.65,
+            developing: 0.35
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/intuition/helpers/heuristic.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Intuition
+      module Helpers
+        class Heuristic
+          include Constants
+
+          attr_reader :id, :name, :heuristic_type, :domain, :uses, :successes
+
+          def initialize(id:, name:, heuristic_type:, domain: :general)
+            @id             = id
+            @name           = name
+            @heuristic_type = resolve_type(heuristic_type)
+            @domain         = domain
+            @uses           = 0
+            @successes      = 0
+          end
+
+          def apply
+            @uses += 1
+          end
+
+          def record_outcome(success:)
+            @successes += 1 if success
+          end
+
+          def success_rate
+            return 0.0 if @uses.zero?
+
+            @successes.to_f / @uses
+          end
+
+          def effective?
+            @uses >= 3 && success_rate >= 0.6
+          end
+
+          def to_h
+            {
+              id:             @id,
+              name:           @name,
+              heuristic_type: @heuristic_type,
+              domain:         @domain,
+              uses:           @uses,
+              successes:      @successes,
+              success_rate:   success_rate.round(4),
+              effective:      effective?
+            }
+          end
+
+          private
+
+          def resolve_type(type)
+            sym = type.to_sym
+            HEURISTIC_TYPES.include?(sym) ? sym : :fast_and_frugal
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-intuition
+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: Recognition-primed decision making for LegionIO — fast-and-frugal heuristics,
+  pattern recognition, and compiled expertise
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/intuition/client.rb
+- lib/legion/extensions/intuition/helpers/constants.rb
+- lib/legion/extensions/intuition/helpers/heuristic.rb
+- lib/legion/extensions/intuition/helpers/intuition_engine.rb
+- lib/legion/extensions/intuition/helpers/pattern.rb
+- lib/legion/extensions/intuition/runners/intuition.rb
+- lib/legion/extensions/intuition/version.rb
+homepage: https://github.com/LegionIO/lex-intuition
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-intuition
+  source_code_uri: https://github.com/LegionIO/lex-intuition
+  documentation_uri: https://github.com/LegionIO/lex-intuition/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-intuition/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-intuition/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: Intuition and pattern recognition for LegionIO
+test_files: []