Module: Legion::Extensions::Agentic::Integration::Mosaic::Runners::CognitiveMosaic

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb

Instance Method Summary collapse

Instance Method Details

#create_mosaic(name:, pattern_category:, capacity: 50, grout_strength: nil, engine: nil) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
 
# File 'lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb', line 25

def create_mosaic(name:, pattern_category:, capacity: 50,
                  grout_strength: nil, engine: nil, **)
  eng = resolve_engine(engine)
  m   = eng.create_mosaic(name: name, pattern_category: pattern_category,
                          capacity: capacity, grout_strength: grout_strength)
  log.debug("[cognitive_mosaic] create_mosaic: name=#{name} pattern=#{pattern_category}")
  { success: true, mosaic: m.to_h }
rescue ArgumentError => e
  { success: false, error: e.message }
end

#create_tessera(material:, domain:, content:, color: nil, fit_quality: nil, engine: nil) ⇒ Object 



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

def create_tessera(material:, domain:, content:,
                   color: nil, fit_quality: nil, engine: nil, **)
  eng = resolve_engine(engine)
  t   = eng.create_tessera(material: material, domain: domain,
                           content: content, color: color,
                           fit_quality: fit_quality)
  log.debug("[cognitive_mosaic] create_tessera: material=#{material} domain=#{domain}")
  { success: true, tessera: t.to_h }
rescue ArgumentError => e
  { success: false, error: e.message }
end

#list_mosaics(engine: nil) ⇒ Object 



53
54
55
56
57
58
59
 
# File 'lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb', line 53

def list_mosaics(engine: nil, **)
  eng = resolve_engine(engine)
  mosaics = eng.all_mosaics
  log.debug("[cognitive_mosaic] list_mosaics: count=#{mosaics.size}")
  { success: true, mosaics: mosaics.map(&:to_h),
    count: mosaics.size }
end

#list_tesserae(engine: nil, material: nil) ⇒ Object 



45
46
47
48
49
50
51
 
# File 'lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb', line 45

def list_tesserae(engine: nil, material: nil, **)
  eng     = resolve_engine(engine)
  results = eng.all_tesserae
  results = results.select { |t| t.material == material.to_sym } if material
  log.debug("[cognitive_mosaic] list_tesserae: count=#{results.size}")
  { success: true, tesserae: results.map(&:to_h), count: results.size }
end

#mosaic_status(engine: nil) ⇒ Object 



61
62
63
64
65
 
# File 'lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb', line 61

def mosaic_status(engine: nil, **)
  eng = resolve_engine(engine)
  log.debug('[cognitive_mosaic] mosaic_status')
  { success: true, report: eng.mosaic_report }
end

#place_tessera(tessera_id:, mosaic_id:, engine: nil) ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb', line 36

def place_tessera(tessera_id:, mosaic_id:, engine: nil, **)
  eng = resolve_engine(engine)
  eng.place_tessera(tessera_id: tessera_id, mosaic_id: mosaic_id)
  log.debug("[cognitive_mosaic] place_tessera: tessera=#{tessera_id[0..7]} mosaic=#{mosaic_id[0..7]}")
  { success: true }
rescue ArgumentError => e
  { success: false, error: e.message }
end