Module: Legion::Extensions::Agentic::Affect::Appraisal::Runners::Appraisal

Extended by:
Appraisal
Included in:
Client, Appraisal
Defined in:
lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb

Instance Method Summary collapse

Instance Method Details

#add_coping_strategy(name:, coping_type:, effectiveness:) ⇒ Object 



44
45
46
47
48
49
50
51
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 44

def add_coping_strategy(name:, coping_type:, effectiveness:, **)
  log.debug("[lex-appraisal] add_coping_strategy name=#{name}")
  added = engine.add_coping_strategy(name: name, coping_type: coping_type, effectiveness: effectiveness)
  { success: added, name: name, coping_type: coping_type }
rescue StandardError => e
  log.error("[lex-appraisal] add_coping_strategy error: #{e.message}")
  { success: false, error: e.message }
end

#appraisal_stats ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 80

def appraisal_stats(**)
  log.debug('[lex-appraisal] appraisal_stats')
  data = engine.to_h
  unresolved = engine.unresolved.size
  {
    success:      true,
    total:        data[:appraisals].size,
    unresolved:   unresolved,
    history_size: data[:history_size],
    pattern:      engine.emotional_pattern
  }
rescue StandardError => e
  log.error("[lex-appraisal] appraisal_stats error: #{e.message}")
  { success: false, error: e.message }
end

#appraise_event(event:, primary:, secondary:, domain: nil) ⇒ Object 



12
13
14
15
16
17
18
19
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 12

def appraise_event(event:, primary:, secondary:, domain: nil, **)
  log.debug("[lex-appraisal] appraise_event event=#{event} domain=#{domain}")
  record = engine.appraise(event: event, primary: primary, secondary: secondary, domain: domain)
  { success: true, appraisal: record.to_h }
rescue StandardError => e
  log.error("[lex-appraisal] appraise_event error: #{e.message}")
  { success: false, error: e.message }
end

#emotional_pattern ⇒ Object 



62
63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 62

def emotional_pattern(**)
  log.debug('[lex-appraisal] emotional_pattern')
  pattern = engine.emotional_pattern
  { success: true, pattern: pattern }
rescue StandardError => e
  log.error("[lex-appraisal] emotional_pattern error: #{e.message}")
  { success: false, error: e.message }
end

#evaluate_coping(appraisal_id:) ⇒ Object 



53
54
55
56
57
58
59
60
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 53

def evaluate_coping(appraisal_id:, **)
  log.debug("[lex-appraisal] evaluate_coping id=#{appraisal_id}")
  result = engine.evaluate_coping(appraisal_id: appraisal_id)
  { success: true }.merge(result)
rescue StandardError => e
  log.error("[lex-appraisal] evaluate_coping error: #{e.message}")
  { success: false, error: e.message }
end

#reappraise_event(appraisal_id:, new_primary:, new_secondary:) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 21

def reappraise_event(appraisal_id:, new_primary:, new_secondary:, **)
  log.debug("[lex-appraisal] reappraise_event id=#{appraisal_id}")
  record = engine.reappraise(appraisal_id: appraisal_id, new_primary: new_primary,
                             new_secondary: new_secondary)
  return { success: false, error: 'appraisal not found' } unless record

  { success: true, appraisal: record.to_h }
rescue StandardError => e
  log.error("[lex-appraisal] reappraise_event error: #{e.message}")
  { success: false, error: e.message }
end

#select_coping_strategy(appraisal_id:, coping_type:) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 33

def select_coping_strategy(appraisal_id:, coping_type:, **)
  log.debug("[lex-appraisal] select_coping appraisal_id=#{appraisal_id}")
  record = engine.select_coping(appraisal_id: appraisal_id, coping_type: coping_type)
  return { success: false, error: 'appraisal not found' } unless record

  { success: true, appraisal: record.to_h }
rescue StandardError => e
  log.error("[lex-appraisal] select_coping error: #{e.message}")
  { success: false, error: e.message }
end

#update_appraisal ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/legion/extensions/agentic/affect/appraisal/runners/appraisal.rb', line 71

def update_appraisal(**)
  log.debug('[lex-appraisal] update_appraisal (decay cycle)')
  engine.decay_all
  { success: true }
rescue StandardError => e
  log.error("[lex-appraisal] update_appraisal error: #{e.message}")
  { success: false, error: e.message }
end