lex-cognitive-cocoon 0.1.0

data/spec/legion/extensions/cognitive_cocoon/client_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveCocoon::Client do
+  subject(:client) { described_class.new }
+
+  describe 'runner interface' do
+    it 'responds to create_cocoon' do
+      expect(client).to respond_to(:create_cocoon)
+    end
+
+    it 'responds to gestate_all' do
+      expect(client).to respond_to(:gestate_all)
+    end
+
+    it 'responds to harvest_ready' do
+      expect(client).to respond_to(:harvest_ready)
+    end
+
+    it 'responds to force_emerge' do
+      expect(client).to respond_to(:force_emerge)
+    end
+
+    it 'responds to cocoon_status' do
+      expect(client).to respond_to(:cocoon_status)
+    end
+
+    it 'responds to list_by_stage' do
+      expect(client).to respond_to(:list_by_stage)
+    end
+  end
+
+  describe '#create_cocoon' do
+    it 'returns success true' do
+      result = client.create_cocoon(cocoon_type: :chrysalis, domain: :cognitive, content: 'idea')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns cocoon hash' do
+      result = client.create_cocoon(cocoon_type: :silk, domain: :emotional)
+      expect(result[:cocoon]).to include(:id, :cocoon_type, :domain, :maturity, :stage)
+    end
+  end
+
+  describe '#gestate_all' do
+    it 'returns success true' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.gestate_all
+      expect(result[:success]).to be true
+    end
+
+    it 'accepts a custom rate' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.gestate_all(rate: 0.2)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#harvest_ready' do
+    it 'returns success true with empty emerged when nothing ready' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.harvest_ready
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'harvests ready cocoons' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive, maturity: 1.0)
+      result = client.harvest_ready
+      expect(result[:count]).to eq(1)
+      expect(result[:emerged].first[:success]).to be true
+    end
+  end
+
+  describe '#force_emerge' do
+    it 'force-emerges a valid cocoon' do
+      create_result = client.create_cocoon(cocoon_type: :shell, domain: :cognitive)
+      id = create_result[:cocoon][:id]
+      result = client.force_emerge(id: id)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.force_emerge(id: 'bad-id')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#cocoon_status' do
+    it 'returns success true' do
+      result = client.cocoon_status
+      expect(result[:success]).to be true
+    end
+
+    it 'includes total_cocoons' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.cocoon_status
+      expect(result[:total_cocoons]).to eq(1)
+    end
+
+    it 'includes maturity_label' do
+      result = client.cocoon_status
+      expect(result).to have_key(:maturity_label)
+    end
+  end
+
+  describe '#list_by_stage' do
+    it 'returns success true' do
+      result = client.list_by_stage(stage: :encapsulating)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the requested stage name' do
+      result = client.list_by_stage(stage: :encapsulating)
+      expect(result[:stage]).to eq(:encapsulating)
+    end
+
+    it 'returns cocoons in the given stage' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.list_by_stage(stage: :encapsulating)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns cocoon hashes' do
+      client.create_cocoon(cocoon_type: :silk, domain: :cognitive)
+      result = client.list_by_stage(stage: :encapsulating)
+      expect(result[:cocoons].first).to include(:id, :cocoon_type, :stage)
+    end
+  end
+
+  describe 'full lifecycle' do
+    it 'creates, gestates, and harvests a cocoon' do
+      client.create_cocoon(cocoon_type: :chrysalis, domain: :cognitive, content: 'deep insight')
+      10.times { client.gestate_all(rate: 0.1) }
+      result = client.harvest_ready
+      expect(result[:count]).to eq(1)
+      expect(result[:emerged].first[:content]).to eq('deep insight')
+    end
+
+    it 'correctly reports status after gestation' do
+      client.create_cocoon(cocoon_type: :pod, domain: :emotional, content: 'growing concept')
+      5.times { client.gestate_all(rate: 0.1) }
+      status = client.cocoon_status
+      expect(status[:average_maturity]).to be_within(0.01).of(0.5)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_cocoon/helpers/cocoon_spec.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveCocoon::Helpers::Cocoon do
+  subject(:cocoon) do
+    described_class.new(cocoon_type: :chrysalis, domain: :cognitive, content: 'a fragile idea')
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(cocoon.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores cocoon_type as symbol' do
+      expect(cocoon.cocoon_type).to eq(:chrysalis)
+    end
+
+    it 'stores domain as symbol' do
+      expect(cocoon.domain).to eq(:cognitive)
+    end
+
+    it 'stores content' do
+      expect(cocoon.content).to eq('a fragile idea')
+    end
+
+    it 'starts with zero maturity by default' do
+      expect(cocoon.maturity).to eq(0.0)
+    end
+
+    it 'assigns protection from PROTECTION_BY_TYPE for chrysalis' do
+      expect(cocoon.protection).to eq(0.8)
+    end
+
+    it 'starts in encapsulating stage' do
+      expect(cocoon.stage).to eq(:encapsulating)
+    end
+
+    it 'records created_at as utc' do
+      expect(cocoon.created_at).to be_a(Time)
+    end
+
+    it 'clamps maturity to 0..1 when overridden' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 1.5)
+      expect(c.maturity).to eq(1.0)
+    end
+
+    it 'clamps protection to 0..1 when overridden' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, protection: 2.0)
+      expect(c.protection).to eq(1.0)
+    end
+
+    it 'uses fallback protection of 0.7 for unknown type via fetch default' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, protection: 0.7)
+      expect(c.protection).to eq(0.7)
+    end
+
+    it 'assigns silk protection correctly' do
+      c = described_class.new(cocoon_type: :silk, domain: :semantic)
+      expect(c.protection).to eq(0.6)
+    end
+
+    it 'assigns shell protection correctly' do
+      c = described_class.new(cocoon_type: :shell, domain: :semantic)
+      expect(c.protection).to eq(0.9)
+    end
+
+    it 'assigns pod protection correctly' do
+      c = described_class.new(cocoon_type: :pod, domain: :semantic)
+      expect(c.protection).to eq(0.7)
+    end
+
+    it 'assigns web protection correctly' do
+      c = described_class.new(cocoon_type: :web, domain: :semantic)
+      expect(c.protection).to eq(0.5)
+    end
+
+    it 'enters developing stage when maturity starts at 0.5' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 0.5)
+      expect(c.stage).to eq(:developing)
+    end
+
+    it 'enters transforming stage when maturity starts at 0.8' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 0.8)
+      expect(c.stage).to eq(:transforming)
+    end
+
+    it 'enters ready stage when maturity starts at 1.0' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 1.0)
+      expect(c.stage).to eq(:ready)
+    end
+  end
+
+  describe '#gestate!' do
+    it 'increases maturity by MATURITY_RATE by default' do
+      cocoon.gestate!
+      expect(cocoon.maturity).to be_within(0.001).of(0.1)
+    end
+
+    it 'accepts a custom rate' do
+      cocoon.gestate!(0.2)
+      expect(cocoon.maturity).to be_within(0.001).of(0.2)
+    end
+
+    it 'does not exceed maturity 1.0' do
+      20.times { cocoon.gestate! }
+      expect(cocoon.maturity).to eq(1.0)
+    end
+
+    it 'transitions to developing stage' do
+      4.times { cocoon.gestate!(0.1) }
+      expect(cocoon.stage).to eq(:developing)
+    end
+
+    it 'transitions to transforming stage' do
+      8.times { cocoon.gestate!(0.1) }
+      expect(cocoon.stage).to eq(:transforming)
+    end
+
+    it 'transitions to ready stage at 1.0' do
+      10.times { cocoon.gestate!(0.1) }
+      expect(cocoon.stage).to eq(:ready)
+    end
+
+    it 'returns self for chaining' do
+      expect(cocoon.gestate!).to be(cocoon)
+    end
+
+    it 'does not advance an emerged cocoon' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 1.0)
+      c.emerge!
+      before_maturity = c.maturity
+      c.gestate!
+      expect(c.maturity).to eq(before_maturity)
+    end
+  end
+
+  describe '#ready?' do
+    it 'returns false for a new cocoon' do
+      expect(cocoon).not_to be_ready
+    end
+
+    it 'returns true when maturity reaches 1.0' do
+      10.times { cocoon.gestate!(0.1) }
+      expect(cocoon).to be_ready
+    end
+  end
+
+  describe '#premature?' do
+    it 'returns true for a new cocoon' do
+      expect(cocoon).to be_premature
+    end
+
+    it 'returns false once cocoon is ready' do
+      10.times { cocoon.gestate!(0.1) }
+      expect(cocoon).not_to be_premature
+    end
+
+    it 'returns false after emergence' do
+      c = described_class.new(cocoon_type: :silk, domain: :emotional, maturity: 1.0)
+      c.emerge!
+      expect(c).not_to be_premature
+    end
+  end
+
+  describe '#emerge!' do
+    context 'when ready' do
+      before { 10.times { cocoon.gestate!(0.1) } }
+
+      it 'returns success true' do
+        expect(cocoon.emerge![:success]).to be true
+      end
+
+      it 'returns the content' do
+        expect(cocoon.emerge![:content]).to eq('a fragile idea')
+      end
+
+      it 'reports not damaged' do
+        expect(cocoon.emerge![:damaged]).to be false
+      end
+
+      it 'sets stage to emerged' do
+        cocoon.emerge!
+        expect(cocoon.stage).to eq(:emerged)
+      end
+    end
+
+    context 'when not ready' do
+      it 'returns success false' do
+        expect(cocoon.emerge![:success]).to be false
+      end
+
+      it 'reports not damaged' do
+        expect(cocoon.emerge![:damaged]).to be false
+      end
+
+      it 'returns an error message' do
+        expect(cocoon.emerge![:error]).to eq('not ready')
+      end
+
+      it 'does not change the stage' do
+        cocoon.emerge!
+        expect(cocoon.stage).to eq(:encapsulating)
+      end
+    end
+  end
+
+  describe '#expose!' do
+    context 'when premature' do
+      it 'returns success true' do
+        expect(cocoon.expose![:success]).to be true
+      end
+
+      it 'reports the idea is damaged' do
+        expect(cocoon.expose![:damaged]).to be true
+      end
+
+      it 'sets stage to emerged' do
+        cocoon.expose!
+        expect(cocoon.stage).to eq(:emerged)
+      end
+
+      it 'applies the premature penalty to maturity' do
+        cocoon.gestate!(0.4)
+        cocoon.expose!
+        expect(cocoon.maturity).to be_within(0.001).of(0.4 * 0.5)
+      end
+    end
+
+    context 'when ready' do
+      before { 10.times { cocoon.gestate!(0.1) } }
+
+      it 'returns success true' do
+        expect(cocoon.expose![:success]).to be true
+      end
+
+      it 'reports not damaged' do
+        expect(cocoon.expose![:damaged]).to be false
+      end
+
+      it 'sets stage to emerged' do
+        cocoon.expose!
+        expect(cocoon.stage).to eq(:emerged)
+      end
+    end
+  end
+
+  describe '#age_seconds' do
+    it 'returns a non-negative float' do
+      expect(cocoon.age_seconds).to be >= 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = cocoon.to_h
+      expect(h).to include(
+        :id, :cocoon_type, :domain, :content, :maturity, :stage,
+        :protection, :ready, :premature, :maturity_label, :age_seconds, :created_at
+      )
+    end
+
+    it 'includes the correct cocoon_type' do
+      expect(cocoon.to_h[:cocoon_type]).to eq(:chrysalis)
+    end
+
+    it 'includes the correct domain' do
+      expect(cocoon.to_h[:domain]).to eq(:cognitive)
+    end
+
+    it 'includes maturity rounded to 10 decimal places' do
+      cocoon.gestate!(0.123456789012)
+      expect(cocoon.to_h[:maturity].to_s.split('.').last.length).to be <= 10
+    end
+
+    it 'includes the maturity_label' do
+      expect(cocoon.to_h[:maturity_label]).to eq(:newly_formed)
+    end
+
+    it 'includes created_at as iso8601' do
+      expect(cocoon.to_h[:created_at]).to match(/\d{4}-\d{2}-\d{2}T/)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_cocoon/helpers/constants_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveCocoon::Helpers::Constants do
+  describe 'GESTATION_STAGES' do
+    it 'is an array of symbols' do
+      expect(described_class::GESTATION_STAGES).to all(be_a(Symbol))
+    end
+
+    it 'contains the five expected stages' do
+      expect(described_class::GESTATION_STAGES).to eq(%i[encapsulating developing transforming ready emerged])
+    end
+
+    it 'is frozen' do
+      expect(described_class::GESTATION_STAGES).to be_frozen
+    end
+  end
+
+  describe 'COCOON_TYPES' do
+    it 'is an array of symbols' do
+      expect(described_class::COCOON_TYPES).to all(be_a(Symbol))
+    end
+
+    it 'contains the five expected types' do
+      expect(described_class::COCOON_TYPES).to eq(%i[silk chrysalis shell pod web])
+    end
+
+    it 'is frozen' do
+      expect(described_class::COCOON_TYPES).to be_frozen
+    end
+  end
+
+  describe 'MAX_COCOONS' do
+    it 'equals 100' do
+      expect(described_class::MAX_COCOONS).to eq(100)
+    end
+  end
+
+  describe 'MATURITY_RATE' do
+    it 'equals 0.1' do
+      expect(described_class::MATURITY_RATE).to eq(0.1)
+    end
+  end
+
+  describe 'PREMATURE_PENALTY' do
+    it 'equals 0.5' do
+      expect(described_class::PREMATURE_PENALTY).to eq(0.5)
+    end
+  end
+
+  describe 'PROTECTION_BY_TYPE' do
+    it 'has an entry for every cocoon type' do
+      described_class::COCOON_TYPES.each do |type|
+        expect(described_class::PROTECTION_BY_TYPE).to have_key(type)
+      end
+    end
+
+    it 'assigns highest protection to shell' do
+      expect(described_class::PROTECTION_BY_TYPE[:shell]).to eq(0.9)
+    end
+
+    it 'assigns lowest protection to web' do
+      expect(described_class::PROTECTION_BY_TYPE[:web]).to eq(0.5)
+    end
+  end
+
+  describe 'MATURITY_LABELS' do
+    it 'is a hash' do
+      expect(described_class::MATURITY_LABELS).to be_a(Hash)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MATURITY_LABELS).to be_frozen
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns fully_gestated for maturity 0.95' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.95)).to eq(:fully_gestated)
+    end
+
+    it 'returns nearly_ready for maturity 0.8' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.8)).to eq(:nearly_ready)
+    end
+
+    it 'returns mid_gestation for maturity 0.6' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.6)).to eq(:mid_gestation)
+    end
+
+    it 'returns early_gestation for maturity 0.4' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.4)).to eq(:early_gestation)
+    end
+
+    it 'returns just_encapsulated for maturity 0.2' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.2)).to eq(:just_encapsulated)
+    end
+
+    it 'returns newly_formed for maturity 0.05' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.05)).to eq(:newly_formed)
+    end
+
+    it 'returns unknown for an empty hash' do
+      expect(described_class.label_for({}, 0.5)).to eq(:unknown)
+    end
+  end
+end