lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/defusion/client_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Defusion::Client do
+  let(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a client with a default engine' do
+      expect(client).to respond_to(:register_thought)
+    end
+
+    it 'accepts an injected engine' do
+      engine = Legion::Extensions::Agentic::Affect::Defusion::Helpers::DefusionEngine.new
+      c      = described_class.new(engine: engine)
+      expect(c).to respond_to(:register_thought)
+    end
+  end
+
+  describe 'runner method delegation' do
+    it 'responds to all runner methods' do
+      %i[
+        register_thought apply_defusion apply_all_techniques visit_thought
+        fuse_thought enmeshed_thoughts defused_thoughts ruminating_thoughts
+        most_fused recommend_technique defusion_report defusion_state
+      ].each do |method|
+        expect(client).to respond_to(method)
+      end
+    end
+  end
+
+  describe 'full workflow integration' do
+    it 'registers, defuses, and reports on a thought cycle' do
+      # Register a fused thought
+      reg = client.register_thought(content: 'I am not good enough', thought_type: :self_concept, belief_strength: 0.9)
+      expect(reg[:success]).to be true
+      tid = reg[:thought_id]
+
+      # Recommend a technique
+      rec = client.recommend_technique(thought_id: tid)
+      expect(rec[:technique]).to eq(:distancing)
+
+      # Apply defusion
+      defused = client.apply_defusion(thought_id: tid, technique: rec[:technique])
+      expect(defused[:success]).to be true
+      expect(defused[:after]).to be < defused[:before]
+
+      # Check report
+      report = client.defusion_report
+      expect(report[:total_thoughts]).to eq(1)
+      expect(report[:defusion_attempts]).to eq(1)
+      expect(report[:defusion_effectiveness]).to be > 0.0
+    end
+
+    it 'tracks enmeshed and defused thoughts over multiple operations' do
+      # Register two thoughts
+      t1 = client.register_thought(content: 'thought 1', thought_type: :belief, belief_strength: 0.8)
+      t2 = client.register_thought(content: 'thought 2', thought_type: :judgment, belief_strength: 0.6)
+
+      # Fully defuse t1
+      20.times { client.apply_defusion(thought_id: t1[:thought_id], technique: :acceptance) }
+
+      # t2 remains enmeshed
+      enmeshed = client.enmeshed_thoughts
+      defused  = client.defused_thoughts
+
+      expect(enmeshed[:count]).to eq(1)
+      expect(defused[:count]).to eq(1)
+      expect(enmeshed[:thoughts].first[:id]).to eq(t2[:thought_id])
+    end
+
+    it 'detects rumination after repeated visits' do
+      reg = client.register_thought(content: 'am I enough?', thought_type: :evaluation, belief_strength: 0.6)
+      tid = reg[:thought_id]
+
+      Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::RUMINATION_COUNT.times { client.visit_thought(thought_id: tid) }
+
+      rum = client.ruminating_thoughts
+      expect(rum[:count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/defusion/helpers/constants_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants do
+  let(:mod) { described_class }
+
+  describe 'DEFUSION_TECHNIQUES' do
+    it 'contains expected techniques' do
+      expect(mod::DEFUSION_TECHNIQUES).to include(:labeling, :distancing, :contextualization, :acceptance, :reframing, :metaphor)
+    end
+
+    it 'is frozen' do
+      expect(mod::DEFUSION_TECHNIQUES).to be_frozen
+    end
+  end
+
+  describe 'TECHNIQUE_POTENCY' do
+    it 'has a potency for every technique' do
+      mod::DEFUSION_TECHNIQUES.each do |technique|
+        expect(mod::TECHNIQUE_POTENCY).to have_key(technique)
+      end
+    end
+
+    it 'has acceptance as highest potency' do
+      expect(mod::TECHNIQUE_POTENCY[:acceptance]).to eq(0.15)
+    end
+
+    it 'has metaphor as lowest potency' do
+      expect(mod::TECHNIQUE_POTENCY[:metaphor]).to eq(0.06)
+    end
+  end
+
+  describe 'FUSION_LABELS' do
+    it 'labels 0.9 as enmeshed' do
+      label = mod::FUSION_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:enmeshed)
+    end
+
+    it 'labels 0.7 as fused' do
+      label = mod::FUSION_LABELS.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:fused)
+    end
+
+    it 'labels 0.5 as partially_fused' do
+      label = mod::FUSION_LABELS.find { |range, _| range.cover?(0.5) }&.last
+      expect(label).to eq(:partially_fused)
+    end
+
+    it 'labels 0.1 as fully_defused' do
+      label = mod::FUSION_LABELS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:fully_defused)
+    end
+  end
+
+  describe 'BELIEF_LABELS' do
+    it 'labels 0.9 as entrenched' do
+      label = mod::BELIEF_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:entrenched)
+    end
+
+    it 'labels 0.15 as negligible' do
+      label = mod::BELIEF_LABELS.find { |range, _| range.cover?(0.15) }&.last
+      expect(label).to eq(:negligible)
+    end
+  end
+
+  describe 'THOUGHT_TYPES' do
+    it 'includes all expected types' do
+      expect(mod::THOUGHT_TYPES).to include(:belief, :assumption, :evaluation, :prediction, :judgment, :self_concept, :rule)
+    end
+
+    it 'is frozen' do
+      expect(mod::THOUGHT_TYPES).to be_frozen
+    end
+  end
+
+  describe 'RECOMMENDED_TECHNIQUES' do
+    it 'maps every thought type to a valid technique' do
+      mod::THOUGHT_TYPES.each do |type|
+        technique = mod::RECOMMENDED_TECHNIQUES[type]
+        expect(mod::DEFUSION_TECHNIQUES).to include(technique), "No valid technique for #{type}"
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/defusion/helpers/defusion_engine_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Defusion::Helpers::DefusionEngine do
+  let(:engine) { described_class.new }
+
+  def register(content: 'I must be perfect', thought_type: :belief, belief_strength: 0.8)
+    engine.register_thought(content: content, thought_type: thought_type, belief_strength: belief_strength)
+  end
+
+  describe '#register_thought' do
+    it 'creates a thought and returns its id' do
+      result = register
+      expect(result[:thought_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:thought]).to be_a(Hash)
+    end
+
+    it 'stores the thought in the engine' do
+      result = register
+      expect(engine.thoughts).to have_key(result[:thought_id])
+    end
+
+    it 'returns error for invalid thought_type' do
+      result = engine.register_thought(content: 'x', thought_type: :invalid_type, belief_strength: 0.5)
+      expect(result[:error]).to eq(:invalid_thought_type)
+      expect(result[:valid]).to eq(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::THOUGHT_TYPES)
+    end
+
+    it 'accepts all valid thought types' do
+      Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::THOUGHT_TYPES.each do |type|
+        result = engine.register_thought(content: "thought #{type}", thought_type: type, belief_strength: 0.5)
+        expect(result[:thought_id]).not_to be_nil
+      end
+    end
+  end
+
+  describe '#apply_defusion' do
+    let(:thought_id) { register[:thought_id] }
+
+    it 'reduces fusion and returns result' do
+      result = engine.apply_defusion(thought_id: thought_id, technique: :acceptance)
+      expect(result[:success]).to be true
+      expect(result[:after]).to be < result[:before]
+    end
+
+    it 'records the defusion in history' do
+      engine.apply_defusion(thought_id: thought_id, technique: :labeling)
+      expect(engine.defusion_history.size).to eq(1)
+      expect(engine.defusion_history.first[:technique]).to eq(:labeling)
+    end
+
+    it 'returns error for unknown thought_id' do
+      result = engine.apply_defusion(thought_id: 'nonexistent', technique: :labeling)
+      expect(result[:error]).to eq(:thought_not_found)
+    end
+
+    it 'returns error for invalid technique' do
+      result = engine.apply_defusion(thought_id: thought_id, technique: :voodoo)
+      expect(result[:error]).to eq(:invalid_technique)
+    end
+
+    it 'includes fusion_label in result' do
+      result = engine.apply_defusion(thought_id: thought_id, technique: :acceptance)
+      expect(result[:fusion_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#apply_all_techniques' do
+    let(:thought_id) { register[:thought_id] }
+
+    it 'applies all techniques and returns aggregated result' do
+      result = engine.apply_all_techniques(thought_id: thought_id)
+      expect(result[:total_applied]).to eq(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::DEFUSION_TECHNIQUES.size)
+      expect(result[:final_fusion]).to be_a(Float)
+    end
+
+    it 'significantly reduces fusion' do
+      initial = engine.thoughts[thought_id].fusion_level
+      engine.apply_all_techniques(thought_id: thought_id)
+      expect(engine.thoughts[thought_id].fusion_level).to be < initial
+    end
+
+    it 'returns error for unknown thought_id' do
+      result = engine.apply_all_techniques(thought_id: 'nonexistent')
+      expect(result[:error]).to eq(:thought_not_found)
+    end
+  end
+
+  describe '#visit_thought' do
+    let(:thought_id) { register[:thought_id] }
+
+    it 'increments visit count' do
+      result = engine.visit_thought(thought_id: thought_id)
+      expect(result[:visit_count]).to eq(1)
+    end
+
+    it 'returns ruminating flag' do
+      result = engine.visit_thought(thought_id: thought_id)
+      expect(result).to have_key(:ruminating)
+    end
+
+    it 'returns error for unknown thought_id' do
+      result = engine.visit_thought(thought_id: 'nonexistent')
+      expect(result[:error]).to eq(:thought_not_found)
+    end
+
+    it 'becomes ruminating after RUMINATION_COUNT visits' do
+      count = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::RUMINATION_COUNT
+      count.times { engine.visit_thought(thought_id: thought_id) }
+      result = engine.visit_thought(thought_id: thought_id)
+      expect(result[:ruminating]).to be true
+    end
+  end
+
+  describe '#enmeshed_thoughts' do
+    it 'returns thoughts above fusion threshold' do
+      register
+      expect(engine.enmeshed_thoughts.size).to be >= 1
+    end
+
+    it 'excludes defused thoughts' do
+      result = register
+      tid = result[:thought_id]
+      20.times { engine.apply_defusion(thought_id: tid, technique: :acceptance) }
+      expect(engine.enmeshed_thoughts).not_to include(engine.thoughts[tid])
+    end
+  end
+
+  describe '#defused_thoughts' do
+    it 'returns empty when no thoughts are defused' do
+      register
+      expect(engine.defused_thoughts).to be_empty
+    end
+
+    it 'returns thought after full defusion' do
+      result = register
+      tid = result[:thought_id]
+      20.times { engine.apply_defusion(thought_id: tid, technique: :acceptance) }
+      expect(engine.defused_thoughts).to include(engine.thoughts[tid])
+    end
+  end
+
+  describe '#ruminating_thoughts' do
+    it 'returns empty with no visits' do
+      register
+      expect(engine.ruminating_thoughts).to be_empty
+    end
+
+    it 'returns thought after enough visits' do
+      result = register
+      tid = result[:thought_id]
+      count = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::RUMINATION_COUNT
+      count.times { engine.visit_thought(thought_id: tid) }
+      expect(engine.ruminating_thoughts).not_to be_empty
+    end
+  end
+
+  describe '#most_fused' do
+    it 'returns thoughts sorted by fusion descending' do
+      r1 = register(content: 'thought 1', thought_type: :belief, belief_strength: 0.8)
+      r2 = register(content: 'thought 2', thought_type: :judgment, belief_strength: 0.5)
+      # Defuse r2 to make r1 more fused
+      5.times { engine.apply_defusion(thought_id: r2[:thought_id], technique: :acceptance) }
+
+      top = engine.most_fused(limit: 2)
+      expect(top.first.id).to eq(r1[:thought_id])
+    end
+
+    it 'respects the limit parameter' do
+      5.times { |i| register(content: "thought #{i}", thought_type: :belief, belief_strength: 0.5) }
+      expect(engine.most_fused(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#recommend_technique' do
+    it 'returns a recommended technique for the thought type' do
+      result = register
+      rec = engine.recommend_technique(thought_id: result[:thought_id])
+      expect(rec[:technique]).to be_a(Symbol)
+      expect(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::DEFUSION_TECHNIQUES).to include(rec[:technique])
+    end
+
+    it 'recommends acceptance for belief type' do
+      result = register(thought_type: :belief)
+      rec = engine.recommend_technique(thought_id: result[:thought_id])
+      expect(rec[:technique]).to eq(:acceptance)
+    end
+
+    it 'returns error for unknown thought_id' do
+      result = engine.recommend_technique(thought_id: 'nonexistent')
+      expect(result[:error]).to eq(:thought_not_found)
+    end
+
+    it 'includes projected_fusion' do
+      result = register
+      rec = engine.recommend_technique(thought_id: result[:thought_id])
+      expect(rec[:projected_fusion]).to be < rec[:current_fusion]
+    end
+  end
+
+  describe '#average_fusion' do
+    it 'returns 0.0 with no thoughts' do
+      expect(engine.average_fusion).to eq(0.0)
+    end
+
+    it 'returns DEFAULT_FUSION when all thoughts are fresh' do
+      2.times { register }
+      expect(engine.average_fusion).to be_within(0.001).of(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::DEFAULT_FUSION)
+    end
+
+    it 'decreases as thoughts are defused' do
+      result = register
+      before_avg = engine.average_fusion
+      10.times { engine.apply_defusion(thought_id: result[:thought_id], technique: :acceptance) }
+      expect(engine.average_fusion).to be < before_avg
+    end
+  end
+
+  describe '#defusion_effectiveness' do
+    it 'returns 0.0 with no history' do
+      expect(engine.defusion_effectiveness).to eq(0.0)
+    end
+
+    it 'returns positive value after defusion attempts' do
+      result = register
+      engine.apply_defusion(thought_id: result[:thought_id], technique: :acceptance)
+      expect(engine.defusion_effectiveness).to be > 0.0
+    end
+  end
+
+  describe '#defusion_report' do
+    it 'includes all expected keys' do
+      register
+      report = engine.defusion_report
+      %i[total_thoughts enmeshed_count defused_count ruminating_count average_fusion
+         defusion_attempts defusion_effectiveness most_fused].each do |key|
+        expect(report).to have_key(key)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes thoughts, defusion_history, and report' do
+      register
+      h = engine.to_h
+      expect(h).to have_key(:thoughts)
+      expect(h).to have_key(:defusion_history)
+      expect(h).to have_key(:report)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/defusion/helpers/thought_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Defusion::Helpers::Thought do
+  let(:thought) { described_class.new(content: 'I am a failure', thought_type: :belief, belief_strength: 0.8) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(thought.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(thought.content).to eq('I am a failure')
+    end
+
+    it 'stores thought_type' do
+      expect(thought.thought_type).to eq(:belief)
+    end
+
+    it 'stores belief_strength' do
+      expect(thought.belief_strength).to eq(0.8)
+    end
+
+    it 'starts at DEFAULT_FUSION' do
+      expect(thought.fusion_level).to eq(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::DEFAULT_FUSION)
+    end
+
+    it 'starts with zero defusion_count' do
+      expect(thought.defusion_count).to eq(0)
+    end
+
+    it 'starts with zero visit_count' do
+      expect(thought.visit_count).to eq(0)
+    end
+
+    it 'clamps belief_strength above 1.0' do
+      t = described_class.new(content: 'x', thought_type: :judgment, belief_strength: 1.5)
+      expect(t.belief_strength).to eq(1.0)
+    end
+
+    it 'clamps belief_strength below 0.0' do
+      t = described_class.new(content: 'x', thought_type: :judgment, belief_strength: -0.2)
+      expect(t.belief_strength).to eq(0.0)
+    end
+  end
+
+  describe '#defuse!' do
+    it 'reduces fusion by the technique potency' do
+      potency = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::TECHNIQUE_POTENCY[:labeling]
+      result  = thought.defuse!(technique: :labeling)
+      expect(result[:reduction]).to be_within(0.0001).of(potency)
+      expect(thought.fusion_level).to be_within(0.0001).of(0.7 - potency)
+    end
+
+    it 'increments defusion_count' do
+      thought.defuse!(technique: :acceptance)
+      expect(thought.defusion_count).to eq(1)
+    end
+
+    it 'does not reduce fusion below 0.0' do
+      10.times { thought.defuse!(technique: :acceptance) }
+      expect(thought.fusion_level).to be >= 0.0
+    end
+
+    it 'returns before, after, and reduction' do
+      result = thought.defuse!(technique: :distancing)
+      expect(result).to have_key(:before)
+      expect(result).to have_key(:after)
+      expect(result).to have_key(:reduction)
+    end
+  end
+
+  describe '#fuse!' do
+    it 'increases fusion by FUSION_DELTA_FUSE' do
+      delta  = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::FUSION_DELTA_FUSE
+      before = thought.fusion_level
+      result = thought.fuse!
+      expect(result[:after]).to be_within(0.0001).of(before + delta)
+    end
+
+    it 'does not exceed 1.0' do
+      # Start from a high value
+      t = described_class.new(content: 'x', thought_type: :rule, belief_strength: 0.5)
+      20.times { t.fuse! }
+      expect(t.fusion_level).to eq(1.0)
+    end
+  end
+
+  describe '#visit!' do
+    it 'increments visit_count' do
+      thought.visit!
+      expect(thought.visit_count).to eq(1)
+    end
+
+    it 'slightly increases fusion' do
+      delta  = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::FUSION_DELTA_VISIT
+      before = thought.fusion_level
+      thought.visit!
+      expect(thought.fusion_level).to be_within(0.0001).of(before + delta)
+    end
+
+    it 'returns visit_count and fusion values' do
+      result = thought.visit!
+      expect(result).to have_key(:visit_count)
+      expect(result).to have_key(:fusion_before)
+      expect(result).to have_key(:fusion_after)
+    end
+  end
+
+  describe '#enmeshed?' do
+    it 'returns true when fusion >= FUSION_THRESHOLD' do
+      # default fusion is 0.7 which equals the threshold
+      expect(thought.enmeshed?).to be true
+    end
+
+    it 'returns false when fusion is low' do
+      10.times { thought.defuse!(technique: :acceptance) }
+      expect(thought.enmeshed?).to be false
+    end
+  end
+
+  describe '#defused?' do
+    it 'returns false at default fusion' do
+      expect(thought.defused?).to be false
+    end
+
+    it 'returns true when fusion drops below DEFUSED_THRESHOLD' do
+      20.times { thought.defuse!(technique: :acceptance) }
+      expect(thought.defused?).to be true
+    end
+  end
+
+  describe '#ruminating?' do
+    it 'returns false at zero visits' do
+      expect(thought.ruminating?).to be false
+    end
+
+    it 'returns true at RUMINATION_COUNT visits' do
+      count = Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::RUMINATION_COUNT
+      count.times { thought.visit! }
+      expect(thought.ruminating?).to be true
+    end
+  end
+
+  describe '#fusion_label' do
+    it 'returns :enmeshed at default fusion 0.7' do
+      # 0.7 is >= FUSION_THRESHOLD, but label range is 0.6...0.8 => :fused
+      # and 0.8.. => :enmeshed. 0.7 falls in fused.
+      expect(thought.fusion_label).to eq(:fused)
+    end
+
+    it 'returns :fully_defused for very low fusion' do
+      20.times { thought.defuse!(technique: :acceptance) }
+      expect(thought.fusion_label).to eq(:fully_defused)
+    end
+  end
+
+  describe '#belief_label' do
+    it 'returns :strong for belief_strength 0.8' do
+      # 0.8.. is entrenched, 0.6...0.8 is strong. 0.8 is on the boundary => entrenched
+      expect(thought.belief_label).to eq(:entrenched)
+    end
+
+    it 'returns :moderate for belief_strength 0.5' do
+      t = described_class.new(content: 'x', thought_type: :assumption, belief_strength: 0.5)
+      expect(t.belief_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = thought.to_h
+      %i[id content thought_type belief_strength fusion_level defusion_count
+         visit_count fusion_label belief_label enmeshed defused ruminating created_at].each do |key|
+        expect(h).to have_key(key)
+      end
+    end
+  end
+end