lex-reflection 0.1.1

data/spec/legion/extensions/reflection/helpers/reflection_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Reflection::Helpers::ReflectionFactory do
+  describe '.new_reflection' do
+    it 'creates a reflection with required fields' do
+      r = described_class.new_reflection(
+        category:    :prediction_calibration,
+        observation: 'Low accuracy detected'
+      )
+      expect(r[:reflection_id]).to be_a(String)
+      expect(r[:category]).to eq(:prediction_calibration)
+      expect(r[:observation]).to eq('Low accuracy detected')
+      expect(r[:severity]).to eq(:notable)
+      expect(r[:recommendation]).to eq(:no_action)
+      expect(r[:acted_on]).to be false
+    end
+
+    it 'raises on invalid category' do
+      expect { described_class.new_reflection(category: :invalid, observation: 'x') }
+        .to raise_error(ArgumentError, /invalid category/)
+    end
+
+    it 'raises on invalid severity' do
+      expect { described_class.new_reflection(category: :trust_drift, observation: 'x', severity: :invalid) }
+        .to raise_error(ArgumentError, /invalid severity/)
+    end
+  end
+
+  describe '.severity_weight' do
+    it 'returns 1.0 for critical' do
+      expect(described_class.severity_weight(:critical)).to eq(1.0)
+    end
+
+    it 'returns lower weights for lower severities' do
+      expect(described_class.severity_weight(:trivial)).to be < described_class.severity_weight(:notable)
+      expect(described_class.severity_weight(:notable)).to be < described_class.severity_weight(:significant)
+    end
+  end
+
+  describe '.severity_for_drop' do
+    it 'returns critical for large drops' do
+      expect(described_class.severity_for_drop(0.5)).to eq(:critical)
+    end
+
+    it 'returns trivial for small drops' do
+      expect(described_class.severity_for_drop(0.05)).to eq(:trivial)
+    end
+  end
+end

