lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/fermentation/helpers/fermentation_engine_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Fermentation::Helpers::FermentationEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_substrate' do
+    it 'creates and returns a substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      expect(sub).to be_a(Legion::Extensions::Agentic::Learning::Fermentation::Helpers::Substrate)
+    end
+
+    it 'adds substrate to a batch' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      report = engine.fermentation_report
+      expect(report[:total_batches]).to eq(1)
+    end
+
+    it 'reuses batch for same domain' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.create_substrate(substrate_type: :dormant_association, domain: :cognitive)
+      expect(engine.fermentation_report[:total_batches]).to eq(1)
+    end
+
+    it 'creates separate batches per domain' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.create_substrate(substrate_type: :raw_idea, domain: :emotional)
+      expect(engine.fermentation_report[:total_batches]).to eq(2)
+    end
+  end
+
+  describe '#ferment' do
+    it 'ferments an existing substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      result = engine.ferment(substrate_id: sub.id)
+      expect(result.maturity).to be > 0.0
+    end
+
+    it 'returns nil for unknown substrate' do
+      expect(engine.ferment(substrate_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#catalyze' do
+    it 'catalyzes an existing substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.3)
+      result = engine.catalyze(substrate_id: sub.id, catalyst_type: :analogy)
+      expect(result.potency).to be > 0.3
+    end
+
+    it 'returns nil for unknown substrate' do
+      expect(engine.catalyze(substrate_id: 'x', catalyst_type: :analogy)).to be_nil
+    end
+  end
+
+  describe '#ferment_all!' do
+    it 'advances all substrates' do
+      s1 = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      s2 = engine.create_substrate(substrate_type: :raw_idea, domain: :emotional)
+      engine.ferment_all!
+      expect(s1.maturity).to be > 0.0
+      expect(s2.maturity).to be > 0.0
+    end
+  end
+
+  describe 'query methods' do
+    before do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.5)
+      engine.create_substrate(substrate_type: :dormant_association, domain: :emotional, potency: 0.3)
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.8)
+    end
+
+    it 'filters by domain' do
+      expect(engine.substrates_by_domain(domain: :cognitive).size).to eq(2)
+    end
+
+    it 'filters by type' do
+      expect(engine.substrates_by_type(type: :raw_idea).size).to eq(2)
+    end
+
+    it 'filters by stage' do
+      expect(engine.substrates_by_stage(stage: :inoculation).size).to eq(3)
+    end
+
+    it 'returns raw substrates' do
+      expect(engine.raw_substrates.size).to eq(3)
+    end
+
+    it 'returns most potent' do
+      results = engine.most_potent(limit: 2)
+      expect(results.size).to eq(2)
+      expect(results.first.potency).to be >= results.last.potency
+    end
+  end
+
+  describe 'aggregate metrics' do
+    it 'returns 0.0 overall_potency for empty engine' do
+      expect(engine.overall_potency).to eq(0.0)
+    end
+
+    it 'computes overall_potency' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.6)
+      expect(engine.overall_potency).to be > 0.0
+    end
+
+    it 'computes overall_maturity' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.ferment(substrate_id: sub.id)
+      expect(engine.overall_maturity).to be > 0.0
+    end
+
+    it 'computes yield_rate' do
+      expect(engine.yield_rate).to eq(0.0)
+    end
+
+    it 'computes stage_distribution' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      dist = engine.stage_distribution
+      expect(dist[:inoculation]).to eq(1)
+    end
+  end
+
+  describe '#fermentation_report' do
+    it 'returns comprehensive report' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.5)
+      report = engine.fermentation_report
+      expect(report).to include(:total_substrates, :total_batches, :overall_potency,
+                                :potency_label, :overall_maturity, :maturity_label,
+                                :yield_rate, :stage_distribution, :batches, :most_potent)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      h = engine.to_h
+      expect(h).to include(:total_substrates, :total_batches, :potency, :maturity, :volatility)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/fermentation/helpers/substrate_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Fermentation::Helpers::Substrate do
+  subject(:substrate) do
+    described_class.new(substrate_type: :raw_idea, domain: :cognitive, content: 'test idea')
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(substrate.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores substrate_type as symbol' do
+      expect(substrate.substrate_type).to eq(:raw_idea)
+    end
+
+    it 'stores domain as symbol' do
+      expect(substrate.domain).to eq(:cognitive)
+    end
+
+    it 'stores content' do
+      expect(substrate.content).to eq('test idea')
+    end
+
+    it 'defaults potency' do
+      expect(substrate.potency).to eq(0.3)
+    end
+
+    it 'starts at inoculation stage' do
+      expect(substrate.stage).to eq(:inoculation)
+    end
+
+    it 'starts with zero maturity' do
+      expect(substrate.maturity).to eq(0.0)
+    end
+
+    it 'starts with empty catalysts' do
+      expect(substrate.catalysts_applied).to be_empty
+    end
+
+    it 'clamps potency to valid range' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 1.5)
+      expect(s.potency).to eq(1.0)
+    end
+  end
+
+  describe '#ferment!' do
+    it 'increases maturity' do
+      substrate.ferment!
+      expect(substrate.maturity).to be > 0.0
+    end
+
+    it 'decreases volatility' do
+      initial = substrate.volatility
+      substrate.ferment!
+      expect(substrate.volatility).to be < initial
+    end
+
+    it 'advances stage with enough fermentation' do
+      5.times { substrate.ferment!(0.1) }
+      expect(substrate.stage).not_to eq(:inoculation)
+    end
+
+    it 'reaches peak stage' do
+      18.times { substrate.ferment!(0.05) }
+      expect(substrate.stage).to eq(:peak)
+    end
+
+    it 'reaches over_fermented stage' do
+      25.times { substrate.ferment!(0.05) }
+      expect(substrate.stage).to eq(:over_fermented)
+    end
+  end
+
+  describe '#catalyze!' do
+    it 'boosts potency' do
+      initial = substrate.potency
+      substrate.catalyze!(:analogy)
+      expect(substrate.potency).to be > initial
+    end
+
+    it 'records catalyst type' do
+      substrate.catalyze!(:dream_residue)
+      expect(substrate.catalysts_applied).to include(:dream_residue)
+    end
+
+    it 'slightly increases volatility' do
+      initial = substrate.volatility
+      substrate.catalyze!(:analogy)
+      expect(substrate.volatility).to be > initial
+    end
+  end
+
+  describe '#spoil!' do
+    it 'halves potency' do
+      initial = substrate.potency
+      substrate.spoil!
+      expect(substrate.potency).to be < initial
+    end
+
+    it 'sets stage to over_fermented' do
+      substrate.spoil!
+      expect(substrate.stage).to eq(:over_fermented)
+    end
+  end
+
+  describe 'predicate methods' do
+    it 'reports ripe when potency and maturity are high' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.8)
+      10.times { s.ferment!(0.06) }
+      expect(s).to be_ripe
+    end
+
+    it 'reports spoiled when potency is very low' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.05)
+      s.spoil!
+      expect(s).to be_spoiled
+    end
+
+    it 'reports raw at inoculation' do
+      expect(substrate).to be_raw
+    end
+
+    it 'reports multi_catalyzed with 3+ catalysts' do
+      substrate.catalyze!(:analogy)
+      substrate.catalyze!(:contrast)
+      substrate.catalyze!(:dream_residue)
+      expect(substrate).to be_multi_catalyzed
+    end
+  end
+
+  describe '#age' do
+    it 'returns age in minutes' do
+      expect(substrate.age).to be >= 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = substrate.to_h
+      expect(h).to include(:id, :substrate_type, :domain, :content, :potency,
+                           :maturity, :volatility, :stage, :ripe, :peak,
+                           :spoiled, :catalysts_applied, :created_at)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/habit/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Habit::Client do
+  describe '#initialize' do
+    it 'creates a default HabitStore when none provided' do
+      client = described_class.new
+      expect(client.habit_store).to be_a(Legion::Extensions::Agentic::Learning::Habit::Helpers::HabitStore)
+    end
+
+    it 'uses an injected habit_store' do
+      store  = Legion::Extensions::Agentic::Learning::Habit::Helpers::HabitStore.new
+      client = described_class.new(habit_store: store)
+      expect(client.habit_store).to be(store)
+    end
+  end
+
+  describe 'runner methods' do
+    let(:client) { described_class.new }
+
+    it 'responds to #observe_action' do
+      expect(client).to respond_to(:observe_action)
+    end
+
+    it 'responds to #suggest_habit' do
+      expect(client).to respond_to(:suggest_habit)
+    end
+
+    it 'responds to #execute_habit' do
+      expect(client).to respond_to(:execute_habit)
+    end
+
+    it 'responds to #decay_habits' do
+      expect(client).to respond_to(:decay_habits)
+    end
+
+    it 'responds to #merge_habits' do
+      expect(client).to respond_to(:merge_habits)
+    end
+
+    it 'responds to #habit_stats' do
+      expect(client).to respond_to(:habit_stats)
+    end
+
+    it 'responds to #habit_repertoire' do
+      expect(client).to respond_to(:habit_repertoire)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/habit/helpers/action_sequence_spec.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Habit::Helpers::ActionSequence do
+  let(:actions) { %i[fetch parse cache] }
+  let(:context) { { domain: :api, mood: :neutral } }
+  let(:sequence) { described_class.new(actions: actions, context: context) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(sequence.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores actions as symbols' do
+      expect(sequence.actions).to eq(%i[fetch parse cache])
+    end
+
+    it 'stores context' do
+      expect(sequence.context).to eq(context)
+    end
+
+    it 'starts with zero execution count' do
+      expect(sequence.execution_count).to eq(0)
+    end
+
+    it 'starts with zero success count' do
+      expect(sequence.success_count).to eq(0)
+    end
+
+    it 'starts with strength 0.3' do
+      expect(sequence.strength).to eq(0.3)
+    end
+
+    it 'starts at :novel maturity' do
+      expect(sequence.maturity).to eq(:novel)
+    end
+
+    it 'has nil last_executed' do
+      expect(sequence.last_executed).to be_nil
+    end
+
+    it 'records created_at' do
+      expect(sequence.created_at).to be_a(Time)
+    end
+
+    it 'converts string actions to symbols' do
+      seq = described_class.new(actions: %w[fetch parse])
+      expect(seq.actions).to eq(%i[fetch parse])
+    end
+  end
+
+  describe '#record_execution' do
+    context 'when success: true' do
+      it 'increments execution_count' do
+        sequence.record_execution(success: true)
+        expect(sequence.execution_count).to eq(1)
+      end
+
+      it 'increments success_count' do
+        sequence.record_execution(success: true)
+        expect(sequence.success_count).to eq(1)
+      end
+
+      it 'increases strength' do
+        before = sequence.strength
+        sequence.record_execution(success: true)
+        expect(sequence.strength).to be > before
+      end
+
+      it 'sets last_executed' do
+        sequence.record_execution(success: true)
+        expect(sequence.last_executed).to be_a(Time)
+      end
+    end
+
+    context 'when success: false' do
+      it 'increments execution_count' do
+        sequence.record_execution(success: false)
+        expect(sequence.execution_count).to eq(1)
+      end
+
+      it 'does not increment success_count' do
+        sequence.record_execution(success: false)
+        expect(sequence.success_count).to eq(0)
+      end
+
+      it 'decreases strength' do
+        before = sequence.strength
+        sequence.record_execution(success: false)
+        expect(sequence.strength).to be < before
+      end
+    end
+
+    it 'does not exceed strength 1.0' do
+      20.times { sequence.record_execution(success: true) }
+      expect(sequence.strength).to be <= 1.0
+    end
+
+    it 'does not go below strength 0.0' do
+      20.times { sequence.record_execution(success: false) }
+      expect(sequence.strength).to be >= 0.0
+    end
+  end
+
+  describe '#maturity progression' do
+    it 'advances to :learning after enough executions' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:learning]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.maturity).to eq(:learning)
+    end
+
+    it 'advances to :practiced after enough executions' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:practiced]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.maturity).to eq(:practiced)
+    end
+
+    it 'advances to :habitual after enough executions' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:habitual]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.maturity).to eq(:habitual)
+    end
+
+    it 'advances to :automatic after enough executions' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:automatic]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.maturity).to eq(:automatic)
+    end
+  end
+
+  describe '#cognitive_cost' do
+    it 'returns the cost for the current maturity stage' do
+      cost = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::COGNITIVE_COST[:novel]
+      expect(sequence.cognitive_cost).to eq(cost)
+    end
+
+    it 'decreases as maturity increases' do
+      novel_cost = sequence.cognitive_cost
+      threshold  = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:automatic]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.cognitive_cost).to be < novel_cost
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 when no executions' do
+      expect(sequence.success_rate).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all executions are successful' do
+      3.times { sequence.record_execution(success: true) }
+      expect(sequence.success_rate).to eq(1.0)
+    end
+
+    it 'returns partial rate for mixed executions' do
+      sequence.record_execution(success: true)
+      sequence.record_execution(success: false)
+      expect(sequence.success_rate).to eq(0.5)
+    end
+  end
+
+  describe '#matches_context?' do
+    it 'returns true for empty context' do
+      expect(sequence.matches_context?({})).to be true
+    end
+
+    it 'returns true when majority of dimensions match' do
+      expect(sequence.matches_context?({ domain: :api, mood: :neutral })).to be true
+    end
+
+    it 'returns false when majority of dimensions do not match' do
+      expect(sequence.matches_context?({ domain: :db, mood: :stressed })).to be false
+    end
+
+    it 'returns true for partial match meeting 50% threshold' do
+      # context has domain: :api, mood: :neutral
+      # querying with domain: :api only — 100% match on stored dims
+      expect(sequence.matches_context?({ domain: :api })).to be true
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength by DECAY_RATE' do
+      before = sequence.strength
+      sequence.decay
+      expect(sequence.strength).to be_within(0.001).of(before - Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::DECAY_RATE)
+    end
+
+    it 'returns true when strength is above floor' do
+      expect(sequence.decay).to be true
+    end
+
+    it 'returns false when strength falls to or below floor' do
+      floor = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::HABIT_STRENGTH_FLOOR
+      # Set strength just below floor + decay_rate so one decay pushes it under
+      rate = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::DECAY_RATE
+      seq  = described_class.new(actions: %i[a b])
+      seq.instance_variable_set(:@strength, floor + (rate * 0.5))
+      expect(seq.decay).to be false
+    end
+  end
+
+  describe '#mature?' do
+    it 'returns false for :novel stage' do
+      expect(sequence.mature?).to be false
+    end
+
+    it 'returns true for :habitual stage' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:habitual]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.mature?).to be true
+    end
+
+    it 'returns true for :automatic stage' do
+      threshold = Legion::Extensions::Agentic::Learning::Habit::Helpers::Constants::MATURITY_THRESHOLDS[:automatic]
+      threshold.times { sequence.record_execution(success: true) }
+      expect(sequence.mature?).to be true
+    end
+  end
+
+  describe '#stale?' do
+    it 'returns true when never executed' do
+      expect(sequence.stale?).to be true
+    end
+
+    it 'returns false when executed recently' do
+      sequence.record_execution(success: true)
+      expect(sequence.stale?(3600)).to be false
+    end
+
+    it 'returns true when last executed beyond threshold' do
+      sequence.record_execution(success: true)
+      sequence.instance_variable_set(:@last_executed, Time.now.utc - 7200)
+      expect(sequence.stale?(3600)).to be true
+    end
+  end
+
+  describe '#similarity' do
+    it 'returns 1.0 for identical sequences' do
+      other = described_class.new(actions: actions)
+      expect(sequence.similarity(other)).to eq(1.0)
+    end
+
+    it 'returns 0.0 for completely different sequences' do
+      other = described_class.new(actions: %i[open write close])
+      expect(sequence.similarity(other)).to eq(0.0)
+    end
+
+    it 'returns a partial score for overlapping sequences' do
+      other = described_class.new(actions: %i[fetch transform store])
+      score = sequence.similarity(other)
+      expect(score).to be > 0.0
+      expect(score).to be < 1.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = sequence.to_h
+      expect(h).to have_key(:id)
+      expect(h).to have_key(:actions)
+      expect(h).to have_key(:context)
+      expect(h).to have_key(:execution_count)
+      expect(h).to have_key(:success_count)
+      expect(h).to have_key(:strength)
+      expect(h).to have_key(:maturity)
+      expect(h).to have_key(:cognitive_cost)
+      expect(h).to have_key(:success_rate)
+      expect(h).to have_key(:last_executed)
+      expect(h).to have_key(:created_at)
+    end
+
+    it 'includes the correct maturity' do
+      expect(sequence.to_h[:maturity]).to eq(:novel)
+    end
+  end
+end