lex-agentic-imagination 0.1.0

data/spec/legion/extensions/agentic/imagination/mental_simulation/helpers/simulation_step_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::SimulationStep do
+  subject(:step) { described_class.new(action: 'deploy service') }
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(step.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the action' do
+      expect(step.action).to eq('deploy service')
+    end
+
+    it 'defaults predicted_outcome to :success' do
+      expect(step.predicted_outcome).to eq(:success)
+    end
+
+    it 'defaults confidence to 0.5' do
+      expect(step.confidence).to eq(0.5)
+    end
+
+    it 'defaults risk to 0.1' do
+      expect(step.risk).to eq(0.1)
+    end
+
+    it 'defaults preconditions to empty array' do
+      expect(step.preconditions).to eq([])
+    end
+
+    it 'defaults postconditions to empty array' do
+      expect(step.postconditions).to eq([])
+    end
+
+    it 'records created_at' do
+      expect(step.created_at).to be_a(Time)
+    end
+
+    it 'clamps confidence above 1.0 to 1.0' do
+      s = described_class.new(action: 'test', confidence: 1.5)
+      expect(s.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence below 0.0 to 0.0' do
+      s = described_class.new(action: 'test', confidence: -0.5)
+      expect(s.confidence).to eq(0.0)
+    end
+
+    it 'clamps risk above 1.0 to 1.0' do
+      s = described_class.new(action: 'test', risk: 2.0)
+      expect(s.risk).to eq(1.0)
+    end
+  end
+
+  describe '#favorable?' do
+    it 'returns true for success with sufficient confidence' do
+      s = described_class.new(action: 'go', predicted_outcome: :success, confidence: 0.8)
+      expect(s.favorable?).to be true
+    end
+
+    it 'returns true for partial_success with sufficient confidence' do
+      s = described_class.new(action: 'go', predicted_outcome: :partial_success, confidence: 0.6)
+      expect(s.favorable?).to be true
+    end
+
+    it 'returns false for success with low confidence' do
+      s = described_class.new(action: 'go', predicted_outcome: :success, confidence: 0.4)
+      expect(s.favorable?).to be false
+    end
+
+    it 'returns false for failure regardless of confidence' do
+      s = described_class.new(action: 'go', predicted_outcome: :failure, confidence: 0.9)
+      expect(s.favorable?).to be false
+    end
+
+    it 'returns false for unknown outcome' do
+      s = described_class.new(action: 'go', predicted_outcome: :unknown, confidence: 0.9)
+      expect(s.favorable?).to be false
+    end
+  end
+
+  describe '#risky?' do
+    it 'returns true when risk >= 0.6' do
+      s = described_class.new(action: 'go', risk: 0.7)
+      expect(s.risky?).to be true
+    end
+
+    it 'returns false when risk < 0.6' do
+      s = described_class.new(action: 'go', risk: 0.4)
+      expect(s.risky?).to be false
+    end
+
+    it 'returns true at exactly 0.6' do
+      s = described_class.new(action: 'go', risk: 0.6)
+      expect(s.risky?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = step.to_h
+      expect(h).to include(:id, :action, :predicted_outcome, :confidence, :risk,
+                           :preconditions, :postconditions, :created_at)
+    end
+
+    it 'includes stored preconditions' do
+      s = described_class.new(action: 'go', preconditions: ['service_up'])
+      expect(s.to_h[:preconditions]).to eq(['service_up'])
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/mental_simulation/runners/mental_simulation_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/imagination/mental_simulation/helpers/client'
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::MentalSimulation::Runners::MentalSimulation do
+  let(:client) { Legion::Extensions::Agentic::Imagination::MentalSimulation::Client.new }
+
+  def create_and_populate_simulation(favorable: true)
+    result = client.create_mental_simulation(label: 'test plan', domain: :infrastructure)
+    sim_id = result[:simulation_id]
+    if favorable
+      client.add_simulation_step(simulation_id: sim_id, action: 'check health', confidence: 0.9, risk: 0.05)
+      client.add_simulation_step(simulation_id: sim_id, action: 'deploy service', confidence: 0.85, risk: 0.05)
+    else
+      client.add_simulation_step(simulation_id: sim_id, action: 'low confidence step', confidence: 0.2, risk: 0.1)
+    end
+    sim_id
+  end
+
+  describe '#create_mental_simulation' do
+    it 'returns a simulation_id' do
+      result = client.create_mental_simulation(label: 'my plan', domain: :networking)
+      expect(result[:simulation_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the label' do
+      result = client.create_mental_simulation(label: 'my plan', domain: :networking)
+      expect(result[:label]).to eq('my plan')
+    end
+
+    it 'returns the domain' do
+      result = client.create_mental_simulation(label: 'my plan', domain: :networking)
+      expect(result[:domain]).to eq(:networking)
+    end
+
+    it 'starts in :pending state' do
+      result = client.create_mental_simulation(label: 'my plan', domain: :app)
+      expect(result[:state]).to eq(:pending)
+    end
+  end
+
+  describe '#add_simulation_step' do
+    it 'returns added: true' do
+      sim_result = client.create_mental_simulation(label: 'plan', domain: :app)
+      result = client.add_simulation_step(simulation_id: sim_result[:simulation_id], action: 'step 1')
+      expect(result[:added]).to be true
+    end
+
+    it 'returns a step_id' do
+      sim_result = client.create_mental_simulation(label: 'plan', domain: :app)
+      result = client.add_simulation_step(simulation_id: sim_result[:simulation_id], action: 'step 1')
+      expect(result[:step_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns error for unknown simulation' do
+      result = client.add_simulation_step(simulation_id: 'bad-id', action: 'noop')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+
+    it 'increments step_count' do
+      sim_result = client.create_mental_simulation(label: 'plan', domain: :app)
+      client.add_simulation_step(simulation_id: sim_result[:simulation_id], action: 'step 1')
+      result = client.add_simulation_step(simulation_id: sim_result[:simulation_id], action: 'step 2')
+      expect(result[:step_count]).to eq(2)
+    end
+  end
+
+  describe '#run_mental_simulation' do
+    it 'transitions state from pending' do
+      sim_id = create_and_populate_simulation
+      result = client.run_mental_simulation(simulation_id: sim_id)
+      expect(result[:state]).not_to eq(:pending)
+    end
+
+    it 'returns favorable: true for a well-configured plan' do
+      sim_id = create_and_populate_simulation(favorable: true)
+      result = client.run_mental_simulation(simulation_id: sim_id)
+      expect(result[:favorable]).to be true
+    end
+
+    it 'returns favorable: false for a low-confidence plan' do
+      sim_id = create_and_populate_simulation(favorable: false)
+      result = client.run_mental_simulation(simulation_id: sim_id)
+      expect(result[:favorable]).to be false
+    end
+
+    it 'returns error for unknown simulation' do
+      result = client.run_mental_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+
+    it 'includes step_count in result' do
+      sim_id = create_and_populate_simulation
+      result = client.run_mental_simulation(simulation_id: sim_id)
+      expect(result[:step_count]).to eq(2)
+    end
+  end
+
+  describe '#abort_mental_simulation' do
+    it 'aborts a simulation' do
+      sim_result = client.create_mental_simulation(label: 'to abort', domain: :app)
+      result = client.abort_mental_simulation(simulation_id: sim_result[:simulation_id])
+      expect(result[:state]).to eq(:aborted)
+      expect(result[:aborted]).to be true
+    end
+
+    it 'returns error for unknown simulation' do
+      result = client.abort_mental_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+  end
+
+  describe '#assess_mental_simulation' do
+    it 'returns assessment without running' do
+      sim_result = client.create_mental_simulation(label: 'assess me', domain: :security)
+      client.add_simulation_step(simulation_id: sim_result[:simulation_id], action: 'read logs',
+                                 confidence: 0.8, risk: 0.1)
+      result = client.assess_mental_simulation(simulation_id: sim_result[:simulation_id])
+      expect(result[:state]).to eq(:pending)
+      expect(result[:steps].size).to eq(1)
+    end
+
+    it 'returns error for unknown simulation' do
+      result = client.assess_mental_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+  end
+
+  describe '#favorable_simulations_report' do
+    it 'returns a report with count' do
+      sim_id = create_and_populate_simulation(favorable: true)
+      client.run_mental_simulation(simulation_id: sim_id)
+      result = client.favorable_simulations_report
+      expect(result).to include(:simulations, :count)
+      expect(result[:count]).to be >= 1
+    end
+
+    it 'returns count: 0 when no favorable simulations exist' do
+      result = client.favorable_simulations_report
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#failed_simulations_report' do
+    it 'returns a report with count' do
+      sim_id = create_and_populate_simulation(favorable: false)
+      client.run_mental_simulation(simulation_id: sim_id)
+      result = client.failed_simulations_report
+      expect(result).to include(:simulations, :count)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#riskiest_simulations_report' do
+    it 'returns a report with simulations and count' do
+      sim_id = create_and_populate_simulation
+      client.add_simulation_step(simulation_id: sim_id, action: 'risky op', risk: 0.9)
+      result = client.riskiest_simulations_report
+      expect(result).to include(:simulations, :count)
+    end
+
+    it 'accepts a limit parameter' do
+      3.times { client.create_mental_simulation(label: 'sim', domain: :app) }
+      result = client.riskiest_simulations_report(limit: 2)
+      expect(result[:count]).to be <= 2
+    end
+  end
+
+  describe '#mental_simulation_stats' do
+    it 'returns stats hash without simulations list' do
+      client.create_mental_simulation(label: 'one', domain: :app)
+      result = client.mental_simulation_stats
+      expect(result).to include(:total_simulations, :history_size, :favorable_count, :failed_count)
+      expect(result).not_to have_key(:simulations)
+    end
+
+    it 'reflects created simulations' do
+      client.create_mental_simulation(label: 'a', domain: :app)
+      client.create_mental_simulation(label: 'b', domain: :app)
+      result = client.mental_simulation_stats
+      expect(result[:total_simulations]).to eq(2)
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Origami::Client do
+  let(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates an OrigamiEngine by default' do
+      expect(client.engine).to be_a(Legion::Extensions::Agentic::Imagination::Origami::Helpers::OrigamiEngine)
+    end
+
+    it 'accepts an injected engine' do
+      custom_engine = Legion::Extensions::Agentic::Imagination::Origami::Helpers::OrigamiEngine.new
+      c = described_class.new(engine: custom_engine)
+      expect(c.engine).to eq(custom_engine)
+    end
+  end
+
+  describe '#create' do
+    it 'creates a figure through the client engine' do
+      result = client.create(domain: 'biology', content: 'cell division')
+      expect(result[:success]).to be true
+      expect(result[:figure][:domain]).to eq('biology')
+    end
+
+    it 'returns an error for invalid input' do
+      result = client.create(domain: '', content: 'test')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#fold' do
+    let(:figure_id) do
+      result = client.create(domain: 'physics', content: 'spacetime curvature')
+      result[:figure][:id]
+    end
+
+    it 'folds the figure' do
+      result = client.fold(id: figure_id, fold_type: :valley, axis: 'temporal')
+      expect(result[:success]).to be true
+      expect(result[:fold_count]).to eq(1)
+    end
+
+    it 'returns error for unknown figure' do
+      result = client.fold(id: 'unknown', fold_type: :valley, axis: 'x')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#unfold' do
+    let(:figure_id) do
+      result = client.create(domain: 'chemistry', content: 'molecular bonding')
+      id = result[:figure][:id]
+      client.fold(id: id, fold_type: :mountain, axis: 'spatial')
+      id
+    end
+
+    it 'unfolds the figure' do
+      result = client.unfold(id: figure_id)
+      expect(result[:success]).to be true
+      expect(result[:fully_unfolded]).to be true
+    end
+  end
+
+  describe '#list_figures' do
+    it 'lists all figures in the client engine' do
+      client.create(domain: 'art', content: 'color theory')
+      client.create(domain: 'music', content: 'harmony')
+      result = client.list_figures
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#origami_status' do
+    it 'returns status report' do
+      client.create(domain: 'philosophy', content: 'epistemology')
+      result = client.origami_status
+      expect(result[:success]).to be true
+      expect(result[:report][:figure_count]).to eq(1)
+    end
+  end
+
+  describe 'full lifecycle' do
+    it 'creates, folds, status, unfolds, and verifies' do
+      create_result = client.create(domain: 'cognition', content: 'working memory')
+      id = create_result[:figure][:id]
+
+      3.times { |i| client.fold(id: id, fold_type: :valley, axis: "axis#{i}") }
+      status = client.origami_status
+      expect(status[:report][:total_folds]).to eq(3)
+
+      client.unfold(id: id)
+      figures = client.list_figures
+      target = figures[:figures].find { |f| f[:id] == id }
+      expect(target[:fold_count]).to eq(2)
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Origami::Helpers::Constants do
+  describe 'FOLD_TYPES' do
+    it 'contains the five fold types' do
+      expect(described_class::FOLD_TYPES).to eq(%i[valley mountain reverse squash petal])
+    end
+
+    it 'is frozen' do
+      expect(described_class::FOLD_TYPES).to be_frozen
+    end
+  end
+
+  describe 'MAX_FOLDS' do
+    it 'is 12' do
+      expect(described_class::MAX_FOLDS).to eq(12)
+    end
+  end
+
+  describe 'MAX_FIGURES' do
+    it 'is 100' do
+      expect(described_class::MAX_FIGURES).to eq(100)
+    end
+  end
+
+  describe 'COMPLEXITY_LABELS' do
+    it 'returns :simple for fold counts 0..2' do
+      (0..2).each do |n|
+        label = described_class::COMPLEXITY_LABELS.find { |range, _| range.include?(n) }
+        expect(label[1]).to eq(:simple)
+      end
+    end
+
+    it 'returns :moderate for fold counts 3..5' do
+      (3..5).each do |n|
+        label = described_class::COMPLEXITY_LABELS.find { |range, _| range.include?(n) }
+        expect(label[1]).to eq(:moderate)
+      end
+    end
+
+    it 'returns :complex for fold counts 6..8' do
+      (6..8).each do |n|
+        label = described_class::COMPLEXITY_LABELS.find { |range, _| range.include?(n) }
+        expect(label[1]).to eq(:complex)
+      end
+    end
+
+    it 'returns :intricate for fold counts 9..11' do
+      (9..11).each do |n|
+        label = described_class::COMPLEXITY_LABELS.find { |range, _| range.include?(n) }
+        expect(label[1]).to eq(:intricate)
+      end
+    end
+
+    it 'returns :transcendent for fold count 12' do
+      label = described_class::COMPLEXITY_LABELS.find { |range, _| range.include?(12) }
+      expect(label[1]).to eq(:transcendent)
+    end
+
+    it 'is frozen' do
+      expect(described_class::COMPLEXITY_LABELS).to be_frozen
+    end
+  end
+
+  describe 'CREASE_DECAY' do
+    it 'is 0.01' do
+      expect(described_class::CREASE_DECAY).to eq(0.01)
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/origami/helpers/crease_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Origami::Helpers::Crease do
+  let(:crease) { described_class.new(fold_type: :valley, axis: 'horizontal', depth: 1) }
+
+  describe '#initialize' do
+    it 'stores fold_type, axis, depth, and sharpness' do
+      expect(crease.fold_type).to eq(:valley)
+      expect(crease.axis).to eq('horizontal')
+      expect(crease.depth).to eq(1)
+      expect(crease.sharpness).to eq(1.0)
+    end
+
+    it 'accepts a custom sharpness' do
+      c = described_class.new(fold_type: :mountain, axis: 'diagonal', depth: 2, sharpness: 0.5)
+      expect(c.sharpness).to eq(0.5)
+    end
+
+    it 'clamps sharpness to 0.0..1.0' do
+      high = described_class.new(fold_type: :petal, axis: 'x', depth: 1, sharpness: 2.0)
+      low  = described_class.new(fold_type: :petal, axis: 'x', depth: 1, sharpness: -1.0)
+      expect(high.sharpness).to eq(1.0)
+      expect(low.sharpness).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for unknown fold_type' do
+      expect { described_class.new(fold_type: :invalid, axis: 'x', depth: 1) }
+        .to raise_error(ArgumentError, /Unknown fold_type/)
+    end
+
+    it 'raises ArgumentError for empty axis' do
+      expect { described_class.new(fold_type: :valley, axis: '', depth: 1) }
+        .to raise_error(ArgumentError, /axis/)
+    end
+
+    it 'raises ArgumentError for non-string axis' do
+      expect { described_class.new(fold_type: :valley, axis: :horizontal, depth: 1) }
+        .to raise_error(ArgumentError, /axis/)
+    end
+
+    it 'raises ArgumentError for depth zero' do
+      expect { described_class.new(fold_type: :valley, axis: 'x', depth: 0) }
+        .to raise_error(ArgumentError, /depth/)
+    end
+
+    it 'raises ArgumentError for negative depth' do
+      expect { described_class.new(fold_type: :valley, axis: 'x', depth: -1) }
+        .to raise_error(ArgumentError, /depth/)
+    end
+
+    it 'accepts all valid fold_types' do
+      Legion::Extensions::Agentic::Imagination::Origami::Helpers::Constants::FOLD_TYPES.each do |ft|
+        c = described_class.new(fold_type: ft, axis: 'test', depth: 1)
+        expect(c.fold_type).to eq(ft)
+      end
+    end
+  end
+
+  describe '#soften!' do
+    it 'reduces sharpness by CREASE_DECAY by default' do
+      rate = Legion::Extensions::Agentic::Imagination::Origami::Helpers::Constants::CREASE_DECAY
+      original = crease.sharpness
+      crease.soften!
+      expect(crease.sharpness).to be_within(0.0001).of(original - rate)
+    end
+
+    it 'accepts a custom rate' do
+      crease.soften!(0.1)
+      expect(crease.sharpness).to be_within(0.0001).of(0.9)
+    end
+
+    it 'clamps sharpness to 0.0' do
+      10.times { crease.soften!(0.2) }
+      expect(crease.sharpness).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(crease.soften!).to eq(crease)
+    end
+  end
+
+  describe '#sharp?' do
+    it 'returns true when sharpness >= 0.6' do
+      c = described_class.new(fold_type: :valley, axis: 'x', depth: 1, sharpness: 0.6)
+      expect(c.sharp?).to be true
+    end
+
+    it 'returns false when sharpness < 0.6' do
+      c = described_class.new(fold_type: :valley, axis: 'x', depth: 1, sharpness: 0.5)
+      expect(c.sharp?).to be false
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns true when sharpness <= 0.1' do
+      c = described_class.new(fold_type: :valley, axis: 'x', depth: 1, sharpness: 0.1)
+      expect(c.faded?).to be true
+    end
+
+    it 'returns false when sharpness > 0.1' do
+      c = described_class.new(fold_type: :valley, axis: 'x', depth: 1, sharpness: 0.5)
+      expect(c.faded?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = crease.to_h
+      expect(h[:fold_type]).to eq(:valley)
+      expect(h[:axis]).to eq('horizontal')
+      expect(h[:depth]).to eq(1)
+      expect(h[:sharpness]).to eq(1.0)
+    end
+
+    it 'rounds sharpness to 10 decimal places' do
+      crease.soften!(0.333)
+      h = crease.to_h
+      expect(h[:sharpness].to_s.length).to be <= 12
+    end
+  end
+end