Module: Legion::Extensions::Core

Includes:
Builder::Absorbers, Builder::Actors, Builder::Helpers, Builder::Hooks, Builder::Routes, Builder::Runners, Builder::Skills, Helpers::Knowledge, Helpers::Lex, Helpers::Transport
Defined in:
lib/legion/extensions/core.rb

Constant Summary

Constants included from Helpers::Base

Helpers::Base::NAMESPACE_BOUNDARIES

Instance Attribute Summary

Attributes included from Builder::Skills

#skills

Attributes included from Builder::Routes

#routes

Attributes included from Builder::Hooks

#hooks

Attributes included from Builder::Actors

#actors

Attributes included from Builder::Runners

#runners

Instance Method Summary collapse

Methods included from Builder::Skills

#build_skill_list, #build_skills, #skill_files

Methods included from Builder::Base

#const_defined_two?, #define_constant_two, #define_get, #find_files, #require_files

Methods included from Builder::Routes

#build_routes

Methods included from Builder::Hooks

#build_hook_list, #build_hooks, #hook_files

Methods included from Builder::Actors

#actor_files, #build_actor_list, #build_actors, #build_meta_actor, #build_meta_actor_list

Methods included from Builder::Helpers

#build_helpers, #helper_files, #helpers

Methods included from Builder::Runners

#build_runner_entry, #build_runner_list, #build_runners, #populate_runner_methods, #runner_files, #runner_modules

Methods included from Builder::Absorbers

#absorbers, #build_absorbers

Methods included from Helpers::Knowledge

#ingest_knowledge, #knowledge_connected?, #knowledge_default_scope, #knowledge_default_tags, #knowledge_global_connected?, #knowledge_local_connected?, #query_knowledge

Methods included from Helpers::Base

#actor_class, #actor_const, #actor_name, #amqp_prefix, #calling_class, #calling_class_array, #from_json, #full_path, #lex_class, #lex_const, #lex_name, #lex_slug, #log_tag, #normalize, #runner_class, #runner_const, #runner_name, #segments, #settings_path, #table_prefix, #to_dotted_hash

Methods included from Helpers::Lex

included, #runner_desc

Methods included from Helpers::Task

#generate_task_id, #generate_task_log, #task_update

Methods included from Helpers::Logger

#handle_runner_exception

Methods included from Helpers::Secret

reset_identity!, resolve_identity!, #secret

Methods included from Helpers::Core

#find_setting

Instance Method Details

#auto_generate_data ⇒ Object 



249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/legion/extensions/core.rb', line 249

def auto_generate_data
  require 'legion/extensions/data'
  log.debug 'running meta magic to generate a data base class'
  if lex_class.const_defined?(:Data, false)
    mod = lex_class.const_get(:Data, false)
    mod.extend(Legion::Extensions::Data) unless mod.respond_to?(:build)
  else
    lex_class.const_set(:Data, Module.new { extend Legion::Extensions::Data })
  end
rescue StandardError => e
  handle_exception(e, lex: lex_name, operation: 'auto_generate_data')
end

#auto_generate_transport ⇒ Object 



238
239
240
241
242
243
244
245
246
247
 
# File 'lib/legion/extensions/core.rb', line 238

def auto_generate_transport
  require 'legion/extensions/transport'
  log.debug 'running meta magic to generate a transport base class'
  if lex_class.const_defined?(:Transport, false)
    mod = lex_class.const_get(:Transport, false)
    mod.extend(Legion::Extensions::Transport) unless mod.respond_to?(:build)
  else
    lex_class.const_set(:Transport, Module.new { extend Legion::Extensions::Transport })
  end
end

#autobuild ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/legion/extensions/core.rb', line 63

def autobuild
  Legion::Logging.debug "[Core] autobuild start: #{name}" if defined?(Legion::Logging)
  @actors = {}
  @meta_actors = {}
  @runners = {}
  @helpers = []

  @queues = {}
  @exchanges = {}
  @messages = {}
  build_settings
  build_transport
  if Legion::Settings[:data][:connected] && data_required?
    Legion::Logging.debug "[Core] building data for #{name}" if defined?(Legion::Logging)
    build_data
  end
  build_helpers
  build_runners
  generate_messages_from_definitions
  build_absorbers
  build_actors
  build_hooks
  build_routes
  build_skills if skills_required?
  Legion::Logging.debug "[Core] autobuild complete: #{name}" if defined?(Legion::Logging)
end

#build_data ⇒ Object 



183
184
185
186
187
188
 
# File 'lib/legion/extensions/core.rb', line 183

def build_data
  Legion::Logging.debug "[Core] build_data: #{name}" if defined?(Legion::Logging)
  auto_generate_data
  lex_class::Data.build
  Legion::Logging.info "[Core] data built: #{name}" if defined?(Legion::Logging)
end

#build_settings ⇒ Object 



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/legion/extensions/core.rb', line 210

def build_settings
  defaults = deep_dup_settings_value(Legion::Settings[:default_extension_settings] || {})

  if Legion::Settings[:extensions].key?(lex_name.to_sym)
    defaults.each do |key, value|
      Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
                                                                     deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
                                                                   else
                                                                     deep_dup_settings_value(value)
                                                                   end
    end
  else
    Legion::Settings[:extensions][lex_name.to_sym] = defaults
  end

  default_settings.each do |key, value|
    Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
                                                                   deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
                                                                 else
                                                                   deep_dup_settings_value(value)
                                                                 end
  end
