Module: Legion::Extensions::Agentic::Integration::Labyrinth::Runners::CognitiveLabyrinth

Extended by:
CognitiveLabyrinth
Includes:
Helpers::Lex
Included in:
Client, CognitiveLabyrinth
Defined in:
lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb

Instance Method Summary collapse

Instance Method Details

#add_node(labyrinth_id:, node_type:, content: nil, danger_level: nil, node_id: nil, engine: nil) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 25

def add_node(labyrinth_id:, node_type:, content: nil, danger_level: nil, node_id: nil, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?
  raise ArgumentError, 'node_type is required' if node_type.nil?

  node = resolve_engine(engine).add_node_to(
    labyrinth_id: labyrinth_id, node_type: node_type,
    content: content, danger_level: danger_level, node_id: node_id
  )
  { success: true, node_id: node.node_id, node_type: node.node_type }
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] add_node error: #{e.message}")
  { success: false, error: e.message }
end

#backtrack(labyrinth_id:, engine: nil) ⇒ Object 



60
61
62
63
64
65
66
67
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 60

def backtrack(labyrinth_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  resolve_engine(engine).backtrack(labyrinth_id: labyrinth_id)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] backtrack error: #{e.message}")
  { success: false, error: e.message }
end

#check_minotaur(labyrinth_id:, engine: nil) ⇒ Object 



78
79
80
81
82
83
84
85
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 78

def check_minotaur(labyrinth_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  resolve_engine(engine).check_minotaur(labyrinth_id: labyrinth_id)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] check_minotaur error: #{e.message}")
  { success: false, error: e.message }
end

#connect_nodes(labyrinth_id:, from_id:, to_id:, bidirectional: true, engine: nil) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 39

def connect_nodes(labyrinth_id:, from_id:, to_id:, bidirectional: true, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  resolve_engine(engine).connect_nodes(
    labyrinth_id: labyrinth_id, from_id: from_id, to_id: to_id, bidirectional: bidirectional
  )
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] connect_nodes error: #{e.message}")
  { success: false, error: e.message }
end

#create_labyrinth(name:, domain: nil, labyrinth_id: nil, engine: nil) ⇒ Object 



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

def create_labyrinth(name:, domain: nil, labyrinth_id: nil, engine: nil, **)
  raise ArgumentError, 'name is required' if name.nil? || name.to_s.strip.empty?

  result = resolve_engine(engine).create_labyrinth(name: name, domain: domain, labyrinth_id: labyrinth_id)
  log.debug("[cognitive_labyrinth] runner: created labyrinth #{result.labyrinth_id[0..7]}")
  { success: true, labyrinth_id: result.labyrinth_id, name: result.name, domain: result.domain }
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] create_labyrinth error: #{e.message}")
  { success: false, error: e.message }
end

#delete_labyrinth(labyrinth_id:, engine: nil) ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 104

def delete_labyrinth(labyrinth_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  resolve_engine(engine).delete_labyrinth(labyrinth_id: labyrinth_id)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] delete_labyrinth error: #{e.message}")
  { success: false, error: e.message }
end

#follow_thread(labyrinth_id:, engine: nil) ⇒ Object 



69
70
71
72
73
74
75
76
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 69

def follow_thread(labyrinth_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  resolve_engine(engine).follow_thread(labyrinth_id: labyrinth_id)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] follow_thread error: #{e.message}")
  { success: false, error: e.message }
end

#labyrinth_report(labyrinth_id:, engine: nil) ⇒ Object 



87
88
89
90
91
92
93
94
95
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 87

def labyrinth_report(labyrinth_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?

  result = resolve_engine(engine).labyrinth_report(labyrinth_id: labyrinth_id)
  { success: true }.merge(result)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] labyrinth_report error: #{e.message}")
  { success: false, error: e.message }
end

#list_labyrinths(engine: nil) ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 97

def list_labyrinths(engine: nil, **)
  result = resolve_engine(engine).list_labyrinths
  { success: true, labyrinths: result, count: result.size }
rescue ArgumentError => e
  { success: false, error: e.message }
end

#move(labyrinth_id:, node_id:, engine: nil) ⇒ Object 



50
51
52
53
54
55
56
57
58
 
# File 'lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb', line 50

def move(labyrinth_id:, node_id:, engine: nil, **)
  raise ArgumentError, 'labyrinth_id is required' if labyrinth_id.nil?
  raise ArgumentError, 'node_id is required' if node_id.nil?

  resolve_engine(engine).move(labyrinth_id: labyrinth_id, node_id: node_id)
rescue ArgumentError => e
  log.debug("[cognitive_labyrinth] move error: #{e.message}")
  { success: false, error: e.message }
end