lex-agentic-imagination 0.1.0

data/spec/legion/extensions/agentic/imagination/garden/runners/cognitive_garden_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Garden::Runners::CognitiveGarden do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:engine) { Legion::Extensions::Agentic::Imagination::Garden::Helpers::GardenEngine.new }
+
+  describe '#plant_seed' do
+    it 'returns success' do
+      result = runner.plant_seed(plant_type: :idea, domain: :reasoning,
+                                 content: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:plant][:plant_type]).to eq(:idea)
+    end
+
+    it 'returns failure for invalid type' do
+      result = runner.plant_seed(plant_type: :weed, domain: :t, content: 'x', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_plot' do
+    it 'returns success' do
+      result = runner.create_plot(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:plot]).to be_a(Hash)
+    end
+  end
+
+  describe '#grow' do
+    it 'grows a plant' do
+      p = engine.plant_seed(plant_type: :idea, domain: :t, content: 'x')
+      result = runner.grow(plant_id: p.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:plant][:health]).to be > 0.5
+    end
+  end
+
+  describe '#water' do
+    it 'waters a plant' do
+      p = engine.plant_seed(plant_type: :idea, domain: :t, content: 'x')
+      result = runner.water(plant_id: p.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#list_plants' do
+    before do
+      engine.plant_seed(plant_type: :idea, domain: :t, content: 'a')
+      engine.plant_seed(plant_type: :theory, domain: :t, content: 'b')
+    end
+
+    it 'returns all plants' do
+      result = runner.list_plants(engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by type' do
+      result = runner.list_plants(plant_type: :idea, engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#garden_status' do
+    it 'returns report' do
+      result = runner.garden_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_plants)
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/genesis/client_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Genesis::Client do
+  let(:engine) { Legion::Extensions::Agentic::Imagination::Genesis::Helpers::GenesisEngine.new }
+  let(:client) { described_class.new(engine: engine) }
+
+  describe '#initialize' do
+    it 'accepts injected engine' do
+      expect(client.engine).to eq(engine)
+    end
+
+    it 'creates a default engine when none injected' do
+      expect(described_class.new.engine).to be_a(Legion::Extensions::Agentic::Imagination::Genesis::Helpers::GenesisEngine)
+    end
+  end
+
+  describe 'runner method presence' do
+    %i[
+      plant_seed germinate_seed birth_concept nurture_concept prune_seed
+      cross_pollinate adopt_concept concept_fitness novelty_landscape
+      genesis_rate most_adopted orphan_concepts genesis_report
+    ].each do |method|
+      it "responds to ##{method}" do
+        expect(client).to respond_to(method)
+      end
+    end
+  end
+
+  describe 'full lifecycle integration' do
+    it 'plants, germinates, and births a concept end-to-end' do
+      plant = client.plant_seed(raw_material: %w[awareness recursion boundary], domain: :abstract,
+                                germination_potential: 0.6, novelty_score: 0.55, viability: 0.45)
+      expect(plant[:success]).to be true
+      sid = plant[:seed_id]
+
+      # Germinate
+      germ = client.germinate_seed(seed_id: sid, boost: 0.15)
+      expect(germ[:success]).to be true
+
+      # Push seed past all thresholds
+      seed = engine.seeds[sid]
+      seed.novelty_score         = 0.8
+      seed.viability             = 0.6
+      seed.germination_potential = 0.75
+
+      birth = client.birth_concept(seed_id: sid, name: 'reflexive dissolution',
+                                   definition: 'a boundary recognizing and dissolving itself')
+      expect(birth[:success]).to be true
+      cid = birth[:concept_id]
+
+      client.nurture_concept(concept_id: cid)
+      client.adopt_concept(concept_id: cid)
+      client.adopt_concept(concept_id: cid)
+
+      fitness = client.concept_fitness(concept_id: cid)
+      expect(fitness[:adoption_count]).to eq(2)
+      expect(fitness[:utility_score]).to be > 0.0
+
+      report = client.genesis_report
+      expect(report[:concepts]).to eq(1)
+      expect(report[:genesis_events]).to eq(1)
+      expect(report[:orphan_count]).to eq(0)
+    end
+
+    it 'cross-pollinates two seeds to form a more novel child' do
+      client.plant_seed(raw_material: %w[signal noise], domain: :emergent, novelty_score: 0.55)
+      client.plant_seed(raw_material: %w[pattern chaos], domain: :abstract, novelty_score: 0.65)
+      seeds  = engine.seeds.values
+      result = client.cross_pollinate(seed_id_a: seeds[0].seed_id, seed_id_b: seeds[1].seed_id)
+      expect(result[:success]).to be true
+      child = engine.seeds[result[:seed_id]]
+      expect(child.novelty_score).to be >= 0.65
+      expect(child.raw_material).to include('signal', 'noise', 'pattern', 'chaos')
+    end
+
+    it 'tracks orphan concepts correctly' do
+      s = engine.plant(raw_material: %w[a b c], domain: :abstract,
+                       germination_potential: 0.9, novelty_score: 0.8, viability: 0.6)
+      engine.birth(seed_id: s[:seed_id], name: 'orphan', definition: 'never used')
+      orphans = client.orphan_concepts
+      expect(orphans[:count]).to eq(1)
+    end
+
+    it 'novelty landscape reflects planted seeds' do
+      client.plant_seed(raw_material: %w[x y z], domain: :logical, novelty_score: 0.73)
+      landscape = client.novelty_landscape
+      expect(landscape[:seeds].size).to eq(1)
+      expect(landscape[:seeds].first[:score]).to eq(0.73)
+    end
+
+    it 'genesis_rate increases with each birth' do
+      s = engine.plant(raw_material: %w[q r s], domain: :abstract,
+                       germination_potential: 0.9, novelty_score: 0.8, viability: 0.6)
+      engine.birth(seed_id: s[:seed_id], name: 'rate test', definition: 'checking rate')
+      rate = client.genesis_rate
+      expect(rate[:total_events]).to eq(1)
+      expect(rate[:rate]).to be > 0.0
+    end
+
+    it 'most_adopted returns concept with highest count' do
+      s1   = engine.plant(raw_material: %w[a], domain: :abstract, germination_potential: 0.9, novelty_score: 0.8, viability: 0.6)
+      cid1 = engine.birth(seed_id: s1[:seed_id], name: 'popular concept', definition: 'used often')[:concept_id]
+      s2   = engine.plant(raw_material: %w[b], domain: :abstract, germination_potential: 0.9, novelty_score: 0.8, viability: 0.6)
+      engine.birth(seed_id: s2[:seed_id], name: 'unknown concept', definition: 'never used')
+      client.adopt_concept(concept_id: cid1)
+      client.adopt_concept(concept_id: cid1)
+      expect(client.most_adopted[:concept][:name]).to eq('popular concept')
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/genesis/cognitive_genesis_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Genesis do
+  it 'exposes the correct version' do
+    expect(described_class::VERSION).to eq('0.1.0')
+  end
+
+  it 'exposes Helpers::Constants' do
+    expect(described_class::Helpers::Constants).to be_a(Module)
+  end
+
+  it 'exposes Helpers::Seed' do
+    expect(described_class::Helpers::Seed).to be_a(Class)
+  end
+
+  it 'exposes Helpers::Concept' do
+    expect(described_class::Helpers::Concept).to be_a(Class)
+  end
+
+  it 'exposes Helpers::GenesisEngine' do
+    expect(described_class::Helpers::GenesisEngine).to be_a(Class)
+  end
+
+  it 'exposes Runners::Genesis' do
+    expect(described_class::Runners::Genesis).to be_a(Module)
+  end
+
+  it 'exposes Client' do
+    expect(described_class::Client).to be_a(Class)
+  end
+end

data/spec/legion/extensions/agentic/imagination/genesis/helpers/concept_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Genesis::Helpers::Concept do
+  let(:consts) { Legion::Extensions::Agentic::Imagination::Genesis::Helpers::Constants }
+  let(:parent_id) { SecureRandom.uuid }
+  let(:defaults) do
+    { name: 'liminal cognition', definition: 'threshold state between frameworks',
+      parent_seed_id: parent_id, domain: :abstract }
+  end
+
+  describe '#initialize' do
+    it 'generates a unique UUID concept_id' do
+      expect(described_class.new(**defaults).concept_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'generates unique IDs for each instance' do
+      a = described_class.new(**defaults)
+      b = described_class.new(**defaults)
+      expect(a.concept_id).not_to eq(b.concept_id)
+    end
+
+    it 'freezes name' do
+      expect(described_class.new(**defaults).name).to be_frozen
+    end
+
+    it 'freezes definition' do
+      expect(described_class.new(**defaults).definition).to be_frozen
+    end
+
+    it 'coerces domain to symbol' do
+      c = described_class.new(**defaults, domain: 'emergent')
+      expect(c.domain).to eq(:emergent)
+    end
+
+    it 'raises ArgumentError for invalid domain' do
+      expect { described_class.new(**defaults, domain: :imaginary) }
+        .to raise_error(ArgumentError, /invalid domain/)
+    end
+
+    it 'clamps maturity to 1.0' do
+      expect(described_class.new(**defaults, maturity: 2.5).maturity).to eq(1.0)
+    end
+
+    it 'clamps maturity to 0.0' do
+      expect(described_class.new(**defaults, maturity: -0.1).maturity).to eq(0.0)
+    end
+
+    it 'clamps utility_score to 1.0' do
+      expect(described_class.new(**defaults, utility_score: 5.0).utility_score).to eq(1.0)
+    end
+
+    it 'defaults maturity to 0.0' do
+      expect(described_class.new(**defaults).maturity).to eq(0.0)
+    end
+
+    it 'defaults adoption_count to 0' do
+      expect(described_class.new(**defaults).adoption_count).to eq(0)
+    end
+
+    it 'defaults connections to empty array' do
+      expect(described_class.new(**defaults).connections).to eq([])
+    end
+
+    it 'sets born_at to UTC Time' do
+      before = Time.now.utc
+      c      = described_class.new(**defaults)
+      after  = Time.now.utc
+      expect(c.born_at).to be >= before
+      expect(c.born_at).to be <= after
+    end
+  end
+
+  describe '#maturity_label' do
+    it 'returns :nascent for maturity 0.0' do
+      expect(described_class.new(**defaults, maturity: 0.0).maturity_label).to eq(:nascent)
+    end
+
+    it 'returns :foundational for maturity 0.9' do
+      expect(described_class.new(**defaults, maturity: 0.9).maturity_label).to eq(:foundational)
+    end
+
+    it 'returns :establishing for maturity 0.5' do
+      expect(described_class.new(**defaults, maturity: 0.5).maturity_label).to eq(:establishing)
+    end
+  end
+
+  describe '#fitness_label' do
+    it 'returns :untested for utility 0.1' do
+      expect(described_class.new(**defaults, utility_score: 0.1).fitness_label).to eq(:untested)
+    end
+
+    it 'returns :essential for utility 0.9' do
+      expect(described_class.new(**defaults, utility_score: 0.9).fitness_label).to eq(:essential)
+    end
+  end
+
+  describe '#adopt!' do
+    it 'increments adoption_count' do
+      c = described_class.new(**defaults)
+      c.adopt!
+      expect(c.adoption_count).to eq(1)
+    end
+
+    it 'increases utility_score by ADOPTION_BONUS' do
+      c = described_class.new(**defaults, utility_score: 0.3)
+      c.adopt!
+      expect(c.utility_score).to be_within(0.0001).of(0.3 + consts::ADOPTION_BONUS)
+    end
+
+    it 'increases maturity by MATURITY_BOOST' do
+      c = described_class.new(**defaults, maturity: 0.2)
+      c.adopt!
+      expect(c.maturity).to be_within(0.0001).of(0.2 + consts::MATURITY_BOOST)
+    end
+
+    it 'clamps utility_score at 1.0' do
+      c = described_class.new(**defaults, utility_score: 0.98)
+      c.adopt!
+      expect(c.utility_score).to eq(1.0)
+    end
+
+    it 'accumulates over multiple calls' do
+      c = described_class.new(**defaults)
+      3.times { c.adopt! }
+      expect(c.adoption_count).to eq(3)
+    end
+  end
+
+  describe '#nurture!' do
+    it 'increases maturity by default MATURITY_BOOST' do
+      c = described_class.new(**defaults, maturity: 0.4)
+      c.nurture!
+      expect(c.maturity).to be_within(0.0001).of(0.4 + consts::MATURITY_BOOST)
+    end
+
+    it 'accepts a custom boost' do
+      c = described_class.new(**defaults, maturity: 0.3)
+      c.nurture!(boost: 0.2)
+      expect(c.maturity).to be_within(0.0001).of(0.5)
+    end
+
+    it 'clamps at 1.0' do
+      c = described_class.new(**defaults, maturity: 0.99)
+      c.nurture!
+      expect(c.maturity).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'decreases maturity by MATURITY_DECAY' do
+      c = described_class.new(**defaults, maturity: 0.5)
+      c.decay!
+      expect(c.maturity).to be_within(0.0001).of(0.5 - consts::MATURITY_DECAY)
+    end
+
+    it 'clamps at 0.0' do
+      c = described_class.new(**defaults, maturity: 0.01)
+      c.decay!
+      expect(c.maturity).to eq(0.0)
+    end
+
+    it 'accepts a custom rate' do
+      c = described_class.new(**defaults, maturity: 0.5)
+      c.decay!(rate: 0.1)
+      expect(c.maturity).to be_within(0.0001).of(0.4)
+    end
+  end
+
+  describe '#connect_to' do
+    it 'adds a concept_id to connections' do
+      c  = described_class.new(**defaults)
+      id = SecureRandom.uuid
+      c.connect_to(id)
+      expect(c.connections).to include(id)
+    end
+
+    it 'does not add duplicates' do
+      c  = described_class.new(**defaults)
+      id = SecureRandom.uuid
+      c.connect_to(id)
+      c.connect_to(id)
+      expect(c.connections.count(id)).to eq(1)
+    end
+
+    it 'supports multiple unique connections' do
+      c = described_class.new(**defaults)
+      3.times { c.connect_to(SecureRandom.uuid) }
+      expect(c.connections.size).to eq(3)
+    end
+  end
+
+  describe '#orphan?' do
+    it 'returns true when adoption_count is 0' do
+      expect(described_class.new(**defaults).orphan?).to be true
+    end
+
+    it 'returns false after one adoption' do
+      c = described_class.new(**defaults)
+      c.adopt!
+      expect(c.orphan?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    subject(:hash) { described_class.new(**defaults).to_h }
+
+    it { expect(hash[:concept_id]).to match(/\A[0-9a-f-]{36}\z/) }
+    it { expect(hash[:name]).to eq('liminal cognition') }
+    it { expect(hash[:definition]).to include('threshold state') }
+    it { expect(hash[:parent_seed_id]).to be_a(String) }
+    it { expect(hash[:domain]).to eq(:abstract) }
+    it { expect(hash[:maturity]).to eq(0.0) }
+    it { expect(hash[:maturity_label]).to eq(:nascent) }
+    it { expect(hash[:connections]).to eq([]) }
+    it { expect(hash[:utility_score]).to eq(0.0) }
+    it { expect(hash[:fitness_label]).to eq(:untested) }
+    it { expect(hash[:adoption_count]).to eq(0) }
+    it { expect(hash[:orphan]).to be true }
+    it { expect(hash[:born_at]).to be_a(Time) }
+  end
+end

data/spec/legion/extensions/agentic/imagination/genesis/helpers/constants_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Genesis::Helpers::Constants do
+  describe 'capacity constants' do
+    it 'defines MAX_SEEDS as 200' do
+      expect(described_class::MAX_SEEDS).to eq(200)
+    end
+
+    it 'defines MAX_CONCEPTS as 100' do
+      expect(described_class::MAX_CONCEPTS).to eq(100)
+    end
+  end
+
+  describe 'germination constants' do
+    it 'defines DEFAULT_GERMINATION as 0.3' do
+      expect(described_class::DEFAULT_GERMINATION).to eq(0.3)
+    end
+
+    it 'defines GERMINATION_BOOST as 0.1' do
+      expect(described_class::GERMINATION_BOOST).to eq(0.1)
+    end
+
+    it 'defines GERMINATION_THRESHOLD as 0.7' do
+      expect(described_class::GERMINATION_THRESHOLD).to eq(0.7)
+    end
+  end
+
+  describe 'novelty and viability thresholds' do
+    it 'defines NOVELTY_THRESHOLD as 0.5' do
+      expect(described_class::NOVELTY_THRESHOLD).to eq(0.5)
+    end
+
+    it 'defines VIABILITY_THRESHOLD as 0.4' do
+      expect(described_class::VIABILITY_THRESHOLD).to eq(0.4)
+    end
+  end
+
+  describe 'concept lifecycle constants' do
+    it 'defines MATURITY_BOOST as 0.08' do
+      expect(described_class::MATURITY_BOOST).to eq(0.08)
+    end
+
+    it 'defines MATURITY_DECAY as 0.02' do
+      expect(described_class::MATURITY_DECAY).to eq(0.02)
+    end
+
+    it 'defines ADOPTION_BONUS as 0.05' do
+      expect(described_class::ADOPTION_BONUS).to eq(0.05)
+    end
+  end
+
+  describe 'SEED_DOMAINS' do
+    it 'is frozen' do
+      expect(described_class::SEED_DOMAINS).to be_frozen
+    end
+
+    it 'contains exactly 8 domains' do
+      expect(described_class::SEED_DOMAINS.size).to eq(8)
+    end
+
+    it 'includes all expected domains' do
+      expected = %i[linguistic spatial logical interpersonal aesthetic procedural abstract emergent]
+      expect(described_class::SEED_DOMAINS).to match_array(expected)
+    end
+
+    it 'contains only symbols' do
+      expect(described_class::SEED_DOMAINS).to all(be_a(Symbol))
+    end
+  end
+
+  describe 'GERMINATION_LABELS' do
+    it 'is a hash' do
+      expect(described_class::GERMINATION_LABELS).to be_a(Hash)
+    end
+
+    it 'labels 0.1 as :dormant' do
+      expect(described_class.label_for(described_class::GERMINATION_LABELS, 0.1)).to eq(:dormant)
+    end
+
+    it 'labels 0.5 as :awakening' do
+      expect(described_class.label_for(described_class::GERMINATION_LABELS, 0.5)).to eq(:awakening)
+    end
+
+    it 'labels 0.9 as :ready' do
+      expect(described_class.label_for(described_class::GERMINATION_LABELS, 0.9)).to eq(:ready)
+    end
+  end
+
+  describe 'NOVELTY_LABELS' do
+    it 'labels 0.1 as :derivative' do
+      expect(described_class.label_for(described_class::NOVELTY_LABELS, 0.1)).to eq(:derivative)
+    end
+
+    it 'labels 0.7 as :novel' do
+      expect(described_class.label_for(described_class::NOVELTY_LABELS, 0.7)).to eq(:novel)
+    end
+
+    it 'labels 0.9 as :unprecedented' do
+      expect(described_class.label_for(described_class::NOVELTY_LABELS, 0.9)).to eq(:unprecedented)
+    end
+  end
+
+  describe 'MATURITY_LABELS' do
+    it 'labels 0.1 as :nascent' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.1)).to eq(:nascent)
+    end
+
+    it 'labels 0.5 as :establishing' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.5)).to eq(:establishing)
+    end
+
+    it 'labels 0.9 as :foundational' do
+      expect(described_class.label_for(described_class::MATURITY_LABELS, 0.9)).to eq(:foundational)
+    end
+  end
+
+  describe 'FITNESS_LABELS' do
+    it 'labels 0.1 as :untested' do
+      expect(described_class.label_for(described_class::FITNESS_LABELS, 0.1)).to eq(:untested)
+    end
+
+    it 'labels 0.5 as :promising' do
+      expect(described_class.label_for(described_class::FITNESS_LABELS, 0.5)).to eq(:promising)
+    end
+
+    it 'labels 0.85 as :essential' do
+      expect(described_class.label_for(described_class::FITNESS_LABELS, 0.85)).to eq(:essential)
+    end
+  end
+
+  describe '.label_for' do
+    it 'clamps values below 0.0 to 0.0' do
+      expect(described_class.label_for(described_class::NOVELTY_LABELS, -0.5)).to eq(:derivative)
+    end
+
+    it 'clamps values above 1.0 to 1.0' do
+      expect(described_class.label_for(described_class::NOVELTY_LABELS, 1.5)).to eq(:unprecedented)
+    end
+
+    it 'returns last label as fallback when no range matches' do
+      sparse = { (0.9..1.0) => :high }
+      expect(described_class.label_for(sparse, 0.5)).to eq(:high)
+    end
+  end
+end