lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/hebbian/helpers/assembly_network_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Hebbian::Helpers::AssemblyNetwork do
+  subject(:network) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Learning::Hebbian::Helpers::Constants }
+
+  describe '#add_unit' do
+    it 'adds a unit' do
+      unit = network.add_unit(id: :a)
+      expect(unit.id).to eq(:a)
+      expect(network.unit_count).to eq(1)
+    end
+
+    it 'returns existing unit on duplicate' do
+      first = network.add_unit(id: :a)
+      second = network.add_unit(id: :a)
+      expect(first).to equal(second)
+    end
+
+    it 'limits units' do
+      constants::MAX_UNITS.times { |i| network.add_unit(id: :"u_#{i}") }
+      expect(network.add_unit(id: :overflow)).to be_nil
+    end
+  end
+
+  describe '#activate_unit' do
+    it 'activates a unit' do
+      unit = network.activate_unit(id: :a, level: 0.8)
+      expect(unit.activation_level).to eq(0.8)
+      expect(unit.active?).to be true
+    end
+
+    it 'auto-creates unit if missing' do
+      network.activate_unit(id: :new_unit)
+      expect(network.unit_count).to eq(1)
+    end
+
+    it 'records activation history' do
+      network.activate_unit(id: :a)
+      expect(network.activation_history.size).to eq(1)
+    end
+  end
+
+  describe '#co_activate' do
+    it 'activates multiple units' do
+      results = network.co_activate(ids: %i[a b c])
+      expect(results.size).to eq(3)
+      expect(network.unit_count).to eq(3)
+    end
+
+    it 'strengthens connections between co-activated units' do
+      network.co_activate(ids: %i[a b])
+      expect(network.query_weight(from: :a, to: :b)).to be > 0
+      expect(network.query_weight(from: :b, to: :a)).to be > 0
+    end
+
+    it 'repeated co-activation increases weight' do
+      network.co_activate(ids: %i[a b])
+      first_weight = network.query_weight(from: :a, to: :b)
+      network.co_activate(ids: %i[a b])
+      expect(network.query_weight(from: :a, to: :b)).to be > first_weight
+    end
+  end
+
+  describe '#query_weight' do
+    it 'returns 0 for unconnected units' do
+      expect(network.query_weight(from: :a, to: :b)).to eq(0.0)
+    end
+  end
+
+  describe 'assembly detection' do
+    it 'forms assembly from repeated co-activation of 3+ units' do
+      10.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      expect(network.assembly_count).to be >= 1
+    end
+
+    it 'consolidates existing assembly on repeated co-activation' do
+      10.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      assembly = network.assemblies.values.first
+      first_coherence = assembly.coherence
+      5.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      expect(assembly.coherence).to be >= first_coherence
+    end
+  end
+
+  describe '#assemblies_containing' do
+    it 'finds assemblies containing a unit' do
+      10.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      asms = network.assemblies_containing(unit_id: :a)
+      expect(asms).not_to be_empty
+      expect(asms.first.includes?(:a)).to be true
+    end
+  end
+
+  describe '#pattern_complete' do
+    it 'completes partial pattern from assembly' do
+      10.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      result = network.pattern_complete(partial_ids: %i[a b])
+      expect(result).not_to be_nil
+      expect(result[:predicted]).to include(:c)
+    end
+
+    it 'returns nil when no matching assembly' do
+      expect(network.pattern_complete(partial_ids: [:unknown])).to be_nil
+    end
+  end
+
+  describe '#strongest_units' do
+    it 'returns most activated units' do
+      5.times { network.activate_unit(id: :frequent, level: 1.0) }
+      network.activate_unit(id: :rare, level: 1.0)
+      top = network.strongest_units(1)
+      expect(top.first[:id]).to eq(:frequent)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays unit weights' do
+      network.co_activate(ids: %i[a b])
+      before = network.query_weight(from: :a, to: :b)
+      network.decay_all
+      expect(network.query_weight(from: :a, to: :b)).to be < before
+    end
+
+    it 'removes dissolving assemblies' do
+      10.times { network.co_activate(ids: %i[a b c], level: 1.0) }
+      network.assemblies.each_value { |a| a.coherence = 0.1 }
+      network.decay_all
+      expect(network.assembly_count).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats' do
+      network.co_activate(ids: %i[a b c])
+      h = network.to_h
+      expect(h).to include(:units, :assemblies, :total_connections, :history_size, :active_units)
+      expect(h[:units]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/hebbian/helpers/assembly_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Hebbian::Helpers::Assembly do
+  subject(:assembly) { described_class.new(id: :asm_one, member_ids: %i[a b c]) }
+
+  let(:constants) { Legion::Extensions::Agentic::Learning::Hebbian::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(assembly.id).to eq(:asm_one)
+      expect(assembly.member_ids).to eq(%i[a b c])
+      expect(assembly.coherence).to eq(0.5)
+    end
+
+    it 'deduplicates members' do
+      asm = described_class.new(id: :dup, member_ids: %i[a a b])
+      expect(asm.member_ids).to eq(%i[a b])
+    end
+  end
+
+  describe '#activate' do
+    it 'increments activation count' do
+      assembly.activate
+      expect(assembly.activation_count).to eq(1)
+      expect(assembly.last_activated).to be_a(Time)
+    end
+  end
+
+  describe '#consolidate' do
+    it 'increases coherence' do
+      before = assembly.coherence
+      assembly.consolidate
+      expect(assembly.coherence).to be > before
+    end
+  end
+
+  describe '#decay' do
+    it 'decreases coherence' do
+      before = assembly.coherence
+      assembly.decay
+      expect(assembly.coherence).to be < before
+    end
+  end
+
+  describe '#dissolving?' do
+    it 'returns false when coherent' do
+      expect(assembly.dissolving?).to be false
+    end
+
+    it 'returns true when coherence drops below threshold' do
+      assembly.coherence = 0.1
+      expect(assembly.dissolving?).to be true
+    end
+  end
+
+  describe '#includes?' do
+    it 'returns true for members' do
+      expect(assembly.includes?(:a)).to be true
+    end
+
+    it 'returns false for non-members' do
+      expect(assembly.includes?(:z)).to be false
+    end
+  end
+
+  describe '#state' do
+    it 'returns :dormant for stable inactive assembly' do
+      expect(assembly.state).to eq(:dormant)
+    end
+
+    it 'returns :active when recently activated' do
+      assembly.activate
+      expect(assembly.state).to eq(:active)
+    end
+
+    it 'returns :dissolving when coherence is low' do
+      assembly.coherence = 0.1
+      expect(assembly.state).to eq(:dissolving)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = assembly.to_h
+      expect(h).to include(:id, :members, :member_count, :coherence, :state, :state_label, :activation_count)
+      expect(h[:member_count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/hebbian/helpers/unit_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Hebbian::Helpers::Unit do
+  subject(:unit) { described_class.new(id: :neuron_a, domain: :cognition) }
+
+  let(:constants) { Legion::Extensions::Agentic::Learning::Hebbian::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(unit.id).to eq(:neuron_a)
+      expect(unit.domain).to eq(:cognition)
+      expect(unit.activation_level).to eq(0.0)
+      expect(unit.activation_count).to eq(0)
+    end
+  end
+
+  describe '#activate' do
+    it 'sets activation level and increments count' do
+      unit.activate(level: 0.8)
+      expect(unit.activation_level).to eq(0.8)
+      expect(unit.activation_count).to eq(1)
+      expect(unit.last_activated).to be_a(Time)
+    end
+
+    it 'clamps activation' do
+      unit.activate(level: 1.5)
+      expect(unit.activation_level).to eq(1.0)
+    end
+  end
+
+  describe '#active?' do
+    it 'returns true when above threshold' do
+      unit.activate(level: 0.5)
+      expect(unit.active?).to be true
+    end
+
+    it 'returns false when below threshold' do
+      expect(unit.active?).to be false
+    end
+  end
+
+  describe '#connect' do
+    it 'creates a connection' do
+      unit.connect(:neuron_b, weight: 0.3)
+      expect(unit.weight_to(:neuron_b)).to eq(0.3)
+    end
+
+    it 'clamps weight' do
+      unit.connect(:neuron_b, weight: 2.0)
+      expect(unit.weight_to(:neuron_b)).to eq(1.0)
+    end
+
+    it 'limits connections' do
+      constants::MAX_CONNECTIONS_PER_UNIT.times { |i| unit.connect(:"n_#{i}") }
+      unit.connect(:overflow)
+      expect(unit.connection_count).to eq(constants::MAX_CONNECTIONS_PER_UNIT)
+    end
+  end
+
+  describe '#strengthen' do
+    it 'increases weight' do
+      unit.connect(:neuron_b, weight: 0.3)
+      unit.strengthen(:neuron_b)
+      expect(unit.weight_to(:neuron_b)).to eq(0.3 + constants::LEARNING_RATE)
+    end
+
+    it 'caps at MAX_WEIGHT' do
+      unit.connect(:neuron_b, weight: 0.98)
+      unit.strengthen(:neuron_b)
+      expect(unit.weight_to(:neuron_b)).to eq(constants::MAX_WEIGHT)
+    end
+  end
+
+  describe '#weaken' do
+    it 'decreases weight' do
+      unit.connect(:neuron_b, weight: 0.5)
+      unit.weaken(:neuron_b)
+      expect(unit.weight_to(:neuron_b)).to eq(0.5 - constants::COMPETITION_FACTOR)
+    end
+  end
+
+  describe '#decay_weights' do
+    it 'decays all connections' do
+      unit.connect(:neuron_b, weight: 0.5)
+      unit.decay_weights
+      expect(unit.weight_to(:neuron_b)).to eq(0.5 - constants::WEIGHT_DECAY)
+    end
+
+    it 'prunes connections at floor' do
+      unit.connect(:neuron_b, weight: constants::WEIGHT_FLOOR + 0.001)
+      unit.decay_weights
+      expect(unit.connection_count).to eq(0)
+    end
+  end
+
+  describe '#weight_label' do
+    it 'returns label for weight' do
+      unit.connect(:neuron_b, weight: 0.9)
+      expect(unit.weight_label(:neuron_b)).to eq(:bonded)
+    end
+  end
+
+  describe '#strongest_connections' do
+    it 'returns top connections sorted by weight' do
+      unit.connect(:a, weight: 0.3)
+      unit.connect(:b, weight: 0.8)
+      unit.connect(:c, weight: 0.5)
+      top = unit.strongest_connections(2)
+      expect(top.keys).to eq(%i[b c])
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash' do
+      h = unit.to_h
+      expect(h).to include(:id, :domain, :activation_level, :active, :connections, :activation_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/hebbian/runners/hebbian_assembly_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Hebbian::Runners::HebbianAssembly do
+  let(:client) { Legion::Extensions::Agentic::Learning::Hebbian::Client.new }
+
+  describe '#activate_unit' do
+    it 'activates a unit' do
+      result = client.activate_unit(id: :a, level: 0.8, domain: :cognition)
+      expect(result[:success]).to be true
+      expect(result[:unit][:id]).to eq(:a)
+      expect(result[:unit][:active]).to be true
+    end
+  end
+
+  describe '#co_activate_units' do
+    it 'co-activates multiple units' do
+      result = client.co_activate_units(ids: %i[a b c])
+      expect(result[:success]).to be true
+      expect(result[:units].size).to eq(3)
+    end
+  end
+
+  describe '#query_weight' do
+    it 'returns weight between units' do
+      client.co_activate_units(ids: %i[a b])
+      result = client.query_weight(from: :a, to: :b)
+      expect(result[:success]).to be true
+      expect(result[:weight]).to be > 0
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns 0 for unconnected' do
+      result = client.query_weight(from: :x, to: :y)
+      expect(result[:weight]).to eq(0.0)
+    end
+  end
+
+  describe '#list_assemblies' do
+    it 'lists assemblies' do
+      10.times { client.co_activate_units(ids: %i[a b c]) }
+      result = client.list_assemblies
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#query_assembly' do
+    it 'queries a specific assembly' do
+      10.times { client.co_activate_units(ids: %i[a b c]) }
+      all = client.list_assemblies
+      id = all[:assemblies].first[:id]
+      result = client.query_assembly(id: id)
+      expect(result[:success]).to be true
+      expect(result[:assembly][:members]).to include(:a, :b, :c)
+    end
+
+    it 'returns not_found for unknown' do
+      result = client.query_assembly(id: :nonexistent)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#pattern_complete' do
+    it 'completes partial pattern' do
+      10.times { client.co_activate_units(ids: %i[a b c]) }
+      result = client.pattern_complete(partial_ids: %i[a b])
+      expect(result[:success]).to be true
+      expect(result[:completion][:predicted]).to include(:c)
+    end
+
+    it 'returns failure when no match' do
+      result = client.pattern_complete(partial_ids: [:unknown])
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#strongest_units' do
+    it 'returns most activated units' do
+      5.times { client.activate_unit(id: :freq) }
+      client.activate_unit(id: :rare)
+      result = client.strongest_units(limit: 1)
+      expect(result[:units].first[:id]).to eq(:freq)
+    end
+  end
+
+  describe '#assemblies_for' do
+    it 'finds assemblies for a unit' do
+      10.times { client.co_activate_units(ids: %i[a b c]) }
+      result = client.assemblies_for(unit_id: :a)
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#update_hebbian' do
+    it 'runs decay tick' do
+      result = client.update_hebbian
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#hebbian_stats' do
+    it 'returns stats' do
+      result = client.hebbian_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:units, :assemblies, :total_connections)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/learning_rate/client_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::LearningRate::Client do
+  let(:client) { described_class.new }
+
+  it 'can be instantiated' do
+    expect(client).to be_a(described_class)
+  end
+
+  it 'includes all runner methods' do
+    expect(client).to respond_to(:record_prediction)
+    expect(client).to respond_to(:record_surprise)
+    expect(client).to respond_to(:record_error)
+    expect(client).to respond_to(:current_rate)
+    expect(client).to respond_to(:fastest_domains)
+    expect(client).to respond_to(:slowest_domains)
+    expect(client).to respond_to(:update_learning_rate)
+    expect(client).to respond_to(:learning_rate_stats)
+  end
+
+  it 'exposes the rate model' do
+    expect(client.rate_model).to be_a(Legion::Extensions::Agentic::Learning::LearningRate::Helpers::RateModel)
+  end
+
+  describe 'full lifecycle' do
+    it 'adapts learning rate based on prediction outcomes' do
+      # Initial state
+      initial = client.current_rate(domain: :coding)[:rate]
+
+      # Agent makes wrong predictions - rate increases
+      5.times { client.record_prediction(domain: :coding, correct: false) }
+      after_errors = client.current_rate(domain: :coding)[:rate]
+      expect(after_errors).to be > initial
+
+      # Something surprising happens - rate boosts further
+      client.record_surprise(domain: :coding, magnitude: 0.8)
+      after_surprise = client.current_rate(domain: :coding)[:rate]
+      expect(after_surprise).to be > after_errors
+
+      # Agent starts getting things right - rate decreases
+      10.times { client.record_prediction(domain: :coding, correct: true) }
+      after_learning = client.current_rate(domain: :coding)[:rate]
+      expect(after_learning).to be < after_surprise
+
+      # Tick decay
+      client.update_learning_rate
+      stats = client.learning_rate_stats[:stats]
+      expect(stats[:domain_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/learning_rate/helpers/constants_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::LearningRate::Helpers::Constants do
+  it 'defines DEFAULT_RATE' do
+    expect(described_class::DEFAULT_RATE).to eq(0.15)
+  end
+
+  it 'defines MIN_RATE and MAX_RATE' do
+    expect(described_class::MIN_RATE).to eq(0.01)
+    expect(described_class::MAX_RATE).to eq(0.5)
+  end
+
+  it 'defines ACCURACY_WINDOW' do
+    expect(described_class::ACCURACY_WINDOW).to eq(20)
+  end
+
+  it 'defines RATE_LABELS covering 0.0..1.0' do
+    labels = described_class::RATE_LABELS
+    [0.01, 0.05, 0.1, 0.2, 0.35, 0.5].each do |val|
+      matched = labels.any? { |range, _| range.cover?(val) }
+      expect(matched).to be(true), "Expected #{val} to match a label range"
+    end
+  end
+
+  it 'has all expected RATE_LABELS values' do
+    values = described_class::RATE_LABELS.values
+    expect(values).to contain_exactly(:fast_learning, :moderate_learning, :slow_learning, :consolidated)
+  end
+end

data/spec/legion/extensions/agentic/learning/learning_rate/helpers/rate_model_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::LearningRate::Helpers::RateModel do
+  let(:model) { described_class.new }
+  let(:constants) { Legion::Extensions::Agentic::Learning::LearningRate::Helpers::Constants }
+
+  describe '#rate_for' do
+    it 'returns default rate for unknown domain' do
+      expect(model.rate_for(:new_domain)).to eq(constants::DEFAULT_RATE)
+    end
+
+    it 'returns tracked rate for known domain' do
+      model.record_prediction(domain: :math, correct: false)
+      expect(model.rate_for(:math)).not_to eq(constants::DEFAULT_RATE)
+    end
+  end
+
+  describe '#record_prediction' do
+    it 'increases rate on incorrect prediction' do
+      model.record_prediction(domain: :math, correct: false)
+      expect(model.rate_for(:math)).to be > constants::DEFAULT_RATE
+    end
+
+    it 'decreases rate on correct prediction' do
+      model.record_prediction(domain: :math, correct: true)
+      expect(model.rate_for(:math)).to be < constants::DEFAULT_RATE
+    end
+
+    it 'records accuracy history' do
+      model.record_prediction(domain: :math, correct: true)
+      model.record_prediction(domain: :math, correct: false)
+      expect(model.accuracy_for(:math)).to eq(0.5)
+    end
+
+    it 'caps accuracy buffer at ACCURACY_WINDOW' do
+      (constants::ACCURACY_WINDOW + 5).times { model.record_prediction(domain: :math, correct: true) }
+      buffer = model.accuracy_buffers[:math]
+      expect(buffer.size).to eq(constants::ACCURACY_WINDOW)
+    end
+  end
+
+  describe '#record_surprise' do
+    it 'increases rate proportional to magnitude' do
+      initial = constants::DEFAULT_RATE
+      model.record_surprise(domain: :math, magnitude: 0.8)
+      expect(model.rate_for(:math)).to be > initial
+    end
+
+    it 'records in history' do
+      model.record_surprise(domain: :math, magnitude: 0.5)
+      expect(model.rate_history.size).to eq(1)
+      expect(model.rate_history.last[:event]).to eq(:surprise)
+    end
+  end
+
+  describe '#record_error' do
+    it 'increases rate proportional to magnitude' do
+      initial = constants::DEFAULT_RATE
+      model.record_error(domain: :math, magnitude: 0.7)
+      expect(model.rate_for(:math)).to be > initial
+    end
+  end
+
+  describe '#accuracy_for' do
+    it 'returns 0.0 for unknown domain' do
+      expect(model.accuracy_for(:unknown)).to eq(0.0)
+    end
+
+    it 'computes rolling accuracy' do
+      3.times { model.record_prediction(domain: :test, correct: true) }
+      model.record_prediction(domain: :test, correct: false)
+      expect(model.accuracy_for(:test)).to eq(0.75)
+    end
+  end
+
+  describe '#decay' do
+    it 'moves rates toward default' do
+      model.record_prediction(domain: :math, correct: false)
+      raised = model.rate_for(:math)
+      model.decay
+      expect(model.rate_for(:math)).to be < raised
+    end
+  end
+
+  describe '#label_for' do
+    it 'returns a symbol' do
+      expect(model.label_for(:math)).to be_a(Symbol)
+    end
+
+    it 'returns :moderate_learning for default rate' do
+      expect(model.label_for(:unknown)).to eq(:moderate_learning)
+    end
+  end
+
+  describe '#fastest_domains' do
+    it 'returns domains sorted by rate descending' do
+      model.record_prediction(domain: :fast, correct: false)
+      model.record_prediction(domain: :fast, correct: false)
+      model.record_prediction(domain: :slow, correct: true)
+      fastest = model.fastest_domains(2)
+      expect(fastest.keys.first).to eq(:fast)
+    end
+  end
+
+  describe '#slowest_domains' do
+    it 'returns domains sorted by rate ascending' do
+      model.record_prediction(domain: :fast, correct: false)
+      model.record_prediction(domain: :slow, correct: true)
+      slowest = model.slowest_domains(2)
+      expect(slowest.keys.first).to eq(:slow)
+    end
+  end
+
+  describe '#overall_rate' do
+    it 'returns default when no domains tracked' do
+      expect(model.overall_rate).to eq(constants::DEFAULT_RATE)
+    end
+
+    it 'averages all domain rates' do
+      model.record_prediction(domain: :a, correct: true)
+      model.record_prediction(domain: :b, correct: false)
+      overall = model.overall_rate
+      expect(overall).to be_a(Float)
+    end
+  end
+
+  describe '#domain_count' do
+    it 'counts tracked domains' do
+      model.record_prediction(domain: :a, correct: true)
+      model.record_prediction(domain: :b, correct: true)
+      expect(model.domain_count).to eq(2)
+    end
+  end
+
+  describe 'domain trimming' do
+    it 'caps at MAX_DOMAINS' do
+      (constants::MAX_DOMAINS + 5).times { |i| model.record_prediction(domain: :"d_#{i}", correct: true) }
+      expect(model.domain_count).to eq(constants::MAX_DOMAINS)
+    end
+  end
+
+  describe '#to_h' do
+    it 'contains expected keys' do
+      h = model.to_h
+      expect(h).to have_key(:domain_count)
+      expect(h).to have_key(:overall_rate)
+      expect(h).to have_key(:rates)
+      expect(h).to have_key(:history_size)
+    end
+  end
+end