Module: Legion::Extensions::Agentic::Inference::Gravity::Runners::Gravity

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

Instance Method Summary collapse

Instance Method Details

#accrete(attractor_id:, amount: Helpers::Constants::MASS_ACCRETION, engine: nil) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 67

def accrete(attractor_id:, amount: Helpers::Constants::MASS_ACCRETION, engine: nil, **)
  eng = engine || gravity_engine
  result = eng.accrete_attractor(attractor_id, amount: amount)

  if result[:error]
    log.warn "[cognitive_gravity] accrete failed: #{result[:error]}"
    return { success: false, **result }
  end

  log.debug "[cognitive_gravity] accreted id=#{attractor_id[0..7]} mass=#{result[:mass]}"
  { success: true, **result }
end

#add_thought(content:, attractor_id:, orbital_distance: 1.0, velocity: 0.0, engine: nil) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 39

def add_thought(content:, attractor_id:, orbital_distance: 1.0, velocity: 0.0,
                engine: nil, **)
  eng = engine || gravity_engine
  result = eng.add_orbiting_thought(
    content:          content,
    attractor_id:     attractor_id,
    orbital_distance: orbital_distance,
    velocity:         velocity
  )

  if result.is_a?(Hash) && result[:error]
    log.warn "[cognitive_gravity] add_thought failed: #{result[:error]}"
    return { success: false, **result }
  end

  log.debug "[cognitive_gravity] thought added id=#{result.id[0..7]} " \
            "attractor=#{attractor_id[0..7]} distance=#{orbital_distance}"
  { success: true, thought: result.to_h }
end

#cognitive_density_map(engine: nil) ⇒ Object 



107
108
109
110
111
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 107

def cognitive_density_map(engine: nil, **)
  eng = engine || gravity_engine
  density_map = eng.cognitive_density_map
  { success: true, density_map: density_map }
end

#create_attractor(content:, domain: :unknown, mass: Helpers::Constants::DEFAULT_MASS, pull_radius: 1.0, decay_rate: 0.01, engine: 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
37
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 13

def create_attractor(content:, domain: :unknown, mass: Helpers::Constants::DEFAULT_MASS,
                     pull_radius: 1.0, decay_rate: 0.01, engine: nil, **)
  eng = engine || gravity_engine
  unless Helpers::Constants.valid_domain?(domain)
    return { success: false, error: :invalid_domain,
             valid_domains: Helpers::Constants::ATTRACTOR_DOMAINS }
  end

  result = eng.add_attractor(
    content:     content,
    domain:      domain,
    mass:        mass,
    pull_radius: pull_radius,
    decay_rate:  decay_rate
  )

  if result.is_a?(Hash) && result[:error]
    log.warn "[cognitive_gravity] create_attractor failed: #{result[:error]}"
    return { success: false, **result }
  end

  log.debug "[cognitive_gravity] attractor created id=#{result.id[0..7]} " \
            "domain=#{domain} mass=#{mass}"
  { success: true, attractor: result.to_h }
end

#erode(attractor_id:, amount: Helpers::Constants::MASS_EROSION, engine: nil) ⇒ Object 



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

def erode(attractor_id:, amount: Helpers::Constants::MASS_EROSION, engine: nil, **)
  eng = engine || gravity_engine
  result = eng.erode_attractor(attractor_id, amount: amount)

  if result[:error]
    log.warn "[cognitive_gravity] erode failed: #{result[:error]}"
    return { success: false, **result }
  end

  log.debug "[cognitive_gravity] eroded id=#{attractor_id[0..7]} " \
            "mass=#{result[:mass]} collapsed=#{result[:collapsed]}"
  { success: true, **result }
end

#gravity_report(engine: nil) ⇒ Object 



113
114
115
116
117
118
119
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 113

def gravity_report(engine: nil, **)
  eng = engine || gravity_engine
  report = eng.gravity_report
  log.debug "[cognitive_gravity] report: attractors=#{report[:total_attractors]} " \
            "orbiting=#{report[:total_orbiting]} supermassive=#{report[:supermassive_count]}"
  { success: true, report: report }
end

#strongest_attractors(limit: 5, engine: nil) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 94

def strongest_attractors(limit: 5, engine: nil, **)
  eng = engine || gravity_engine
  attractors = eng.strongest_attractors(limit: limit)
  log.debug "[cognitive_gravity] strongest_attractors count=#{attractors.size}"
  { success: true, attractors: attractors.map(&:to_h), count: attractors.size }
end

#thought_distribution(engine: nil) ⇒ Object 



101
102
103
104
105
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 101

def thought_distribution(engine: nil, **)
  eng = engine || gravity_engine
  distribution = eng.thought_distribution
  { success: true, distribution: distribution }
end

#tick_gravity(engine: nil) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/legion/extensions/agentic/inference/gravity/runners/gravity.rb', line 59

def tick_gravity(engine: nil, **)
  eng = engine || gravity_engine
  result = eng.simulate_tick
  log.debug "[cognitive_gravity] tick: captures=#{result[:captures].size} " \
            "escapes=#{result[:escapes].size}"
  { success: true, **result }
end