Module: Legion::Extensions::Agentic::Language::ConceptualMetaphor::Runners::ConceptualMetaphor

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb

Instance Method Summary collapse

Instance Method Details

#add_metaphor_entailment(metaphor_id:, entailment:) ⇒ Object 



45
46
47
48
49
50
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 45

def add_metaphor_entailment(metaphor_id:, entailment:, **)
  result = engine.add_entailment(metaphor_id: metaphor_id, entailment: entailment)
  log.debug "[conceptual_metaphor] entailment id=#{metaphor_id[0..7]} " \
            "success=#{result[:success]}"
  result
end

#apply_metaphor(metaphor_id:, source_concept:) ⇒ Object 



38
39
40
41
42
43
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 38

def apply_metaphor(metaphor_id:, source_concept:, **)
  result = engine.apply_metaphor(metaphor_id: metaphor_id, source_concept: source_concept)
  log.debug "[conceptual_metaphor] apply id=#{metaphor_id[0..7]} " \
            "concept=#{source_concept} mapped=#{result[:mapped]}"
  { success: true }.merge(result)
end

#conceptual_metaphor_stats ⇒ Object 



90
91
92
93
94
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 90

def conceptual_metaphor_stats(**)
  stats = engine.to_h
  log.debug "[conceptual_metaphor] stats total=#{stats[:total_metaphors]}"
  { success: true }.merge(stats)
end

#conventional_metaphors ⇒ Object 



58
59
60
61
62
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 58

def conventional_metaphors(**)
  metaphors = engine.conventional_metaphors
  log.debug "[conceptual_metaphor] conventional count=#{metaphors.size}"
  { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
end

#create_metaphor(source_domain:, target_domain:, metaphor_type:, mappings:, strength: nil, conventionality: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 13

def create_metaphor(source_domain:, target_domain:, metaphor_type:,
                    mappings:, strength: nil, conventionality: nil, **)
  unless Helpers::Constants::METAPHOR_TYPES.include?(metaphor_type)
    return { success: false, error: :invalid_metaphor_type,
             valid_types: Helpers::Constants::METAPHOR_TYPES }
  end

  result = engine.create_metaphor(
    source_domain:   source_domain,
    target_domain:   target_domain,
    metaphor_type:   metaphor_type,
    mappings:        mappings,
    strength:        strength,
    conventionality: conventionality
  )

  return result unless result.is_a?(Helpers::Metaphor)

  log.debug "[conceptual_metaphor] created #{source_domain}->#{target_domain} " \
            "type=#{metaphor_type} id=#{result.id[0..7]}"
  { success: true, metaphor_id: result.id, source_domain: source_domain,
    target_domain: target_domain, metaphor_type: metaphor_type,
    strength: result.strength, conventionality: result.conventionality }
end

#find_metaphors_for(domain:) ⇒ Object 



52
53
54
55
56
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 52

def find_metaphors_for(domain:, **)
  metaphors = engine.find_by_domain(domain: domain)
  log.debug "[conceptual_metaphor] find domain=#{domain} count=#{metaphors.size}"
  { success: true, domain: domain, metaphors: metaphors.map(&:to_h), count: metaphors.size }
end

#metaphors_by_type(metaphor_type:) ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 76

def metaphors_by_type(metaphor_type:, **)
  metaphors = engine.by_type(metaphor_type: metaphor_type)
  log.debug "[conceptual_metaphor] by_type=#{metaphor_type} count=#{metaphors.size}"
  { success: true, metaphor_type: metaphor_type, metaphors: metaphors.map(&:to_h),
    count: metaphors.size }
end

#novel_metaphors ⇒ Object 



64
65
66
67
68
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 64

def novel_metaphors(**)
  metaphors = engine.novel_metaphors
  log.debug "[conceptual_metaphor] novel count=#{metaphors.size}"
  { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
end

#strongest_metaphors(limit: 5) ⇒ Object 



70
71
72
73
74
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 70

def strongest_metaphors(limit: 5, **)
  metaphors = engine.strongest(limit: limit)
  log.debug "[conceptual_metaphor] strongest limit=#{limit} count=#{metaphors.size}"
  { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
end

#update_conceptual_metaphor ⇒ Object 



83
84
85
86
87
88
 
# File 'lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb', line 83

def update_conceptual_metaphor(**)
  engine.decay_all
  pruned = engine.prune_weak
  log.debug "[conceptual_metaphor] decay+prune pruned=#{pruned}"
  { success: true, pruned: pruned }
end