end

#build_transport ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/legion/extensions/core.rb', line 190

def build_transport
  if File.exist? "#{extension_path}/transport/autobuild.rb"
    require "#{extension_path}/transport/autobuild"
    extension_class::Transport::AutoBuild.build
    log.warn 'still using transport::autobuild, please upgrade'
    return
  end

  if File.exist? "#{extension_path}/transport.rb"
    require "#{extension_path}/transport"
    unless extension_class::Transport.respond_to?(:build)
      log.warn "#{extension_class}::Transport does not respond to build, auto-generating"
      auto_generate_transport
    end
  else
    auto_generate_transport
  end
  extension_class::Transport.build
end

#cache_required? ⇒ Boolean

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/legion/extensions/core.rb', line 98

def cache_required?
  false
end

#camelize(name) ⇒ Object 



179
180
181
 
# File 'lib/legion/extensions/core.rb', line 179

def camelize(name)
  name.to_s.split('_').collect(&:capitalize).join
end

#crypt_required? ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/legion/extensions/core.rb', line 102

def crypt_required?
  false
end

#data_required? ⇒ Boolean

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/legion/extensions/core.rb', line 90

def data_required?
  false
end

#deep_dup_settings_value(value) ⇒ Object 



262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/legion/extensions/core.rb', line 262

def deep_dup_settings_value(value)
  case value
  when Hash
    value.each_with_object({}) do |(key, nested), duplicated|
      duplicated[key.to_sym] = deep_dup_settings_value(nested)
    end
  when Array
    value.map { |item| deep_dup_settings_value(item) }
  else
    value.dup
  end
rescue TypeError
  value
end

#default_settings ⇒ Object 



234
235
236
 
# File 'lib/legion/extensions/core.rb', line 234

def default_settings
  {}
end

#generate_messages_from_definitions ⇒ Object

Auto-generate AMQP message classes for each runner method that has a definition. Explicit Messages::* classes in the transport directory take precedence. Runs after build_runners so definitions are populated.



137
138
139
140
141
142
143
144
145
146
 
# File 'lib/legion/extensions/core.rb', line 137

def generate_messages_from_definitions
  ctx = message_generation_context
  return unless ctx

  @runners.each do |runner_name, attr|
    generate_runner_messages(ctx, runner_name, attr)
  end
rescue StandardError => e
  log.warn "[Core] generate_messages_from_definitions failed: #{e.message}" if defined?(log)
end

#generate_runner_messages(ctx, runner_name, attr) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/legion/extensions/core.rb', line 161

def generate_runner_messages(ctx, runner_name, attr)
  runner_module = attr[:runner_module]
  return unless runner_module.respond_to?(:definitions)

  runner_module.definitions.each_key do |method_name|
    const_name = "#{camelize(runner_name)}#{camelize(method_name)}"
    next if ctx[:messages_mod].const_defined?(const_name, false)

    rk_value = "#{ctx[:prefix]}.runners.#{runner_name}.#{method_name}"
    ctx[:messages_mod].const_set(const_name, Class.new(Legion::Transport::Message) do
      define_method(:exchange) { ctx[:default_exch] }
      define_method(:routing_key) { rk_value }
    end)
  end
rescue StandardError => e
  log.warn "[Core] message generation error for #{runner_name}: #{e.message}" if defined?(log)
end

#llm_required? ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/legion/extensions/core.rb', line 110

def llm_required?
  false
end

#mcp_tools? ⇒ Boolean

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/legion/extensions/core.rb', line 122

def mcp_tools?
  true
end

#mcp_tools_deferred? ⇒ Boolean

Returns:

  • (Boolean) 


126
127
128
 
# File 'lib/legion/extensions/core.rb', line 126

def mcp_tools_deferred?
  true
end

#message_generation_context ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/legion/extensions/core.rb', line 148

def message_generation_context
  return unless defined?(Legion::Transport::Message)
  return unless lex_class.const_defined?('Transport', false)

  transport_mod = lex_class::Transport
  return unless transport_mod.const_defined?('Messages', false) && transport_mod.const_defined?('Exchanges', false)

  default_exch = transport_mod.default_exchange
  { messages_mod: transport_mod::Messages, default_exch: default_exch, prefix: amqp_prefix }
rescue StandardError
  nil
end

#remote_invocable? ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/legion/extensions/core.rb', line 118

def remote_invocable?
  true
end

#skills_required? ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/legion/extensions/core.rb', line 114

def skills_required?
  false
end

#transport_required? ⇒ Boolean

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/legion/extensions/core.rb', line 94

def transport_required?
  true
end

#trigger_words ⇒ Object 



130
131
132
 
# File 'lib/legion/extensions/core.rb', line 130

def trigger_words
  []
end

#vault_required? ⇒ Boolean

Returns:

  • (Boolean) 


106
107
108
 
# File 'lib/legion/extensions/core.rb', line 106

def vault_required?
  false
end