lex-agentic-imagination 0.1.0

data/spec/legion/extensions/agentic/imagination/greenhouse/helpers/seedling_spec.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Greenhouse::Helpers::Seedling do
+  subject(:seedling) { described_class.new(plant_type: :hypothesis, domain: 'cognition', content: 'test idea') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(seedling.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets plant_type' do
+      expect(seedling.plant_type).to eq(:hypothesis)
+    end
+
+    it 'sets domain' do
+      expect(seedling.domain).to eq('cognition')
+    end
+
+    it 'sets content' do
+      expect(seedling.content).to eq('test idea')
+    end
+
+    it 'defaults to seed stage' do
+      expect(seedling.growth_stage).to eq(:seed)
+    end
+
+    it 'defaults health to 0.5' do
+      expect(seedling.health).to eq(0.5)
+    end
+
+    it 'defaults root_depth to 0.0' do
+      expect(seedling.root_depth).to eq(0.0)
+    end
+
+    it 'raises on invalid plant_type' do
+      expect { described_class.new(plant_type: :invalid, domain: 'd', content: 'c') }
+        .to raise_error(ArgumentError, /unknown plant_type/)
+    end
+
+    it 'raises on invalid growth_stage' do
+      expect { described_class.new(plant_type: :insight, domain: 'd', content: 'c', growth_stage: :adult) }
+        .to raise_error(ArgumentError, /unknown growth_stage/)
+    end
+
+    it 'clamps health above 1.0' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: 2.5)
+      expect(s.health).to eq(1.0)
+    end
+
+    it 'clamps health below 0.0' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: -0.5)
+      expect(s.health).to eq(0.0)
+    end
+  end
+
+  describe '#grow!' do
+    context 'with optimal conditions' do
+      let(:conditions) { { temperature: 22.0, humidity: 0.65, light_level: 0.75 } }
+
+      it 'returns grew: true' do
+        result = seedling.grow!(conditions)
+        expect(result[:grew]).to be true
+      end
+
+      it 'increases health' do
+        before_health = seedling.health
+        seedling.grow!(conditions)
+        expect(seedling.health).to be > before_health
+      end
+
+      it 'increases root_depth' do
+        seedling.grow!(conditions)
+        expect(seedling.root_depth).to be > 0.0
+      end
+
+      it 'includes quality in result' do
+        result = seedling.grow!(conditions)
+        expect(result[:quality]).to be_between(0.0, 1.0)
+      end
+    end
+
+    context 'with poor conditions' do
+      let(:conditions) { { temperature: 0.0, humidity: 0.0, light_level: 0.0 } }
+
+      it 'returns grew: false' do
+        result = seedling.grow!(conditions)
+        expect(result[:grew]).to be false
+      end
+
+      it 'returns reason :poor_environment' do
+        result = seedling.grow!(conditions)
+        expect(result[:reason]).to eq(:poor_environment)
+      end
+    end
+
+    context 'with empty conditions' do
+      it 'uses default quality of 0.5 and can grow' do
+        result = seedling.grow!({})
+        # quality 0.5 >= MIN_QUALITY_FOR_GROWTH (0.40)
+        expect(result[:grew]).to be true
+      end
+    end
+
+    it 'advances stage when health crosses threshold after enough grows' do
+      high_health_seedling = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: 0.8)
+      conditions = { temperature: 22.0, humidity: 0.65, light_level: 0.75 }
+      result = high_health_seedling.grow!(conditions)
+      expect(result[:stage_change]).to be true
+      expect(high_health_seedling.growth_stage).to eq(:sprout)
+    end
+
+    it 'does not advance stage past mature (bloom is explicit)' do
+      mature = described_class.new(plant_type: :insight, domain: 'd', content: 'c',
+                                   growth_stage: :mature, health: 0.9)
+      conditions = { temperature: 22.0, humidity: 0.65, light_level: 0.75 }
+      mature.grow!(conditions)
+      expect(mature.growth_stage).to eq(:mature)
+    end
+  end
+
+  describe '#wilt!' do
+    it 'reduces health' do
+      before_health = seedling.health
+      seedling.wilt!(0.5)
+      expect(seedling.health).to be < before_health
+    end
+
+    it 'returns a wilt result hash' do
+      result = seedling.wilt!(0.5)
+      expect(result[:wilted]).to be true
+      expect(result[:health]).to be_a(Float)
+    end
+
+    it 'clamps stress to [0, 1]' do
+      result = seedling.wilt!(5.0)
+      expect(result[:stress]).to eq(1.0)
+    end
+
+    it 'does not allow health below 0.0' do
+      seedling.wilt!(1.0)
+      seedling.wilt!(1.0)
+      seedling.wilt!(1.0)
+      expect(seedling.health).to be >= 0.0
+    end
+  end
+
+  describe '#bloom!' do
+    context 'when plant is mature' do
+      subject(:mature_seedling) do
+        described_class.new(plant_type: :theory, domain: 'd', content: 'c', growth_stage: :mature, health: 0.7)
+      end
+
+      it 'transitions to bloom stage' do
+        mature_seedling.bloom!
+        expect(mature_seedling.growth_stage).to eq(:bloom)
+      end
+
+      it 'returns bloomed: true' do
+        result = mature_seedling.bloom!
+        expect(result[:bloomed]).to be true
+      end
+
+      it 'boosts health slightly' do
+        before_health = mature_seedling.health
+        mature_seedling.bloom!
+        expect(mature_seedling.health).to be >= before_health
+      end
+    end
+
+    context 'when plant is not mature' do
+      it 'returns bloomed: false' do
+        result = seedling.bloom!
+        expect(result[:bloomed]).to be false
+        expect(result[:reason]).to eq(:not_mature)
+      end
+    end
+  end
+
+  describe '#healthy?' do
+    it 'returns true when health >= 0.6' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: 0.8)
+      expect(s.healthy?).to be true
+    end
+
+    it 'returns false when health < 0.6' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: 0.5)
+      expect(s.healthy?).to be false
+    end
+  end
+
+  describe '#wilting?' do
+    it 'returns true when health < 0.3' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', health: 0.2)
+      expect(s.wilting?).to be true
+    end
+
+    it 'returns false when health >= 0.3' do
+      expect(seedling.wilting?).to be false
+    end
+  end
+
+  describe '#mature?' do
+    it 'returns true when growth_stage is :mature' do
+      s = described_class.new(plant_type: :insight, domain: 'd', content: 'c', growth_stage: :mature)
+      expect(s.mature?).to be true
+    end
+
+    it 'returns false for other stages' do
+      expect(seedling.mature?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all key fields' do
+      h = seedling.to_h
+      expect(h.keys).to include(:id, :plant_type, :domain, :content, :growth_stage, :health, :root_depth, :planted_at, :last_tended)
+    end
+
+    it 'rounds health to 10 decimal places' do
+      h = seedling.to_h
+      expect(h[:health]).to be_a(Float)
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/greenhouse/runners/cognitive_greenhouse_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Greenhouse::Runners::CognitiveGreenhouse do
+  let(:greenhouse) { Legion::Extensions::Agentic::Imagination::Greenhouse::Helpers::Greenhouse.new }
+  let(:engine) { Legion::Extensions::Agentic::Imagination::Greenhouse::Helpers::GreenhouseEngine.new(greenhouse: greenhouse) }
+
+  # Use a throwaway object that extends the runner module so private state is isolated per example
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#plant_idea' do
+    it 'returns success: true for a valid idea' do
+      result = runner.plant_idea(plant_type: :hypothesis, domain: 'cognition', content: 'test', engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the planted seedling in result' do
+      result = runner.plant_idea(plant_type: :insight, domain: 'ai', content: 'test', engine: engine)
+      expect(result[:result][:seedling][:plant_type]).to eq(:insight)
+    end
+
+    it 'returns success: false for invalid plant_type' do
+      result = runner.plant_idea(plant_type: :bad, domain: 'd', content: 'c', engine: engine)
+      expect(result[:success]).to be false
+      expect(result[:error]).to match(/unknown plant_type/)
+    end
+
+    it 'uses the injected engine' do
+      runner.plant_idea(plant_type: :question, domain: 'd', content: 'c', engine: engine)
+      expect(engine.greenhouse.plants.size).to eq(1)
+    end
+  end
+
+  describe '#tend_greenhouse' do
+    before do
+      engine.plant_in_greenhouse(plant_type: :hypothesis, domain: 'd', content: 'c')
+    end
+
+    it 'returns success: true' do
+      result = runner.tend_greenhouse(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns grow_all results' do
+      result = runner.tend_greenhouse(engine: engine)
+      expect(result[:result]).to have_key(:grew)
+      expect(result[:result]).to have_key(:total)
+    end
+  end
+
+  describe '#adjust_environment' do
+    it 'returns success: true' do
+      result = runner.adjust_environment(temperature: 24.0, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'updates greenhouse temperature via engine' do
+      runner.adjust_environment(temperature: 24.0, engine: engine)
+      expect(greenhouse.temperature).to eq(24.0)
+    end
+
+    it 'returns updated quality in result' do
+      result = runner.adjust_environment(temperature: 22.0, humidity: 0.65, engine: engine)
+      expect(result[:result][:quality]).to be_a(Float)
+    end
+  end
+
+  describe '#advance_season' do
+    it 'returns success: true' do
+      result = runner.advance_season(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'advances the season' do
+      runner.advance_season(engine: engine)
+      expect(greenhouse.season).to eq(:summer)
+    end
+
+    it 'returns season in result' do
+      result = runner.advance_season(engine: engine)
+      expect(result[:result][:season]).to eq(:summer)
+    end
+  end
+
+  describe '#harvest_ideas' do
+    it 'returns success: true' do
+      result = runner.harvest_ideas(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns harvested count' do
+      result = runner.harvest_ideas(engine: engine)
+      expect(result[:result][:harvested]).to eq(0)
+    end
+
+    it 'collects bloomed plants' do
+      mature = Legion::Extensions::Agentic::Imagination::Greenhouse::Helpers::Seedling.new(
+        plant_type: :theory, domain: 'd', content: 'c', growth_stage: :mature, health: 0.9
+      )
+      mature.bloom!
+      greenhouse.plant!(mature)
+      result = runner.harvest_ideas(engine: engine)
+      expect(result[:result][:harvested]).to eq(1)
+    end
+  end
+
+  describe '#greenhouse_status' do
+    it 'returns success: true' do
+      result = runner.greenhouse_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns report with total_plants' do
+      result = runner.greenhouse_status(engine: engine)
+      expect(result[:result]).to have_key(:total_plants)
+    end
+
+    it 'returns report with conditions' do
+      result = runner.greenhouse_status(engine: engine)
+      expect(result[:result]).to have_key(:conditions)
+    end
+  end
+
+  describe 'default_engine memoization' do
+    it 'creates a default engine when none provided' do
+      result = runner.greenhouse_status
+      expect(result[:success]).to be true
+    end
+
+    it 'reuses the same engine across calls' do
+      runner.plant_idea(plant_type: :hypothesis, domain: 'd', content: 'c')
+      status = runner.greenhouse_status
+      expect(status[:result][:total_plants]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Imagery::Client do
+  it 'creates default simulation store' do
+    client = described_class.new
+    expect(client.simulation_store).to be_a(Legion::Extensions::Agentic::Imagination::Imagery::Helpers::SimulationStore)
+  end
+
+  it 'accepts injected simulation store' do
+    store = Legion::Extensions::Agentic::Imagination::Imagery::Helpers::SimulationStore.new
+    client = described_class.new(simulation_store: store)
+    expect(client.simulation_store).to equal(store)
+  end
+
+  it 'includes Imagination runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:simulate, :what_if, :compare,
+                                 :record_actual_outcome, :imagination_stats)
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Imagery::Helpers::Constants do
+  it 'defines 4 imagination modes' do
+    expect(described_class::MODES.size).to eq(4)
+  end
+
+  it 'defines 6 outcome types' do
+    expect(described_class::OUTCOME_TYPES.size).to eq(6)
+  end
+
+  it 'defines 3 risk tolerances' do
+    expect(described_class::RISK_TOLERANCES).to contain_exactly(:conservative, :moderate, :aggressive)
+  end
+
+  it 'defines evaluation weights summing to 1.0' do
+    total = described_class::EVALUATION_WEIGHTS.values.sum
+    expect(total).to be_within(0.001).of(1.0)
+  end
+
+  it 'defines ordered confidence thresholds' do
+    expect(described_class::LOW_CONFIDENCE).to be < described_class::MEDIUM_CONFIDENCE
+    expect(described_class::MEDIUM_CONFIDENCE).to be < described_class::HIGH_CONFIDENCE
+  end
+end

data/spec/legion/extensions/agentic/imagination/imagery/helpers/scenario_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Imagery::Helpers::Scenario do
+  subject(:scenario) { described_class.new(action: 'deploy', context: { env: :prod }) }
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(scenario.scenario_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores action and context' do
+      expect(scenario.action).to eq('deploy')
+      expect(scenario.context[:env]).to eq(:prod)
+    end
+  end
+
+  describe '#add_outcome' do
+    it 'adds an outcome' do
+      scenario.add_outcome(type: :success, likelihood: 0.7, value: 0.8)
+      expect(scenario.outcomes.size).to eq(1)
+      expect(scenario.outcomes.first[:type]).to eq(:success)
+    end
+
+    it 'clamps likelihood to 0-1' do
+      scenario.add_outcome(likelihood: 1.5, value: 0.5)
+      expect(scenario.outcomes.first[:likelihood]).to eq(1.0)
+    end
+
+    it 'classifies valence' do
+      scenario.add_outcome(value: 0.8)
+      expect(scenario.outcomes.first[:valence]).to eq(:very_positive)
+    end
+  end
+
+  describe '#expected_value' do
+    it 'returns 0 with no outcomes' do
+      expect(scenario.expected_value).to eq(0.0)
+    end
+
+    it 'computes weighted expected value' do
+      scenario.add_outcome(likelihood: 0.7, value: 0.8)
+      scenario.add_outcome(likelihood: 0.3, value: -0.5)
+      ev = scenario.expected_value
+      expect(ev).to be_within(0.001).of((0.7 * 0.8) + (0.3 * -0.5))
+    end
+  end
+
+  describe '#risk_score' do
+    it 'returns 0 with no negative outcomes' do
+      scenario.add_outcome(likelihood: 0.5, value: 0.5)
+      expect(scenario.risk_score).to eq(0.0)
+    end
+
+    it 'computes risk from negative outcomes' do
+      scenario.add_outcome(likelihood: 0.3, value: -0.6)
+      expect(scenario.risk_score).to be_within(0.001).of(0.3 * 0.6)
+    end
+  end
+
+  describe '#best_outcome / #worst_outcome' do
+    before do
+      scenario.add_outcome(value: 0.8, likelihood: 0.5)
+      scenario.add_outcome(value: -0.3, likelihood: 0.5)
+    end
+
+    it 'returns highest value outcome as best' do
+      expect(scenario.best_outcome[:value]).to eq(0.8)
+    end
+
+    it 'returns lowest value outcome as worst' do
+      expect(scenario.worst_outcome[:value]).to eq(-0.3)
+    end
+  end
+
+  describe '#reversibility' do
+    it 'returns 1.0 when all outcomes are reversible' do
+      scenario.add_outcome(value: 0.5, reversible: true)
+      expect(scenario.reversibility).to eq(1.0)
+    end
+
+    it 'returns 0.0 when no outcomes are reversible' do
+      scenario.add_outcome(value: 0.5, reversible: false)
+      expect(scenario.reversibility).to eq(0.0)
+    end
+  end
+
+  describe '#evaluate' do
+    before do
+      scenario.add_outcome(likelihood: 0.7, value: 0.6)
+      scenario.add_outcome(likelihood: 0.3, value: -0.3)
+    end
+
+    it 'produces evaluation hash' do
+      scenario.evaluate
+      expect(scenario.evaluation).to include(:expected_value, :risk, :reversibility, :composite)
+    end
+
+    it 'produces a composite score' do
+      scenario.evaluate
+      expect(scenario.evaluation[:composite]).to be_a(Numeric)
+      expect(scenario.evaluation[:composite]).to be > 0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete scenario hash' do
+      h = scenario.to_h
+      expect(h).to include(:scenario_id, :action, :context, :outcomes, :expected_value)
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/imagery/helpers/simulation_store_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Imagery::Helpers::SimulationStore do
+  subject(:store) { described_class.new }
+
+  let(:simulation) do
+    {
+      simulation_id:  SecureRandom.uuid,
+      mode:           :prospective,
+      scenarios:      [],
+      recommendation: { action: 'deploy', composite: 0.8 },
+      simulated_at:   Time.now.utc
+    }
+  end
+
+  describe '#store' do
+    it 'stores a simulation' do
+      store.store(simulation)
+      expect(store.size).to eq(1)
+    end
+
+    it 'caps at MAX_SIMULATIONS' do
+      (Legion::Extensions::Agentic::Imagination::Imagery::Helpers::Constants::MAX_SIMULATIONS + 5).times do |i|
+        store.store(simulation.merge(simulation_id: "sim-#{i}"))
+      end
+      expect(store.size).to eq(Legion::Extensions::Agentic::Imagination::Imagery::Helpers::Constants::MAX_SIMULATIONS)
+    end
+  end
+
+  describe '#get' do
+    it 'retrieves by ID' do
+      store.store(simulation)
+      found = store.get(simulation[:simulation_id])
+      expect(found).to eq(simulation)
+    end
+
+    it 'returns nil for missing ID' do
+      expect(store.get('nonexistent')).to be_nil
+    end
+  end
+
+  describe '#recent' do
+    it 'returns last N simulations' do
+      3.times { |i| store.store(simulation.merge(simulation_id: "sim-#{i}")) }
+      expect(store.recent(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#by_mode' do
+    it 'filters by mode' do
+      store.store(simulation.merge(mode: :prospective))
+      store.store(simulation.merge(simulation_id: 'x', mode: :counterfactual))
+      expect(store.by_mode(:prospective).size).to eq(1)
+    end
+  end
+
+  describe '#accuracy_check' do
+    it 'records actual outcome' do
+      store.store(simulation)
+      result = store.accuracy_check(simulation[:simulation_id], actual_outcome: { valence: :positive })
+      expect(result).to be true
+    end
+
+    it 'returns nil for missing simulation' do
+      result = store.accuracy_check('nonexistent', actual_outcome: {})
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#simulation_accuracy' do
+    it 'returns nil with no checked simulations' do
+      expect(store.simulation_accuracy).to be_nil
+    end
+
+    it 'computes accuracy' do
+      store.store(simulation)
+      store.accuracy_check(simulation[:simulation_id], actual_outcome: { valence: :positive })
+      expect(store.simulation_accuracy).to eq(1.0)
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all simulations' do
+      store.store(simulation)
+      store.clear
+      expect(store.size).to eq(0)
+    end
+  end
+end