lex-agentic-language 0.1.0

data/spec/legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::ConceptualBlending::Helpers::BlendingEngine do
+  subject(:engine) { described_class.new }
+
+  let(:space_a) do
+    engine.create_space(name: 'biology', domain: 'science').tap do |s|
+      s.add_element(name: 'virus', properties: { type: :pathogen })
+      s.add_element(name: 'host', properties: { type: :organism })
+      s.add_relation(from: 'virus', to: 'host', type: :infects)
+      s.add_relation(from: 'virus', to: 'host', type: :spreads)
+    end
+  end
+
+  let(:space_b) do
+    engine.create_space(name: 'computing', domain: 'technology').tap do |s|
+      s.add_element(name: 'software', properties: { type: :program })
+      s.add_element(name: 'network', properties: { type: :infrastructure })
+      s.add_relation(from: 'software', to: 'network', type: :corrupts)
+      s.add_relation(from: 'software', to: 'network', type: :replicates)
+    end
+  end
+
+  describe '#create_space' do
+    it 'returns a MentalSpace' do
+      space = engine.create_space(name: 'test', domain: 'misc')
+      expect(space).to be_a(Legion::Extensions::Agentic::Language::ConceptualBlending::Helpers::MentalSpace)
+    end
+
+    it 'stores space internally' do
+      space = engine.create_space(name: 'test', domain: 'misc')
+      expect(engine.to_h[:spaces_count]).to eq(1)
+      space # suppress unused warning
+    end
+  end
+
+  describe '#add_element_to_space' do
+    it 'adds element to the space' do
+      space = engine.create_space(name: 's', domain: 'd')
+      engine.add_element_to_space(space_id: space.id, name: 'elem', properties: { key: :val })
+      expect(space.elements['elem']).to eq({ key: :val })
+    end
+
+    it 'raises ArgumentError for unknown space_id' do
+      expect do
+        engine.add_element_to_space(space_id: 'bad-id', name: 'x', properties: {})
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#add_relation_to_space' do
+    it 'adds relation to the space' do
+      space = engine.create_space(name: 's', domain: 'd')
+      engine.add_relation_to_space(space_id: space.id, from: 'a', to: 'b', type: :links)
+      expect(space.relations.first).to eq({ from: 'a', to: 'b', type: :links })
+    end
+
+    it 'raises ArgumentError for unknown space_id' do
+      expect do
+        engine.add_relation_to_space(space_id: 'bad-id', from: 'a', to: 'b', type: :x)
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#blend' do
+    it 'creates a Blend from two spaces' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      expect(blend).to be_a(Legion::Extensions::Agentic::Language::ConceptualBlending::Helpers::Blend)
+    end
+
+    it 'sets both input space ids' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      expect(blend.input_space_ids).to contain_exactly(space_a.id, space_b.id)
+    end
+
+    it 'uses the given blend_type' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id, blend_type: :mirror)
+      expect(blend.blend_type).to eq(:mirror)
+    end
+
+    it 'extracts generic space with shared relation types' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      expect(blend.generic_space).to have_key(:shared_relation_types)
+    end
+
+    it 'merges elements from both spaces' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      merged = blend.blended_elements[:merged_elements]
+      expect(merged).to include('virus', 'software')
+    end
+
+    it 'generates emergent properties from cross-domain relations' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      expect(blend.blended_elements[:emergent_properties]).not_to be_empty
+    end
+
+    it 'raises ArgumentError for unknown space ids' do
+      expect do
+        engine.blend(space_a_id: 'bad', space_b_id: space_b.id)
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#elaborate_blend' do
+    let(:blend) { engine.blend(space_a_id: space_a.id, space_b_id: space_b.id) }
+
+    it 'adds emergent property to blend' do
+      engine.elaborate_blend(blend_id: blend.id, emergent_property: 'computer_immune_system')
+      expect(blend.blended_elements[:emergent_properties]).to include('computer_immune_system')
+    end
+
+    it 'raises ArgumentError for unknown blend_id' do
+      expect do
+        engine.elaborate_blend(blend_id: 'bad', emergent_property: 'x')
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#compress_blend' do
+    let(:blend) { engine.blend(space_a_id: space_a.id, space_b_id: space_b.id) }
+
+    it 'reduces blend strength' do
+      original_strength = blend.strength
+      engine.compress_blend(blend_id: blend.id, removed_element: 'virus')
+      expect(blend.strength).to be < original_strength
+    end
+
+    it 'raises ArgumentError for unknown blend_id' do
+      expect do
+        engine.compress_blend(blend_id: 'bad', removed_element: 'x')
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#find_blends' do
+    it 'finds blends involving spaces from the given domain' do
+      engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      results = engine.find_blends(domain: 'science')
+      expect(results).not_to be_empty
+    end
+
+    it 'returns empty array when no matching domain' do
+      engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      results = engine.find_blends(domain: 'nonexistent')
+      expect(results).to eq([])
+    end
+  end
+
+  describe '#best_blends' do
+    it 'returns array of blends ordered by quality' do
+      engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      results = engine.best_blends(limit: 5)
+      expect(results).to be_an(Array)
+    end
+
+    it 'respects the limit' do
+      3.times { engine.blend(space_a_id: space_a.id, space_b_id: space_b.id) }
+      results = engine.best_blends(limit: 2)
+      expect(results.size).to be <= 2
+    end
+  end
+
+  describe '#blend_quality' do
+    let(:blend) { engine.blend(space_a_id: space_a.id, space_b_id: space_b.id) }
+
+    it 'returns quality assessment hash' do
+      result = engine.blend_quality(blend_id: blend.id)
+      expect(result).to include(:blend_id, :quality_score, :quality_label, :strength, :use_count, :stale)
+    end
+
+    it 'raises ArgumentError for unknown blend_id' do
+      expect do
+        engine.blend_quality(blend_id: 'bad')
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#decay_stale' do
+    it 'returns count of decayed blends' do
+      engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      count = engine.decay_stale
+      expect(count).to be_a(Integer)
+    end
+  end
+
+  describe '#prune_weak' do
+    it 'returns count of pruned blends' do
+      pruned = engine.prune_weak
+      expect(pruned).to be_a(Integer)
+    end
+
+    it 'removes blends with strength below 0.1' do
+      blend = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id)
+      blend.instance_variable_set(:@strength, 0.05)
+      engine.prune_weak
+      expect(engine.to_h[:blends_count]).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      result = engine.to_h
+      expect(result).to include(:spaces_count, :blends_count, :best_quality)
+    end
+
+    it 'reflects current state' do
+      engine.create_space(name: 's', domain: 'd')
+      expect(engine.to_h[:spaces_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/language/conceptual_blending/helpers/mental_space_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::ConceptualBlending::Helpers::MentalSpace do
+  subject(:space) { described_class.new(name: 'biology', domain: 'science') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(space.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets name and domain' do
+      expect(space.name).to eq('biology')
+      expect(space.domain).to eq('science')
+    end
+
+    it 'starts with empty elements and relations' do
+      expect(space.elements).to eq({})
+      expect(space.relations).to eq([])
+    end
+
+    it 'records created_at timestamp' do
+      expect(space.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#add_element' do
+    it 'stores element with properties' do
+      space.add_element(name: 'virus', properties: { type: :pathogen })
+      expect(space.elements['virus']).to eq({ type: :pathogen })
+    end
+
+    it 'returns self for chaining' do
+      result = space.add_element(name: 'cell', properties: {})
+      expect(result).to eq(space)
+    end
+
+    it 'stores multiple elements' do
+      space.add_element(name: 'virus', properties: {})
+      space.add_element(name: 'host', properties: {})
+      expect(space.elements.size).to eq(2)
+    end
+  end
+
+  describe '#add_relation' do
+    it 'stores relation hash' do
+      space.add_relation(from: 'virus', to: 'host', type: :infects)
+      expect(space.relations.first).to eq({ from: 'virus', to: 'host', type: :infects })
+    end
+
+    it 'returns self for chaining' do
+      result = space.add_relation(from: 'a', to: 'b', type: :links)
+      expect(result).to eq(space)
+    end
+
+    it 'accumulates multiple relations' do
+      space.add_relation(from: 'a', to: 'b', type: :one)
+      space.add_relation(from: 'b', to: 'c', type: :two)
+      expect(space.relations.size).to eq(2)
+    end
+  end
+
+  describe '#element_names' do
+    it 'returns array of element name keys' do
+      space.add_element(name: 'alpha', properties: {})
+      space.add_element(name: 'beta', properties: {})
+      expect(space.element_names).to contain_exactly('alpha', 'beta')
+    end
+
+    it 'returns empty array when no elements' do
+      expect(space.element_names).to eq([])
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      result = space.to_h
+      expect(result).to include(:id, :name, :domain, :elements, :relations, :created_at)
+    end
+
+    it 'reflects current state' do
+      space.add_element(name: 'x', properties: { val: 1 })
+      expect(space.to_h[:elements]['x']).to eq({ val: 1 })
+    end
+  end
+end

data/spec/legion/extensions/agentic/language/conceptual_blending/runners/conceptual_blending_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/language/conceptual_blending/client'
+
+RSpec.describe Legion::Extensions::Agentic::Language::ConceptualBlending::Runners::ConceptualBlending do
+  let(:client) { Legion::Extensions::Agentic::Language::ConceptualBlending::Client.new }
+
+  let(:space_a_id) do
+    result = client.create_mental_space(name: 'biology', domain: 'science')
+    result[:space][:id]
+  end
+
+  let(:space_b_id) do
+    result = client.create_mental_space(name: 'computing', domain: 'technology')
+    result[:space][:id]
+  end
+
+  before do
+    client.add_space_element(space_id: space_a_id, name: 'virus', properties: { type: :pathogen })
+    client.add_space_relation(space_id: space_a_id, from: 'virus', to: 'host', type: :infects)
+    client.add_space_element(space_id: space_b_id, name: 'software', properties: { type: :program })
+    client.add_space_relation(space_id: space_b_id, from: 'software', to: 'network', type: :corrupts)
+  end
+
+  describe '#create_mental_space' do
+    it 'returns success with space hash' do
+      result = client.create_mental_space(name: 'test', domain: 'misc')
+      expect(result[:success]).to be true
+      expect(result[:space]).to include(:id, :name, :domain)
+    end
+  end
+
+  describe '#add_space_element' do
+    it 'returns success with space_id and element name' do
+      result = client.add_space_element(space_id: space_a_id, name: 'new_elem', properties: {})
+      expect(result[:success]).to be true
+      expect(result[:element]).to eq('new_elem')
+    end
+
+    it 'returns failure for unknown space_id' do
+      result = client.add_space_element(space_id: 'bad-id', name: 'x', properties: {})
+      expect(result[:success]).to be false
+      expect(result[:error]).to include('not found')
+    end
+  end
+
+  describe '#add_space_relation' do
+    it 'returns success with relation hash' do
+      result = client.add_space_relation(space_id: space_a_id, from: 'a', to: 'b', type: :links)
+      expect(result[:success]).to be true
+      expect(result[:relation]).to eq({ from: 'a', to: 'b', type: :links })
+    end
+
+    it 'returns failure for unknown space_id' do
+      result = client.add_space_relation(space_id: 'bad', from: 'a', to: 'b', type: :x)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_blend' do
+    it 'returns success with blend hash' do
+      result = client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id)
+      expect(result[:success]).to be true
+      expect(result[:blend]).to include(:id, :blend_type, :strength)
+    end
+
+    it 'uses provided blend_type' do
+      result = client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id, blend_type: :mirror)
+      expect(result[:blend][:blend_type]).to eq(:mirror)
+    end
+
+    it 'returns failure for unknown space ids' do
+      result = client.create_blend(space_a_id: 'bad', space_b_id: space_b_id)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#elaborate_blend' do
+    let(:blend_id) do
+      result = client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id)
+      result[:blend][:id]
+    end
+
+    it 'returns success with updated blend' do
+      result = client.elaborate_blend(blend_id: blend_id, emergent_property: 'antivirus_software')
+      expect(result[:success]).to be true
+      expect(result[:blend][:blended_elements][:emergent_properties]).to include('antivirus_software')
+    end
+
+    it 'returns failure for unknown blend_id' do
+      result = client.elaborate_blend(blend_id: 'bad', emergent_property: 'x')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#compress_blend' do
+    let(:blend_id) do
+      result = client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id)
+      result[:blend][:id]
+    end
+
+    it 'returns success with updated blend' do
+      result = client.compress_blend(blend_id: blend_id, removed_element: 'virus')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown blend_id' do
+      result = client.compress_blend(blend_id: 'bad', removed_element: 'x')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#best_blends' do
+    it 'returns success with blends array' do
+      client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id)
+      result = client.best_blends(limit: 5)
+      expect(result[:success]).to be true
+      expect(result[:blends]).to be_an(Array)
+      expect(result[:count]).to eq(result[:blends].size)
+    end
+
+    it 'returns empty array when no blends exist' do
+      fresh_client = Legion::Extensions::Agentic::Language::ConceptualBlending::Client.new
+      result = fresh_client.best_blends(limit: 5)
+      expect(result[:blends]).to eq([])
+    end
+  end
+
+  describe '#blend_quality' do
+    let(:blend_id) do
+      result = client.create_blend(space_a_id: space_a_id, space_b_id: space_b_id)
+      result[:blend][:id]
+    end
+
+    it 'returns quality assessment' do
+      result = client.blend_quality(blend_id: blend_id)
+      expect(result[:success]).to be true
+      expect(result).to include(:quality_score, :quality_label, :strength)
+    end
+
+    it 'returns failure for unknown blend_id' do
+      result = client.blend_quality(blend_id: 'bad')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#update_conceptual_blending' do
+    it 'returns success with decay and prune counts' do
+      result = client.update_conceptual_blending
+      expect(result[:success]).to be true
+      expect(result).to include(:decayed, :pruned)
+    end
+  end
+
+  describe '#conceptual_blending_stats' do
+    it 'returns success with engine stats' do
+      result = client.conceptual_blending_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:spaces_count, :blends_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/language/conceptual_metaphor/client_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::ConceptualMetaphor::Client do
+  subject(:client) { described_class.new }
+
+  it 'creates a metaphor' do
+    result = client.create_metaphor(
+      source_domain: :money, target_domain: :time,
+      metaphor_type: :structural, mappings: { spend: :waste }
+    )
+    expect(result[:success]).to be true
+  end
+
+  it 'applies a metaphor' do
+    created = client.create_metaphor(
+      source_domain: :money, target_domain: :time,
+      metaphor_type: :structural, mappings: { spend: :waste }
+    )
+    result = client.apply_metaphor(
+      metaphor_id: created[:metaphor_id], source_concept: :spend
+    )
+    expect(result[:target_concept]).to eq(:waste)
+  end
+
+  it 'returns stats' do
+    result = client.conceptual_metaphor_stats
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/language/conceptual_metaphor/helpers/metaphor_engine_spec.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::ConceptualMetaphor::Helpers::MetaphorEngine do
+  subject(:engine) { described_class.new }
+
+  let(:metaphor) do
+    engine.create_metaphor(
+      source_domain: :money,
+      target_domain: :time,
+      metaphor_type: :structural,
+      mappings:      { spend: :waste, save: :conserve }
+    )
+  end
+
+  describe '#create_metaphor' do
+    it 'creates and stores a metaphor' do
+      result = metaphor
+      expect(result).to be_a(Legion::Extensions::Agentic::Language::ConceptualMetaphor::Helpers::Metaphor)
+      expect(result.source_domain).to eq(:money)
+    end
+
+    it 'rejects invalid metaphor types' do
+      result = engine.create_metaphor(
+        source_domain: :a, target_domain: :b,
+        metaphor_type: :invalid, mappings: {}
+      )
+      expect(result[:success]).to be false
+    end
+
+    it 'records history' do
+      metaphor
+      expect(engine.history.size).to eq(1)
+    end
+  end
+
+  describe '#apply_metaphor' do
+    it 'maps a source concept to target' do
+      result = engine.apply_metaphor(metaphor_id: metaphor.id, source_concept: :spend)
+      expect(result[:mapped]).to be true
+      expect(result[:target_concept]).to eq(:waste)
+    end
+
+    it 'returns found: false for unknown metaphor' do
+      result = engine.apply_metaphor(metaphor_id: 'nonexistent', source_concept: :spend)
+      expect(result[:found]).to be false
+    end
+
+    it 'returns mapped: false for unmapped concept' do
+      result = engine.apply_metaphor(metaphor_id: metaphor.id, source_concept: :borrow)
+      expect(result[:mapped]).to be false
+    end
+  end
+
+  describe '#add_entailment' do
+    it 'adds entailment to metaphor' do
+      result = engine.add_entailment(metaphor_id: metaphor.id, entailment: 'time is valuable')
+      expect(result[:success]).to be true
+      expect(result[:entailment_count]).to eq(1)
+    end
+
+    it 'returns error for unknown metaphor' do
+      result = engine.add_entailment(metaphor_id: 'bad', entailment: 'test')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#find_by_domain' do
+    it 'finds metaphors involving the domain' do
+      metaphor
+      results = engine.find_by_domain(domain: :time)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#find_by_source' do
+    it 'finds metaphors by source domain' do
+      metaphor
+      results = engine.find_by_source(source_domain: :money)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#find_by_target' do
+    it 'finds metaphors by target domain' do
+      metaphor
+      results = engine.find_by_target(target_domain: :time)
+      expect(results.size).to eq(1)
+    end
+  end
+
+  describe '#conventional_metaphors' do
+    it 'returns metaphors with high conventionality' do
+      engine.create_metaphor(
+        source_domain: :war, target_domain: :argument,
+        metaphor_type: :structural, mappings: { attack: :criticize },
+        conventionality: 0.9
+      )
+      expect(engine.conventional_metaphors.size).to eq(1)
+    end
+  end
+
+  describe '#novel_metaphors' do
+    it 'returns metaphors with low conventionality' do
+      engine.create_metaphor(
+        source_domain: :ocean, target_domain: :emotion,
+        metaphor_type: :ontological, mappings: { depth: :intensity },
+        conventionality: 0.1
+      )
+      expect(engine.novel_metaphors.size).to eq(1)
+    end
+  end
+
+  describe '#strongest' do
+    it 'returns metaphors sorted by strength' do
+      metaphor
+      engine.create_metaphor(
+        source_domain: :war, target_domain: :argument,
+        metaphor_type: :structural, mappings: {}, strength: 0.9
+      )
+      results = engine.strongest(limit: 2)
+      expect(results.first.strength).to be >= results.last.strength
+    end
+  end
+
+  describe '#by_type' do
+    it 'filters by metaphor type' do
+      metaphor
+      engine.create_metaphor(
+        source_domain: :container, target_domain: :mind,
+        metaphor_type: :ontological, mappings: { full: :knowledgeable }
+      )
+      structural = engine.by_type(metaphor_type: :structural)
+      expect(structural.size).to eq(1)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces strength of all metaphors' do
+      original = metaphor.strength
+      engine.decay_all
+      expect(metaphor.strength).to be < original
+    end
+  end
+
+  describe '#prune_weak' do
+    it 'removes very weak metaphors' do
+      weak = engine.create_metaphor(
+        source_domain: :a, target_domain: :b,
+        metaphor_type: :structural, mappings: {}, strength: 0.03
+      )
+      30.times { weak.decay! }
+      pruned = engine.prune_weak
+      expect(pruned).to be >= 1
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats' do
+      metaphor
+      stats = engine.to_h
+      expect(stats[:total_metaphors]).to eq(1)
+      expect(stats[:total_domains]).to eq(2)
+      expect(stats).to include(:type_counts, :conventional_count, :novel_count)
+    end
+  end
+end