Module: Legion::Extensions::Agentic::Defense::Quicksilver::Runners::CognitiveQuicksilver

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb

Instance Method Summary collapse

Instance Method Details

#add_to_pool(droplet_id:, pool_id:, engine: nil) ⇒ Object 



95
96
97
98
99
100
101
102
103
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 95

def add_to_pool(droplet_id:, pool_id:, engine: nil, **)
  eng = engine || quicksilver_engine
  pool = eng.add_to_pool(droplet_id: droplet_id, pool_id: pool_id)
  log.debug("[cognitive_quicksilver] add_to_pool droplet=#{droplet_id} pool=#{pool_id}")
  { success: true, pool: pool.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] add_to_pool failed: #{e.message}")
  { success: false, error: e.message }
end

#capture(droplet_id:, engine: nil) ⇒ Object 



75
76
77
78
79
80
81
82
83
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 75

def capture(droplet_id:, engine: nil, **)
  eng = engine || quicksilver_engine
  droplet = eng.capture_droplet(droplet_id: droplet_id)
  log.debug("[cognitive_quicksilver] capture id=#{droplet_id} fluidity=#{droplet.fluidity.round(2)}")
  { success: true, droplet: droplet.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] capture failed: #{e.message}")
  { success: false, error: e.message }
end

#create_droplet(form: :droplet, content: '', engine: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 13

def create_droplet(form: :droplet, content: '', engine: nil, **)
  raise ArgumentError, "invalid form: #{form}" unless Helpers::Constants::FORM_TYPES.include?(form)

  eng = engine || quicksilver_engine
  droplet = eng.create_droplet(form: form, content: content.to_s)
  log.debug("[cognitive_quicksilver] create_droplet id=#{droplet.id} form=#{droplet.form}")
  { success: true, droplet: droplet.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] create_droplet failed: #{e.message}")
  { success: false, error: e.message }
end

#create_pool(surface_type: :glass, engine: nil) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 25

def create_pool(surface_type: :glass, engine: nil, **)
  raise ArgumentError, "invalid surface_type: #{surface_type}" unless Helpers::Constants::SURFACE_TYPES.include?(surface_type)

  eng = engine || quicksilver_engine
  pool = eng.create_pool(surface_type: surface_type)
  log.debug("[cognitive_quicksilver] create_pool id=#{pool.id} surface=#{pool.surface_type}")
  { success: true, pool: pool.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] create_pool failed: #{e.message}")
  { success: false, error: e.message }
end

#list_droplets(engine: nil) ⇒ Object 



105
106
107
108
109
110
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 105

def list_droplets(engine: nil, **)
  eng = engine || quicksilver_engine
  items = eng.droplets
  log.debug("[cognitive_quicksilver] list_droplets count=#{items.size}")
  { success: true, droplets: items, count: items.size }
end

#merge(droplet_a_id:, droplet_b_id:, engine: nil) ⇒ Object 



49
50
51
52
53
54
55
56
57
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 49

def merge(droplet_a_id:, droplet_b_id:, engine: nil, **)
  eng = engine || quicksilver_engine
  droplet = eng.merge_droplets(droplet_a_id: droplet_a_id, droplet_b_id: droplet_b_id)
  log.debug("[cognitive_quicksilver] merge a=#{droplet_a_id} b=#{droplet_b_id} result_mass=#{droplet.mass.round(2)}")
  { success: true, droplet: droplet.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] merge failed: #{e.message}")
  { success: false, error: e.message }
end

#quicksilver_status(engine: nil) ⇒ Object 



112
113
114
115
116
117
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 112

def quicksilver_status(engine: nil, **)
  eng = engine || quicksilver_engine
  report = eng.quicksilver_report
  log.debug("[cognitive_quicksilver] status droplets=#{report[:total_droplets]} pools=#{report[:total_pools]}")
  { success: true, **report }
end

#release(droplet_id:, engine: nil) ⇒ Object 



85
86
87
88
89
90
91
92
93
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 85

def release(droplet_id:, engine: nil, **)
  eng = engine || quicksilver_engine
  droplet = eng.release_droplet(droplet_id: droplet_id)
  log.debug("[cognitive_quicksilver] release id=#{droplet_id} fluidity=#{droplet.fluidity.round(2)}")
  { success: true, droplet: droplet.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] release failed: #{e.message}")
  { success: false, error: e.message }
end

#shift_form(droplet_id:, new_form:, engine: nil) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 37

def shift_form(droplet_id:, new_form:, engine: nil, **)
  raise ArgumentError, "invalid form: #{new_form}" unless Helpers::Constants::FORM_TYPES.include?(new_form)

  eng = engine || quicksilver_engine
  droplet = eng.shift_form(droplet_id: droplet_id, new_form: new_form)
  log.debug("[cognitive_quicksilver] shift_form id=#{droplet_id} new_form=#{new_form}")
  { success: true, droplet: droplet.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] shift_form failed: #{e.message}")
  { success: false, error: e.message }
end

#split(droplet_id:, engine: nil) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/legion/extensions/agentic/defense/quicksilver/runners/cognitive_quicksilver.rb', line 59

def split(droplet_id:, engine: nil, **)
  eng = engine || quicksilver_engine
  result = eng.split_droplet(droplet_id: droplet_id)
  if result.nil?
    log.debug("[cognitive_quicksilver] split id=#{droplet_id} too_small")
    return { success: false, error: 'droplet mass too small to split' }
  end

  original, twin = result
  log.debug("[cognitive_quicksilver] split id=#{droplet_id} twin_id=#{twin.id}")
  { success: true, original: original.to_h, twin: twin.to_h }
rescue ArgumentError => e
  log.debug("[cognitive_quicksilver] split failed: #{e.message}")
  { success: false, error: e.message }
end