lex-self-model 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c0246b5a6afc20e2381d6517d83d9e7786c3da4de8f35126fb027bdabacd0aa
+  data.tar.gz: 8975d4507567a790d341bd24317f4206207aaebe24ef630dfafbcd82634b24ce
+SHA512:
+  metadata.gz: 145cc57f3dd898d6ea653162aad93be523c0e7b8f3c5c15c604ce23bdc2b343f0936a6052d3cff8ea3824e03672439f5dcfe0c1f3176e06a241f8247c6bc4fc0
+  data.tar.gz: 0b6d03bc047353a34198a1459c40ab873428d073c549a7a5ac2003104dd588c0bffc91f68846c446cd2729c939b89629270bd901fdbc0c25a2d0c7277efe9a09

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

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

data/lib/legion/extensions/self_model/helpers/capability.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SelfModel
+      module Helpers
+        class Capability
+          include Constants
+
+          attr_reader :id, :name, :domain, :competence, :attempts, :successes, :state, :calibration_error
+
+          def initialize(id:, name:, domain: :general, competence: DEFAULT_COMPETENCE)
+            @id                = id
+            @name              = name
+            @domain            = domain
+            @competence        = competence.to_f.clamp(COMPETENCE_FLOOR, COMPETENCE_CEILING)
+            @attempts          = 0
+            @successes         = 0
+            @calibration_error = 0.0
+            @state             = compute_state
+          end
+
+          def record_attempt(predicted_success:, actual_success:)
+            @attempts += 1
+            @successes += 1 if actual_success
+
+            prediction = predicted_success ? 1.0 : 0.0
+            outcome    = actual_success    ? 1.0 : 0.0
+
+            error = prediction - outcome
+            @calibration_error += CALIBRATION_ALPHA * (error - @calibration_error)
+
+            @competence += CALIBRATION_ALPHA * (outcome - @competence)
+            @competence  = @competence.clamp(COMPETENCE_FLOOR, COMPETENCE_CEILING)
+            @state       = compute_state
+          end
+
+          def competence_label
+            CONFIDENCE_LABELS.each { |range, lbl| return lbl if range.cover?(@competence) }
+            :very_low
+          end
+
+          def calibrated?
+            @calibration_error.abs < 0.15
+          end
+
+          def overconfident?
+            @calibration_error > OVERCONFIDENCE_THRESHOLD
+          end
+
+          def underconfident?
+            @calibration_error < UNDERCONFIDENCE_THRESHOLD
+          end
+
+          def to_h
+            {
+              id:                @id,
+              name:              @name,
+              domain:            @domain,
+              competence:        @competence.round(4),
+              competence_label:  competence_label,
+              state:             @state,
+              attempts:          @attempts,
+              successes:         @successes,
+              calibration_error: @calibration_error.round(4),
+              calibrated:        calibrated?,
+              overconfident:     overconfident?,
+              underconfident:    underconfident?
+            }
+          end
+
+          private
+
+          def compute_state
+            if @competence < 0.2
+              :unknown
+            elsif @competence < 0.5
+              :developing
+            elsif @competence < 0.8
+              :competent
+            else
+              :expert
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SelfModel
+      module Helpers
+        module Constants
+          MAX_CAPABILITIES      = 100
+          MAX_KNOWLEDGE_DOMAINS = 50
+          MAX_HISTORY           = 200
+
+          DEFAULT_COMPETENCE  = 0.5
+          COMPETENCE_FLOOR    = 0.05
+          COMPETENCE_CEILING  = 0.99
+          CALIBRATION_ALPHA   = 0.1
+
+          OVERCONFIDENCE_THRESHOLD  =  0.3
+          UNDERCONFIDENCE_THRESHOLD = -0.3
+
+          CAPABILITY_STATES = %i[unknown developing competent expert].freeze
+          KNOWLEDGE_STATES  = %i[ignorant aware familiar expert].freeze
+
+          CONFIDENCE_LABELS = {
+            (0.9..)     => :very_high,
+            (0.7...0.9) => :high,
+            (0.5...0.7) => :moderate,
+            (0.3...0.5) => :low,
+            (..0.3)     => :very_low
+          }.freeze
+
+          CALIBRATION_LABELS = {
+            excellent:    0.05,
+            good:         0.10,
+            fair:         0.20,
+            poor:         0.35,
+            uncalibrated: Float::INFINITY
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/self_model/helpers/knowledge_domain.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SelfModel
+      module Helpers
+        class KnowledgeDomain
+          include Constants
+
+          attr_reader :id, :name, :depth, :breadth, :confidence, :state, :last_accessed
+
+          def initialize(id:, name:, depth: 0.0, breadth: 0.0)
+            @id            = id
+            @name          = name
+            @depth         = depth.to_f.clamp(0.0, 1.0)
+            @breadth       = breadth.to_f.clamp(0.0, 1.0)
+            @last_accessed = nil
+            @state         = compute_state
+            @confidence    = average_score
+          end
+
+          def deepen(amount:)
+            @depth      = (@depth + amount.to_f).clamp(0.0, 1.0)
+            @state      = compute_state
+            @confidence = average_score
+          end
+
+          def broaden(amount:)
+            @breadth    = (@breadth + amount.to_f).clamp(0.0, 1.0)
+            @state      = compute_state
+            @confidence = average_score
+          end
+
+          def access!
+            @last_accessed = Time.now.utc
+          end
+
+          def knowledge_label
+            CONFIDENCE_LABELS.each { |range, lbl| return lbl if range.cover?(@confidence) }
+            :very_low
+          end
+
+          def to_h
+            {
+              id:              @id,
+              name:            @name,
+              depth:           @depth.round(4),
+              breadth:         @breadth.round(4),
+              confidence:      @confidence.round(4),
+              state:           @state,
+              knowledge_label: knowledge_label,
+              last_accessed:   @last_accessed
+            }
+          end
+
+          private
+
+          def average_score
+            (@depth + @breadth) / 2.0
+          end
+
+          def compute_state
+            score = average_score
+            if score < 0.2
+              :ignorant
+            elsif score < 0.5
+              :aware
+            elsif score < 0.8
+              :familiar
+            else
+              :expert
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/self_model/helpers/self_model.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SelfModel
+      module Helpers
+        class SelfModel
+          include Constants
+
+          attr_reader :capabilities, :knowledge_domains, :predictions, :history
+
+          def initialize
+            @capabilities      = {}
+            @knowledge_domains = {}
+            @predictions       = []
+            @history           = []
+            @cap_counter       = 0
+            @dom_counter       = 0
+          end
+
+          def add_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE)
+            return nil if @capabilities.size >= MAX_CAPABILITIES
+
+            @cap_counter += 1
+            cap_id = :"cap_#{@cap_counter}"
+            cap = Capability.new(id: cap_id, name: name, domain: domain, competence: competence)
+            @capabilities[cap_id] = cap
+            cap
+          end
+
+          def add_knowledge_domain(name:, depth: 0.0, breadth: 0.0)
+            return nil if @knowledge_domains.size >= MAX_KNOWLEDGE_DOMAINS
+
+            @dom_counter += 1
+            dom_id = :"dom_#{@dom_counter}"
+            dom = KnowledgeDomain.new(id: dom_id, name: name, depth: depth, breadth: breadth)
+            @knowledge_domains[dom_id] = dom
+            dom
+          end
+
+          def predict_success(capability_id:)
+            cap = @capabilities[capability_id]
+            return nil unless cap
+
+            prediction = { capability_id: capability_id, predicted_probability: cap.competence.round(4),
+                           at: Time.now.utc }
+            @predictions << prediction
+            @predictions.shift while @predictions.size > MAX_HISTORY
+            prediction
+          end
+
+          def record_outcome(capability_id:, predicted:, actual:)
+            cap = @capabilities[capability_id]
+            return nil unless cap
+
+            cap.record_attempt(predicted_success: predicted, actual_success: actual)
+            event = { type: :outcome, capability_id: capability_id, predicted: predicted,
+                      actual: actual, at: Time.now.utc }
+            @history << event
+            @history.shift while @history.size > MAX_HISTORY
+            event
+          end
+
+          def introspect
+            {
+              overall_confidence: overall_confidence.round(4),
+              strengths:          strengths.map(&:to_h),
+              weaknesses:         weaknesses.map(&:to_h),
+              blind_spots:        blind_spots.map(&:to_h),
+              knowledge_gaps:     knowledge_gaps.map(&:to_h),
+              calibration:        calibration_report
+            }
+          end
+
+          def strengths
+            @capabilities.values.select { |c| c.competence > 0.7 }
+          end
+
+          def weaknesses
+            @capabilities.values.select { |c| c.competence < 0.3 }
+          end
+
+          def blind_spots
+            @capabilities.values.select(&:overconfident?)
+          end
+
+          def calibration_report
+            caps = @capabilities.values
+            return { label: :uncalibrated, mean_error: 0.0, calibrated_count: 0, total: 0 } if caps.empty?
+
+            errors = caps.map { |c| c.calibration_error.abs }
+            mean_error = errors.sum / errors.size.to_f
+            calibrated_count = caps.count(&:calibrated?)
+
+            label = CALIBRATION_LABELS.each do |lbl, threshold|
+              break lbl if mean_error <= threshold
+            end
+            label = :uncalibrated unless label.is_a?(Symbol)
+
+            { label: label, mean_error: mean_error.round(4), calibrated_count: calibrated_count,
+              total: caps.size }
+          end
+
+          def knowledge_gaps
+            @knowledge_domains.values.select { |d| d.depth < 0.3 }
+          end
+
+          def can_do?(capability_name)
+            cap = @capabilities.values.find { |c| c.name == capability_name }
+            return false unless cap
+
+            cap.competence >= 0.5
+          end
+
+          def knows_about?(domain_name)
+            dom = @knowledge_domains.values.find { |d| d.name == domain_name }
+            return false unless dom
+
+            dom.confidence >= 0.5
+          end
+
+          def overall_confidence
+            return DEFAULT_COMPETENCE if @capabilities.empty?
+
+            total = @capabilities.values.sum(&:competence)
+            total / @capabilities.size.to_f
+          end
+
+          def to_h
+            {
+              capability_count:       @capabilities.size,
+              knowledge_domain_count: @knowledge_domains.size,
+              overall_confidence:     overall_confidence.round(4),
+              strength_count:         strengths.size,
+              weakness_count:         weaknesses.size,
+              blind_spot_count:       blind_spots.size,
+              knowledge_gap_count:    knowledge_gaps.size,
+              prediction_count:       @predictions.size,
+              history_size:           @history.size
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module SelfModel
+      module Runners
+        module SelfModel
+          include Helpers::Constants
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def add_self_capability(name:, domain: :general, competence: DEFAULT_COMPETENCE, **)
+            cap = model.add_capability(name: name, domain: domain, competence: competence)
+            return { success: false, reason: :limit_reached } unless cap
+
+            { success: true, capability_id: cap.id, competence: cap.competence.round(4), state: cap.state }
+          end
+
+          def add_self_knowledge(name:, depth: 0.0, breadth: 0.0, **)
+            dom = model.add_knowledge_domain(name: name, depth: depth, breadth: breadth)
+            return { success: false, reason: :limit_reached } unless dom
+
+            { success: true, domain_id: dom.id, depth: dom.depth.round(4), breadth: dom.breadth.round(4),
+              state: dom.state }
+          end
+
+          def predict_own_success(capability_id:, **)
+            prediction = model.predict_success(capability_id: capability_id)
+            return { success: false, reason: :not_found } unless prediction
+
+            { success: true }.merge(prediction)
+          end
+
+          def record_self_outcome(capability_id:, predicted:, actual:, **)
+            event = model.record_outcome(capability_id: capability_id, predicted: predicted, actual: actual)
+            return { success: false, reason: :not_found } unless event
+
+            cap = model.capabilities[capability_id]
+            { success: true, capability_id: capability_id, competence: cap.competence.round(4),
+              calibration_error: cap.calibration_error.round(4) }
+          end
+
+          def self_introspection(**)
+            { success: true }.merge(model.introspect)
+          end
+
+          def self_strengths(**)
+            strengths = model.strengths.map(&:to_h)
+            { success: true, strengths: strengths, count: strengths.size }
+          end
+
+          def self_weaknesses(**)
+            weaknesses = model.weaknesses.map(&:to_h)
+            { success: true, weaknesses: weaknesses, count: weaknesses.size }
+          end
+
+          def self_blind_spots(**)
+            blind_spots = model.blind_spots.map(&:to_h)
+            { success: true, blind_spots: blind_spots, count: blind_spots.size }
+          end
+
+          def self_calibration_report(**)
+            { success: true }.merge(model.calibration_report)
+          end
+
+          def self_model_stats(**)
+            { success: true }.merge(model.to_h)
+          end
+
+          private
+
+          def model
+            @model ||= Helpers::SelfModel.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-self-model
+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: Predictive self-model for LegionIO — capability tracking, knowledge domain
+  modeling, calibration, and metacognitive introspection
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/self_model/client.rb
+- lib/legion/extensions/self_model/helpers/capability.rb
+- lib/legion/extensions/self_model/helpers/constants.rb
+- lib/legion/extensions/self_model/helpers/knowledge_domain.rb
+- lib/legion/extensions/self_model/helpers/self_model.rb
+- lib/legion/extensions/self_model/runners/self_model.rb
+- lib/legion/extensions/self_model/version.rb
+homepage: https://github.com/LegionIO/lex-self-model
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-self-model
+  source_code_uri: https://github.com/LegionIO/lex-self-model
+  documentation_uri: https://github.com/LegionIO/lex-self-model/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-self-model/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-self-model/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: Metacognitive self-model for LegionIO
+test_files: []