lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/switching/helpers/switching_engine_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Switching::Helpers::SwitchingEngine do
+  subject(:engine) { described_class.new }
+
+  let(:coding) { engine.register_task(name: 'coding', task_type: :analytical, complexity: 0.7) }
+  let(:writing) { engine.register_task(name: 'writing', task_type: :creative, complexity: 0.5) }
+  let(:chatting) { engine.register_task(name: 'chatting', task_type: :social, complexity: 0.3) }
+
+  describe '#register_task' do
+    it 'creates a task set' do
+      task = engine.register_task(name: 'test')
+      expect(task).to be_a(Legion::Extensions::Agentic::Attention::Switching::Helpers::TaskSet)
+    end
+  end
+
+  describe '#activate_task' do
+    it 'activates the task' do
+      engine.activate_task(task_id: coding.id)
+      expect(coding.ready?).to be true
+    end
+
+    it 'returns nil for unknown task' do
+      expect(engine.activate_task(task_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#switch_to' do
+    it 'switches between tasks' do
+      engine.activate_task(task_id: coding.id)
+      result = engine.switch_to(task_id: writing.id)
+      expect(result[:task][:id]).to eq(writing.id)
+      expect(result[:switch_event]).not_to be_nil
+    end
+
+    it 'records switch cost' do
+      engine.activate_task(task_id: coding.id)
+      result = engine.switch_to(task_id: writing.id)
+      expect(result[:switch_event][:switch_cost]).to be > 0
+    end
+
+    it 'creates residual on previous task' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      expect(coding.residual?).to be true
+    end
+
+    it 'returns nil for unknown task' do
+      expect(engine.switch_to(task_id: 'bad')).to be_nil
+    end
+
+    it 'has no switch event for first activation' do
+      result = engine.switch_to(task_id: coding.id)
+      expect(result[:switch_event]).to be_nil
+    end
+  end
+
+  describe '#warmup_active' do
+    it 'increases active task readiness' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      engine.switch_to(task_id: coding.id)
+      # After switching back, warmup the task
+      initial = coding.readiness
+      engine.warmup_active
+      expect(coding.readiness).to be >= initial
+    end
+
+    it 'returns nil with no active task' do
+      expect(engine.warmup_active).to be_nil
+    end
+  end
+
+  describe '#decay_all_residuals!' do
+    it 'reduces residual on deactivated tasks' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      original = coding.residual_activation
+      engine.decay_all_residuals!
+      expect(coding.residual_activation).to be < original
+    end
+  end
+
+  describe '#active_task' do
+    it 'returns nil initially' do
+      expect(engine.active_task).to be_nil
+    end
+
+    it 'returns active task after activation' do
+      engine.activate_task(task_id: coding.id)
+      expect(engine.active_task.id).to eq(coding.id)
+    end
+  end
+
+  describe '#tasks_with_residual' do
+    it 'returns tasks with residual activation' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      expect(engine.tasks_with_residual.map(&:id)).to include(coding.id)
+    end
+  end
+
+  describe '#average_switch_cost' do
+    it 'returns default with no switches' do
+      default = Legion::Extensions::Agentic::Attention::Switching::Helpers::Constants::DEFAULT_SWITCH_COST
+      expect(engine.average_switch_cost).to eq(default)
+    end
+
+    it 'computes average after switches' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      engine.switch_to(task_id: chatting.id)
+      expect(engine.average_switch_cost).to be > 0
+    end
+  end
+
+  describe '#switch_cost_between' do
+    it 'returns average cost for a specific pair' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      cost = engine.switch_cost_between(from_id: coding.id, to_id: writing.id)
+      expect(cost).to be > 0
+    end
+
+    it 'returns nil for unknown pair' do
+      expect(engine.switch_cost_between(from_id: 'a', to_id: 'b')).to be_nil
+    end
+  end
+
+  describe '#most_costly_pair' do
+    it 'returns nil with no switches' do
+      expect(engine.most_costly_pair).to be_nil
+    end
+
+    it 'returns the highest cost event' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      expect(engine.most_costly_pair).to be_a(Legion::Extensions::Agentic::Attention::Switching::Helpers::SwitchEvent)
+    end
+  end
+
+  describe '#switching_report' do
+    it 'returns comprehensive report' do
+      engine.activate_task(task_id: coding.id)
+      engine.switch_to(task_id: writing.id)
+      report = engine.switching_report
+      expect(report).to include(
+        :total_tasks, :total_switches, :active_task,
+        :average_switch_cost, :costly_count, :cheap_count,
+        :residual_count, :recent_switches
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_tasks, :total_switches, :active_task_id,
+        :average_switch_cost, :residual_count
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/switching/helpers/task_set_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Switching::Helpers::TaskSet do
+  subject(:task) { described_class.new(name: 'coding') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(task.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets name' do
+      expect(task.name).to eq('coding')
+    end
+
+    it 'defaults to analytical type' do
+      expect(task.task_type).to eq(:analytical)
+    end
+
+    it 'defaults complexity to 0.5' do
+      expect(task.complexity).to eq(0.5)
+    end
+
+    it 'starts with zero readiness' do
+      expect(task.readiness).to eq(0.0)
+    end
+
+    it 'starts with zero residual' do
+      expect(task.residual_activation).to eq(0.0)
+    end
+
+    it 'clamps high complexity' do
+      high = described_class.new(name: 'x', complexity: 5.0)
+      expect(high.complexity).to eq(1.0)
+    end
+  end
+
+  describe '#activate!' do
+    it 'sets readiness to 1.0' do
+      task.activate!
+      expect(task.readiness).to eq(1.0)
+    end
+
+    it 'clears residual activation' do
+      task.activate!
+      expect(task.residual_activation).to eq(0.0)
+    end
+
+    it 'increments activation count' do
+      task.activate!
+      expect(task.activation_count).to eq(1)
+    end
+  end
+
+  describe '#deactivate!' do
+    it 'transfers readiness to residual' do
+      task.activate!
+      task.deactivate!
+      expect(task.residual_activation).to eq(1.0)
+      expect(task.readiness).to eq(0.0)
+    end
+  end
+
+  describe '#warmup!' do
+    it 'increases readiness' do
+      task.warmup!
+      expect(task.readiness).to be > 0.0
+    end
+
+    it 'clamps at 1.0' do
+      10.times { task.warmup! }
+      expect(task.readiness).to eq(1.0)
+    end
+  end
+
+  describe '#decay_residual!' do
+    it 'reduces residual activation' do
+      task.activate!
+      task.deactivate!
+      original = task.residual_activation
+      task.decay_residual!
+      expect(task.residual_activation).to be < original
+    end
+
+    it 'does not go below zero' do
+      task.decay_residual!
+      expect(task.residual_activation).to eq(0.0)
+    end
+  end
+
+  describe '#ready?' do
+    it 'is false initially' do
+      expect(task.ready?).to be false
+    end
+
+    it 'is true after activation' do
+      task.activate!
+      expect(task.ready?).to be true
+    end
+  end
+
+  describe '#residual?' do
+    it 'is false initially' do
+      expect(task.residual?).to be false
+    end
+
+    it 'is true after deactivation' do
+      task.activate!
+      task.deactivate!
+      expect(task.residual?).to be true
+    end
+  end
+
+  describe '#readiness_label' do
+    it 'returns unprepared initially' do
+      expect(task.readiness_label).to eq(:unprepared)
+    end
+
+    it 'returns fully_ready when activated' do
+      task.activate!
+      expect(task.readiness_label).to eq(:fully_ready)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = task.to_h
+      expect(hash).to include(
+        :id, :name, :task_type, :complexity, :readiness,
+        :readiness_label, :residual_activation, :residual_label,
+        :ready, :has_residual, :activation_count, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/synesthesia/client_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/synesthesia/client'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:register_mapping)
+    expect(client).to respond_to(:trigger)
+    expect(client).to respond_to(:decay_mappings)
+    expect(client).to respond_to(:cross_modal_richness)
+    expect(client).to respond_to(:dominant_modality_pairs)
+    expect(client).to respond_to(:event_history)
+    expect(client).to respond_to(:modality_coverage)
+    expect(client).to respond_to(:synesthesia_report)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SynesthesiaEngine.new
+    c = described_class.new(engine: engine)
+    c.register_mapping(source_modality: :auditory, target_modality: :visual,
+                       trigger_pattern: {}, response_pattern: {})
+    expect(engine.mappings.size).to eq(1)
+  end
+
+  it 'maintains state across calls' do
+    client.register_mapping(source_modality: :auditory, target_modality: :visual,
+                            trigger_pattern: { freq: :high }, response_pattern: { color: :red },
+                            strength: 0.7)
+    client.trigger(source_modality: :auditory, input: { note: :A4 })
+    report = client.synesthesia_report
+    expect(report[:mapping_count]).to eq(1)
+    expect(report[:event_count]).to eq(1)
+  end
+
+  it 'runs a full cross-modal cycle' do
+    client.register_mapping(source_modality: :semantic, target_modality: :visual,
+                            trigger_pattern: { concept: :danger }, response_pattern: { hue: :red },
+                            strength: 0.8)
+    client.register_mapping(source_modality: :semantic, target_modality: :emotional,
+                            trigger_pattern: { concept: :danger }, response_pattern: { tone: :fear },
+                            strength: 0.7)
+
+    events = client.trigger(source_modality: :semantic, input: { concept: :danger })
+    expect(events[:triggered_count]).to eq(2)
+
+    richness = client.cross_modal_richness
+    expect(richness[:richness]).to be > 0.0
+
+    coverage = client.modality_coverage
+    expect(coverage[:covered_modalities]).to include(:semantic, :visual, :emotional)
+
+    history = client.event_history(limit: 5)
+    expect(history[:count]).to eq(2)
+  end
+end

data/spec/legion/extensions/agentic/attention/synesthesia/helpers/constants_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::Constants do
+  describe 'constants' do
+    it 'defines MAX_MAPPINGS' do
+      expect(described_class::MAX_MAPPINGS).to eq(200)
+    end
+
+    it 'defines MAX_EVENTS' do
+      expect(described_class::MAX_EVENTS).to eq(500)
+    end
+
+    it 'defines DEFAULT_STRENGTH' do
+      expect(described_class::DEFAULT_STRENGTH).to eq(0.5)
+    end
+
+    it 'defines STRENGTH_BOOST' do
+      expect(described_class::STRENGTH_BOOST).to eq(0.1)
+    end
+
+    it 'defines STRENGTH_DECAY' do
+      expect(described_class::STRENGTH_DECAY).to eq(0.02)
+    end
+
+    it 'defines TRIGGER_THRESHOLD' do
+      expect(described_class::TRIGGER_THRESHOLD).to eq(0.3)
+    end
+
+    it 'defines 8 modalities' do
+      expect(described_class::MODALITIES.size).to eq(8)
+    end
+
+    it 'includes all expected modalities' do
+      expect(described_class::MODALITIES).to include(:visual, :auditory, :tactile, :emotional,
+                                                     :semantic, :temporal, :spatial, :abstract)
+    end
+
+    it 'defines STRENGTH_LABELS with range keys' do
+      expect(described_class::STRENGTH_LABELS).to be_a(Hash)
+      expect(described_class::STRENGTH_LABELS.values).to include(:dominant, :strong, :moderate, :faint, :trace)
+    end
+
+    it 'defines RICHNESS_LABELS with range keys' do
+      expect(described_class::RICHNESS_LABELS).to be_a(Hash)
+      expect(described_class::RICHNESS_LABELS.values).to include(:synesthetic, :vivid, :partial, :sparse, :amodal)
+    end
+
+    it 'defines INTENSITY_LABELS with range keys' do
+      expect(described_class::INTENSITY_LABELS).to be_a(Hash)
+      expect(described_class::INTENSITY_LABELS.values).to include(:overwhelming, :intense, :moderate, :subtle, :subliminal)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns dominant for value 0.9' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, 0.9)).to eq(:dominant)
+    end
+
+    it 'returns strong for value 0.7' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, 0.7)).to eq(:strong)
+    end
+
+    it 'returns moderate for value 0.5' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, 0.5)).to eq(:moderate)
+    end
+
+    it 'returns faint for value 0.3' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, 0.3)).to eq(:faint)
+    end
+
+    it 'returns trace for value 0.1' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, 0.1)).to eq(:trace)
+    end
+
+    it 'returns unknown for nil' do
+      expect(described_class.label_for(described_class::STRENGTH_LABELS, nil)).to eq(:unknown)
+    end
+
+    it 'works with RICHNESS_LABELS' do
+      expect(described_class.label_for(described_class::RICHNESS_LABELS, 0.9)).to eq(:synesthetic)
+      expect(described_class.label_for(described_class::RICHNESS_LABELS, 0.1)).to eq(:amodal)
+    end
+
+    it 'works with INTENSITY_LABELS' do
+      expect(described_class.label_for(described_class::INTENSITY_LABELS, 0.9)).to eq(:overwhelming)
+      expect(described_class.label_for(described_class::INTENSITY_LABELS, 0.1)).to eq(:subliminal)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/synesthesia/helpers/sensory_mapping_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Synesthesia::Helpers::SensoryMapping do
+  subject(:mapping) do
+    described_class.new(
+      source_modality:  :auditory,
+      target_modality:  :visual,
+      trigger_pattern:  { frequency: :high },
+      response_pattern: { color: :bright_red },
+      strength:         0.6
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(mapping.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores source_modality' do
+      expect(mapping.source_modality).to eq(:auditory)
+    end
+
+    it 'stores target_modality' do
+      expect(mapping.target_modality).to eq(:visual)
+    end
+
+    it 'stores trigger_pattern' do
+      expect(mapping.trigger_pattern).to eq({ frequency: :high })
+    end
+
+    it 'stores response_pattern' do
+      expect(mapping.response_pattern).to eq({ color: :bright_red })
+    end
+
+    it 'clamps strength to [0, 1]' do
+      over  = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                  trigger_pattern: {}, response_pattern: {}, strength: 1.5)
+      under = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                  trigger_pattern: {}, response_pattern: {}, strength: -0.5)
+      expect(over.strength).to eq(1.0)
+      expect(under.strength).to eq(0.0)
+    end
+
+    it 'initializes activation_count to 0' do
+      expect(mapping.activation_count).to eq(0)
+    end
+
+    it 'sets created_at' do
+      expect(mapping.created_at).to be_a(Time)
+    end
+
+    it 'last_activated_at is nil initially' do
+      expect(mapping.last_activated_at).to be_nil
+    end
+  end
+
+  describe '#activate!' do
+    it 'increments activation_count' do
+      expect { mapping.activate! }.to change(mapping, :activation_count).by(1)
+    end
+
+    it 'boosts strength by STRENGTH_BOOST' do
+      before = mapping.strength
+      mapping.activate!
+      expect(mapping.strength).to be_within(0.001).of((before + 0.1).clamp(0.0, 1.0))
+    end
+
+    it 'clamps strength to 1.0' do
+      strong = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                   trigger_pattern: {}, response_pattern: {}, strength: 0.95)
+      strong.activate!
+      expect(strong.strength).to eq(1.0)
+    end
+
+    it 'sets last_activated_at' do
+      mapping.activate!
+      expect(mapping.last_activated_at).to be_a(Time)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces strength by STRENGTH_DECAY' do
+      before = mapping.strength
+      mapping.decay!
+      expect(mapping.strength).to be_within(0.001).of((before - 0.02).clamp(0.0, 1.0))
+    end
+
+    it 'does not go below 0.0' do
+      weak = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                 trigger_pattern: {}, response_pattern: {}, strength: 0.01)
+      weak.decay!
+      expect(weak.strength).to eq(0.0)
+    end
+  end
+
+  describe '#active?' do
+    it 'returns true when strength >= TRIGGER_THRESHOLD' do
+      expect(mapping.active?).to be true
+    end
+
+    it 'returns false when strength < TRIGGER_THRESHOLD' do
+      weak = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                 trigger_pattern: {}, response_pattern: {}, strength: 0.1)
+      expect(weak.active?).to be false
+    end
+  end
+
+  describe '#strength_label' do
+    it 'returns :strong for strength 0.6' do
+      expect(mapping.strength_label).to eq(:strong)
+    end
+
+    it 'returns :trace for low strength' do
+      weak = described_class.new(source_modality: :visual, target_modality: :auditory,
+                                 trigger_pattern: {}, response_pattern: {}, strength: 0.1)
+      expect(weak.strength_label).to eq(:trace)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = mapping.to_h
+      expect(h).to include(:id, :source_modality, :target_modality, :trigger_pattern,
+                           :response_pattern, :strength, :activation_count, :strength_label,
+                           :active, :created_at, :last_activated_at)
+    end
+
+    it 'reflects activation state after activate!' do
+      mapping.activate!
+      h = mapping.to_h
+      expect(h[:activation_count]).to eq(1)
+      expect(h[:last_activated_at]).to be_a(Time)
+    end
+  end
+end