data/spec/legion/extensions/reflection/helpers/reflection_store_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Reflection::Helpers::ReflectionStore do
+  subject(:store) { described_class.new }
+
+  let(:reflection) do
+    Legion::Extensions::Reflection::Helpers::ReflectionFactory.new_reflection(
+      category:       :prediction_calibration,
+      observation:    'Low accuracy',
+      severity:       :significant,
+      recommendation: :increase_curiosity
+    )
+  end
+
+  describe '#store and #get' do
+    it 'stores and retrieves a reflection' do
+      store.store(reflection)
+      expect(store.get(reflection[:reflection_id])).to eq(reflection)
+    end
+
+    it 'increments total_generated' do
+      store.store(reflection)
+      expect(store.total_generated).to eq(1)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns reflections in reverse chronological order' do
+      r1 = Legion::Extensions::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :trust_drift, observation: 'first'
+      )
+      store.store(r1)
+      r2 = Legion::Extensions::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :memory_health, observation: 'second'
+      )
+      store.store(r2)
+
+      recent = store.recent(limit: 2)
+      expect(recent.first[:observation]).to eq('second')
+    end
+  end
+
+  describe '#by_category' do
+    it 'filters by category' do
+      store.store(reflection)
+      other = Legion::Extensions::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :trust_drift, observation: 'other'
+      )
+      store.store(other)
+
+      results = store.by_category(:prediction_calibration)
+      expect(results.size).to eq(1)
+      expect(results.first[:category]).to eq(:prediction_calibration)
+    end
+  end
+
+  describe '#mark_acted_on' do
+    it 'marks a reflection as acted on' do
+      store.store(reflection)
+      store.mark_acted_on(reflection[:reflection_id])
+      expect(store.get(reflection[:reflection_id])[:acted_on]).to be true
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.mark_acted_on('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#cognitive_health' do
+    it 'returns 1.0 when all scores are at default' do
+      expect(store.cognitive_health).to eq(1.0)
+    end
+
+    it 'decreases when category scores drop' do
+      store.update_category_score(:prediction_calibration, 0.3)
+      expect(store.cognitive_health).to be < 1.0
+    end
+  end
+
+  describe '#severity_counts' do
+    it 'counts reflections by severity' do
+      store.store(reflection)
+      critical = Legion::Extensions::Reflection::Helpers::ReflectionFactory.new_reflection(
+        category: :cognitive_load, observation: 'overload', severity: :critical
+      )
+      store.store(critical)
+
+      counts = store.severity_counts
+      expect(counts[:significant]).to eq(1)
+      expect(counts[:critical]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/reflection/runners/reflection_spec.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Reflection::Runners::Reflection do
+  let(:client) { Legion::Extensions::Reflection::Client.new }
+
+  describe '#reflect' do
+    it 'returns results with no tick data' do
+      result = client.reflect(tick_results: {})
+      expect(result[:reflections_generated]).to eq(0)
+      expect(result[:cognitive_health]).to eq(1.0)
+    end
+
+    it 'generates reflections from problematic tick results' do
+      result = client.reflect(tick_results: {
+                                prediction_engine:    { confidence: 0.2 },
+                                emotional_evaluation: { stability: 0.1 },
+                                memory_consolidation: { pruned: 90, total: 100 }
+                              })
+      expect(result[:reflections_generated]).to be >= 2
+      expect(result[:cognitive_health]).to be < 1.0
+    end
+
+    it 'accumulates metric history over multiple calls' do
+      5.times { client.reflect(tick_results: { prediction_engine: { confidence: 0.9 } }) }
+      5.times { client.reflect(tick_results: { prediction_engine: { confidence: 0.4 } }) }
+
+      # Should detect trend
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.3 } })
+      predictions = result[:new_reflections].select { |r| r[:category] == :prediction_calibration }
+      expect(predictions).not_to be_empty
+    end
+  end
+
+  describe '#cognitive_health' do
+    it 'returns full health with no data' do
+      result = client.cognitive_health
+      expect(result[:health]).to eq(1.0)
+    end
+
+    it 'degrades with bad tick results' do
+      client.reflect(tick_results: {
+                       prediction_engine:    { confidence: 0.2 },
+                       emotional_evaluation: { stability: 0.1 }
+                     })
+      result = client.cognitive_health
+      expect(result[:health]).to be < 1.0
+      expect(result[:category_scores][:prediction_calibration]).to eq(0.2)
+    end
+  end
+
+  describe '#recent_reflections' do
+    it 'returns recent reflections' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      result = client.recent_reflections(limit: 5)
+      expect(result[:reflections]).not_to be_empty
+    end
+  end
+
+  describe '#reflections_by_category' do
+    it 'filters by category' do
+      client.reflect(tick_results: {
+                       prediction_engine:    { confidence: 0.1 },
+                       emotional_evaluation: { stability: 0.1 }
+                     })
+      result = client.reflections_by_category(category: :emotional_stability)
+      result[:reflections].each do |r|
+        expect(r[:category]).to eq(:emotional_stability)
+      end
+    end
+  end
+
+  describe '#adapt' do
+    it 'marks a reflection as acted upon' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      reflections = client.recent_reflections[:reflections]
+      id = reflections.first[:reflection_id]
+
+      result = client.adapt(reflection_id: id)
+      expect(result[:adapted]).to be true
+    end
+
+    it 'returns error for unknown id' do
+      result = client.adapt(reflection_id: 'nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#reflection_stats' do
+    it 'returns comprehensive stats' do
+      client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      stats = client.reflection_stats
+      expect(stats[:total_generated]).to be >= 1
+      expect(stats[:cognitive_health]).to be_a(Float)
+      expect(stats[:severity_counts]).to be_a(Hash)
+    end
+  end
+
+  describe '#reflect with LLM enhancement' do
+    let(:fake_chat) { double }
+    let(:llm_observation) { 'My prediction confidence is critically low at 10%, strongly correlated with declining memory health.' }
+    let(:fake_response) do
+      double(content: <<~TEXT)
+        EMOTION: Emotional state appears stable this tick.
+        PREDICTION: #{llm_observation}
+        MEMORY: Memory health is nominal.
+        TRUST: Trust scores unchanged.
+        CURIOSITY: Curiosity levels normal.
+        IDENTITY: Identity entropy within bounds.
+      TEXT
+    end
+
+    before do
+      stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_response)
+    end
+
+    it 'replaces mechanical observation text with LLM-generated text' do
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      prediction_reflection = result[:new_reflections].find { |r| r[:category] == :prediction_calibration }
+      expect(prediction_reflection).not_to be_nil
+      expect(prediction_reflection[:observation]).to include('critically low')
+    end
+
+    it 'does not change recommendation symbols when using LLM' do
+      result = client.reflect(tick_results: { prediction_engine: { confidence: 0.1 } })
+      prediction_reflection = result[:new_reflections].find { |r| r[:category] == :prediction_calibration }
+      expect(prediction_reflection).not_to be_nil
+      expect(prediction_reflection[:recommendation]).to eq(:increase_curiosity)
+    end
+
+    it 'falls back to mechanical observations when LLM returns nil' do
+      allow(fake_chat).to receive(:ask).and_return(double(content: nil))
+
+      result = client.reflect(tick_results: {
+                                prediction_engine:    { confidence: 0.2 },
+                                emotional_evaluation: { stability: 0.1 }
+                              })
+      expect(result[:reflections_generated]).to be >= 1
+      # Mechanical observations still present (LLM returned nil)
+      result[:new_reflections].each do |r|
+        expect(r[:observation]).to be_a(String)
+        expect(r[:observation]).not_to be_empty
+      end
+    end
+  end
+
+  describe '#reflect_on_dream' do
+    context 'without LLM' do
+      it 'uses mechanical fallback for empty dream results' do
+        result = client.reflect_on_dream(dream_results: {})
+        expect(result[:reflection]).to eq('Dream cycle completed.')
+        expect(result[:source]).to eq(:mechanical)
+      end
+
+      it 'builds mechanical reflection from dream phase data' do
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit:             { decayed: 3, unresolved_count: 2 },
+                                           contradiction_resolution: { detected: 1, resolved: 1 },
+                                           agenda_formation:         { agenda_items: 3 }
+                                         })
+        expect(result[:reflection]).to include('Memory audit')
+        expect(result[:source]).to eq(:mechanical)
+      end
+    end
+
+    context 'with LLM available' do
+      let(:fake_chat) { double }
+      let(:fake_response) do
+        double(content: <<~TEXT)
+          REFLECTION: The dream cycle consolidated 3 traces and resolved a contradiction in the identity domain. I notice a strengthening of procedural memory pathways.
+        TEXT
+      end
+
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+        allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+        allow(fake_chat).to receive(:with_instructions)
+        allow(fake_chat).to receive(:ask).and_return(fake_response)
+      end
+
+      it 'uses LLM-generated reflection when available' do
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit:             { decayed: 3, unresolved_count: 2 },
+                                           contradiction_resolution: { detected: 1, resolved: 1 }
+                                         })
+        expect(result[:reflection]).to include('consolidated 3 traces')
+        expect(result[:source]).to eq(:llm)
+      end
+
+      it 'falls back to mechanical when LLM returns nil' do
+        allow(fake_chat).to receive(:ask).and_return(double(content: nil))
+
+        result = client.reflect_on_dream(dream_results: {
+                                           memory_audit: { decayed: 1, unresolved_count: 0 }
+                                         })
+        expect(result[:source]).to eq(:mechanical)
+        expect(result[:reflection]).to be_a(String)
+        expect(result[:reflection]).not_to be_empty
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+end
+
+require 'legion/extensions/reflection'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: lex-reflection
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+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: Metacognitive self-monitoring for brain-modeled agentic AI
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lex-reflection.gemspec
+- lib/legion/extensions/reflection.rb
+- lib/legion/extensions/reflection/client.rb
+- lib/legion/extensions/reflection/helpers/constants.rb
+- lib/legion/extensions/reflection/helpers/llm_enhancer.rb
+- lib/legion/extensions/reflection/helpers/monitors.rb
+- lib/legion/extensions/reflection/helpers/reflection.rb
+- lib/legion/extensions/reflection/helpers/reflection_store.rb
+- lib/legion/extensions/reflection/runners/reflection.rb
+- lib/legion/extensions/reflection/version.rb
+- spec/legion/extensions/reflection/client_spec.rb
+- spec/legion/extensions/reflection/helpers/llm_enhancer_spec.rb
+- spec/legion/extensions/reflection/helpers/monitors_spec.rb
+- spec/legion/extensions/reflection/helpers/reflection_spec.rb
+- spec/legion/extensions/reflection/helpers/reflection_store_spec.rb
+- spec/legion/extensions/reflection/runners/reflection_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-reflection
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-reflection
+  source_code_uri: https://github.com/LegionIO/lex-reflection
+  documentation_uri: https://github.com/LegionIO/lex-reflection
+  changelog_uri: https://github.com/LegionIO/lex-reflection
+  bug_tracker_uri: https://github.com/LegionIO/lex-reflection/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: LEX Reflection
+test_files: []