Module: Legion::Extensions::Agentic::Homeostasis::Pendulum::Runners::CognitivePendulum

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb

Instance Method Summary collapse

Instance Method Details

#check_resonance(frequency:) ⇒ Object 



60
61
62
63
64
65
66
67
68
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 60

def check_resonance(frequency:, **)
  return { success: false, error: :invalid_frequency, message: 'frequency must be positive' } unless frequency.to_f.positive?

  resonant_ids = pendulum_engine.check_resonance(frequency.to_f)
  log.debug("[cognitive_pendulum] resonance check frequency=#{frequency} matches=#{resonant_ids.size}")
  { success: true, frequency: frequency, resonant_pendulum_ids: resonant_ids, count: resonant_ids.size }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#create_pendulum(pole_pair:, amplitude: 0.5, period: 10.0, damping: Helpers::Constants::DAMPING_RATE) ⇒ 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/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 13

def create_pendulum(pole_pair:, amplitude: 0.5, period: 10.0, damping: Helpers::Constants::DAMPING_RATE, **)
  unless Helpers::Constants.valid_pole_pair?(pole_pair)
    return { success: false, error: :invalid_pole_pair, valid_pairs: Helpers::Constants::POLE_PAIRS.keys }
  end

  raise ArgumentError, 'amplitude must be 0.0..1.0' unless amplitude.between?(0.0, 1.0)
  raise ArgumentError, 'period must be positive' unless period.positive?

  if pendulum_engine.count >= Helpers::Constants::MAX_PENDULUMS
    return { success: false, error: :max_pendulums_reached, max: Helpers::Constants::MAX_PENDULUMS }
  end

  pendulum = pendulum_engine.create_pendulum(
    pole_pair: pole_pair,
    amplitude: amplitude,
    period:    period,
    damping:   damping
  )

  log.debug("[cognitive_pendulum] created pole_pair=#{pole_pair} id=#{pendulum.id[0..7]}")
  { success: true, pendulum_id: pendulum.id, pole_pair: pole_pair, amplitude: pendulum.amplitude }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#damp_all ⇒ Object 



51
52
53
54
55
56
57
58
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 51

def damp_all(**)
  pendulum_engine.damp_all!
  count = pendulum_engine.count
  log.debug("[cognitive_pendulum] damped all (#{count} pendulums)")
  { success: true, damped: count }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#get_dominant_pole(pendulum_id:) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 70

def get_dominant_pole(pendulum_id:, **)
  pole = pendulum_engine.dominant_pole(pendulum_id)
  if pole.nil?
    log.debug("[cognitive_pendulum] dominant_pole failed: #{pendulum_id[0..7]} not found")
    return { success: false, error: :not_found }
  end

  log.debug("[cognitive_pendulum] dominant_pole id=#{pendulum_id[0..7]} pole=#{pole}")
  { success: true, pendulum_id: pendulum_id, dominant_pole: pole }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#get_pendulum(pendulum_id:) ⇒ Object 



107
108
109
110
111
112
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 107

def get_pendulum(pendulum_id:, **)
  p = pendulum_engine.get(pendulum_id)
  p ? { success: true, pendulum: p.to_h } : { success: false, error: :not_found }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#most_active(limit: 5) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 83

def most_active(limit: 5, **)
  pendulums = pendulum_engine.most_active(limit: limit)
  log.debug("[cognitive_pendulum] most_active limit=#{limit} found=#{pendulums.size}")
  { success: true, pendulums: pendulums.map(&:to_h), count: pendulums.size }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#most_damped(limit: 5) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 91

def most_damped(limit: 5, **)
  pendulums = pendulum_engine.most_damped(limit: limit)
  log.debug("[cognitive_pendulum] most_damped limit=#{limit} found=#{pendulums.size}")
  { success: true, pendulums: pendulums.map(&:to_h), count: pendulums.size }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#pendulum_report ⇒ Object 



99
100
101
102
103
104
105
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 99

def pendulum_report(**)
  report = pendulum_engine.pendulum_report
  log.debug("[cognitive_pendulum] report total=#{report[:total]}")
  { success: true, report: report }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end

#swing(pendulum_id:, force: 0.0) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/legion/extensions/agentic/homeostasis/pendulum/runners/cognitive_pendulum.rb', line 38

def swing(pendulum_id:, force: 0.0, **)
  result = pendulum_engine.swing(pendulum_id, force: force)
  unless result
    log.debug("[cognitive_pendulum] swing failed: #{pendulum_id[0..7]} not found")
    return { success: false, error: :not_found }
  end

  log.debug("[cognitive_pendulum] swing id=#{pendulum_id[0..7]} position=#{result.current_position.round(4)}")
  { success: true, pendulum_id: pendulum_id, current_position: result.current_position, dominant_pole: result.dominant_pole }
rescue ArgumentError => e
  { success: false, error: :argument_error, message: e.message }
end