legionio 1.8.4 → 1.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8cfc2d3d92d0f7d6597d051be30145be9a38864fe9c346b69320d07b6cefdf6
-  data.tar.gz: e9420d7bdce1733c87dfe9924a4d82f5993d49ffaabcaa44ad96425c9bb1288d
+  metadata.gz: b26f7ff8bd0262bc8eedecfad569c5cd412b3c95f8a2f014f4017c21cd62013b
+  data.tar.gz: 3404fcfd2f6e7d4dabce66d9645997213ecb355a030a0dddb4df6c681e98cd1f
 SHA512:
-  metadata.gz: 25467ee9926361dc83606f260567026ca9688b2b04f0ce16978c9ff9ba703d981e20065b77960d805cd8259a1f2765f56f509e869f51f25ef01ceed087268be7
-  data.tar.gz: f33bcdbbda291c3e32f7aa5153ca30a22526ca673b7d584303e908346814c4e5f2e6035ec4f2b95c3c322867d3b09a3c0dbe2814f5d8a785ebc18f18cccd4611
+  metadata.gz: 406b9987436e8df5ad44a00edee5bfce4e68f8681ec089690d39cf4895fc1dab73cbe3500848ca1283a737c9997dad5c74700d09e719d70cab888b7acf28beef
+  data.tar.gz: 39409aeeb616e4e9e5d679f525be36ecdd60433c5154c8a2c5ebc2c936ce1a5a5d40d33731b9fcc9dc00a8bd6cfc0b3f8fbbd80c1bcc7d2e8736a5227182708a

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [1.8.5] - 2026-04-15
+
+### Fixed
+- `Legion::Extensions::Core#trigger_words` now defaults to `lex_name.split('_')` (e.g. `['github']` for lex-github) instead of `[]`, ensuring extensions auto-surface in TriggerIndex without requiring explicit declaration. Closes #139
+- `Legion::Extensions::Builder::Runners#build_runner_entry` now always populates `trigger_words`, defaulting to `[runner_name]` when the runner module does not define them explicitly. Closes #139
+- `Legion::Tools::Discovery#synthesize_functions` now builds a real JSON Schema from Ruby method reflection data (`Method#parameters`) — required kwargs become required schema properties, optional kwargs become optional properties — so the LLM receives accurate parameter information instead of an empty schema. Closes #140
+- `Legion::Tools::Discovery#synthesize_functions` now uses `definition[:desc]` for tool description when a `definition` DSL entry exists, falling back to the method name rather than `"method_name function"`. Closes #140
+- `Legion::Tools::Discovery#tool_attributes` now reads `definition[:inputs]` when present and non-empty, using it as the input schema in preference to `meta[:options]`. Closes #140
+- `Legion::Tools::Discovery#register_function` fixed asymmetric default: `resolve_exposed` now defaults to `true` when the extension does not respond to `mcp_tools?`, matching the behaviour of `resolve_mcp_tools_enabled`. Closes #140
+
 ## [1.8.4] - 2026-04-14
 
 ### Added

data/lib/legion/extensions/builders/runners.rb

@@ -42,7 +42,11 @@ module Legion
             class_methods:   {}
           }
           entry[:scheduled_tasks] = loaded_runner.scheduled_tasks if loaded_runner.method_defined?(:scheduled_tasks)
-          entry[:trigger_words] = loaded_runner.trigger_words if loaded_runner.respond_to?(:trigger_words)
+          entry[:trigger_words] = if loaded_runner.respond_to?(:trigger_words) && loaded_runner.trigger_words.any?
+                                    loaded_runner.trigger_words
+                                  else
+                                    [runner_name]
+                                  end
           entry[:desc] = settings[:runners][runner_name.to_sym][:desc] if settings.key?(:runners) && settings[:runners].key?(runner_name.to_sym)
           entry
         end

data/lib/legion/extensions/core.rb

@@ -128,7 +128,7 @@ module Legion
       end
 
       def trigger_words
-        []
+        lex_name.split('_')
       end
 
       # Auto-generate AMQP message classes for each runner method that has a definition.

data/lib/legion/tools/discovery.rb

@@ -80,14 +80,40 @@ module Legion
           return {} unless runner_entry&.dig(:class_methods).is_a?(Hash)
 
           runner_entry[:class_methods].each_with_object({}) do |(method_name, method_info), funcs|
-            funcs[method_name] = { desc: "#{method_name} function", options: {}, args: method_info[:args] }
+            defn = runner_mod.respond_to?(:definition_for) ? runner_mod.definition_for(method_name) : nil
+            funcs[method_name] = {
+              desc:    defn&.dig(:desc) || method_name.to_s,
+              options: build_schema_from_args(method_info[:args]),
+              args:    method_info[:args]
+            }
           end
         end
 
+        def build_schema_from_args(args)
+          return {} if args.nil? || args.empty?
+
+          properties = {}
+          required = []
+
+          args.each do |type, name|
+            next if name.nil? || %i[** * block].include?(name)
+
+            param_name = name.to_s
+            properties[param_name] = { type: 'string' }
+            required << param_name if type == :req
+          end
+
+          return {} if properties.empty?
+
+          schema = { properties: properties }
+          schema[:required] = required unless required.empty?
+          schema
+        end
+
         def register_function(ext, runner_mod, func_name, meta, is_deferred)
           defn = runner_mod.respond_to?(:definition_for) ? runner_mod.definition_for(func_name) : nil
 
-          ext_default = ext.respond_to?(:mcp_tools?) ? ext.mcp_tools? : false
+          ext_default = ext.respond_to?(:mcp_tools?) ? ext.mcp_tools? : true
           return unless resolve_exposed(defn, meta, ext_default)
 
           requires = defn&.dig(:requires)&.map(&:to_s) || meta[:requires]
@@ -149,7 +175,7 @@ module Legion
           {
             tool_name:     defn&.dig(:mcp_prefix) || "legion-#{ext_name}-#{runner_snake}-#{func_name}",
             description:   meta[:desc] || defn&.dig(:desc) || "#{ext_name}##{func_name}",
-            input_schema:  normalize_schema(meta[:options]),
+            input_schema:  normalize_schema(defn&.dig(:inputs)&.any? ? defn[:inputs] : meta[:options]),
             mcp_category:  defn&.dig(:mcp_category),
             mcp_tier:      defn&.dig(:mcp_tier),
             deferred:      deferred,

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.8.4'
+  VERSION = '1.8.5'
 end

data/scripts/fleet_smoke_test.rb

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Fleet Pipeline Smoke Test
+# =========================
+# Runs against a live RabbitMQ instance to verify exchange/queue topology
+# and basic message flow.
+#
+# Prerequisites:
+#   - RabbitMQ running on localhost:5672 (or set RABBITMQ_URL)
+#   - Legion gems installed: legion-transport, legion-settings, legion-json
+#   - Fleet extensions deployed: lex-assessor, lex-planner, lex-developer, lex-validator
+#
+# Usage:
+#   ruby scripts/fleet_smoke_test.rb
+#   RABBITMQ_URL=amqp://user:pass@host:5672 ruby scripts/fleet_smoke_test.rb
+
+require 'json'
+require 'securerandom'
+require 'timeout'
+
+# Suppress legion logging noise
+ENV['LEGION_LOG_LEVEL'] ||= 'error'
+
+class FleetSmokeTest
+  FLEET_EXCHANGES = %w[
+    lex.assessor lex.planner lex.developer lex.validator
+  ].freeze
+
+  FLEET_QUEUES = %w[
+    lex.assessor.runners.assessor
+    lex.planner.runners.planner
+    lex.developer.runners.developer
+    lex.developer.runners.ship
+    lex.validator.runners.validator
+  ].freeze
+
+  ABSORBER_QUEUES = %w[
+    lex.github.absorbers.issues.absorb
+  ].freeze
+
+  attr_reader :results
+
+  def initialize
+    @results = []
+    @passed = 0
+    @failed = 0
+  end
+
+  def run
+    puts '=' * 60
+    puts 'Fleet Pipeline Smoke Test'
+    puts '=' * 60
+    puts
+
+    check_dependencies
+    setup_transport
+    check_exchanges
+    check_queues
+    check_absorber_queues
+    test_publish_consume
+    teardown
+
+    report
+  end
+
+  private
+
+  def check_dependencies
+    section('Checking dependencies')
+
+    %w[legion-transport legion-settings legion-json].each do |gem_name|
+      Gem::Specification.find_by_name(gem_name)
+      pass("#{gem_name} installed")
+    rescue Gem::MissingSpecError
+      fail_test("#{gem_name} not installed")
+    end
+  end
+
+  def setup_transport
+    section('Connecting to RabbitMQ')
+
+    require 'legion/settings'
+    require 'legion/logging'
+    require 'legion/transport'
+
+    Legion::Logging.setup(log_level: 'error', level: 'error', trace: false)
+    Legion::Settings.load
+
+    if ENV['RABBITMQ_URL']
+      Legion::Settings.loader.settings[:transport] ||= {}
+      Legion::Settings.loader.settings[:transport][:url] = ENV.fetch('RABBITMQ_URL', nil)
+    end
+
+    Legion::Settings.merge_settings('transport', Legion::Transport::Settings.default)
+    Legion::Transport::Connection.setup
+    pass('Connected to RabbitMQ')
+  rescue StandardError => e
+    fail_test("RabbitMQ connection failed: #{e.message}")
+    puts "\n  Set RABBITMQ_URL or configure transport in ~/.legionio/settings/"
+    exit 1
+  end
+
+  def check_exchanges
+    section('Checking fleet exchanges')
+
+    channel = Legion::Transport::Connection.session.create_channel
+    FLEET_EXCHANGES.each do |name|
+      check_or_create_exchange(channel, name)
+      channel = Legion::Transport::Connection.session.create_channel
+    end
+  end
+
+  def check_or_create_exchange(channel, name)
+    channel.exchange_declare(name, 'topic', passive: true)
+    pass("Exchange #{name} exists")
+  rescue Bunny::NotFound
+    channel = Legion::Transport::Connection.session.create_channel
+    channel.exchange_declare(name, 'topic', durable: true)
+    pass("Exchange #{name} created")
+  rescue StandardError => e
+    fail_test("Exchange #{name} check failed: #{e.message}")
+  end
+
+  def check_queues
+    section('Checking fleet queues')
+
+    channel = Legion::Transport::Connection.session.create_channel
+    FLEET_QUEUES.each do |name|
+      check_or_create_queue(channel, name)
+      channel = Legion::Transport::Connection.session.create_channel
+    end
+  end
+
+  def check_absorber_queues
+    section('Checking absorber queues')
+
+    channel = Legion::Transport::Connection.session.create_channel
+    ABSORBER_QUEUES.each do |name|
+      check_or_create_queue(channel, name, prefix: 'Absorber queue')
+      channel = Legion::Transport::Connection.session.create_channel
+    end
+  end
+
+  def check_or_create_queue(channel, name, prefix: 'Queue')
+    q = channel.queue(name, durable: true, passive: true)
+    pass("#{prefix} #{name} exists (depth: #{q.message_count})")
+  rescue Bunny::NotFound
+    channel = Legion::Transport::Connection.session.create_channel
+    channel.queue(name, durable: true)
+    pass("#{prefix} #{name} created")
+  rescue StandardError => e
+    fail_test("#{prefix} #{name} check failed: #{e.message}")
+  end
+
+  def test_publish_consume
+    section('Testing publish/consume round-trip')
+
+    channel = Legion::Transport::Connection.session.create_channel
+    test_queue_name = "fleet.smoke_test.#{SecureRandom.hex(4)}"
+
+    exchange = channel.topic('lex.assessor', durable: true)
+    queue = channel.queue(test_queue_name, durable: false, auto_delete: true)
+    queue.bind(exchange, routing_key: "#{test_queue_name}.#")
+
+    test_payload = {
+      work_item_id: SecureRandom.uuid,
+      source:       'smoke_test',
+      title:        'Fleet smoke test message',
+      timestamp:    Time.now.utc.iso8601
+    }
+
+    exchange.publish(
+      JSON.generate(test_payload),
+      routing_key:  "#{test_queue_name}.test",
+      content_type: 'application/json',
+      persistent:   false
+    )
+
+    received = nil
+    Timeout.timeout(5) do
+      _, _, body = queue.pop
+      received = body ? JSON.parse(body, symbolize_names: true) : nil
+    end
+
+    if received && received[:work_item_id] == test_payload[:work_item_id]
+      pass('Publish/consume round-trip successful')
+    else
+      fail_test('Message not received or payload mismatch')
+    end
+  rescue Timeout::Error
+    fail_test('Publish/consume timed out after 5 seconds')
+  rescue StandardError => e
+    fail_test("Publish/consume failed: #{e.message}")
+  ensure
+    queue&.delete
+  end
+
+  def teardown
+    Legion::Transport::Connection.shutdown
+  rescue StandardError
+    nil
+  end
+
+  def section(title)
+    puts
+    puts "--- #{title} ---"
+  end
+
+  def pass(message)
+    @passed += 1
+    @results << { status: :pass, message: message }
+    puts "  [PASS] #{message}"
+  end
+
+  def fail_test(message)
+    @failed += 1
+    @results << { status: :fail, message: message }
+    puts "  [FAIL] #{message}"
+  end
+
+  def report
+    puts
+    puts '=' * 60
+    total = @passed + @failed
+    if @failed.zero?
+      puts "ALL #{total} CHECKS PASSED"
+    else
+      puts "#{@passed}/#{total} passed, #{@failed} FAILED"
+    end
+    puts '=' * 60
+
+    exit(@failed.zero? ? 0 : 1)
+  end
+end
+
+FleetSmokeTest.new.run if $PROGRAM_NAME == __FILE__

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.8.4
+  version: 1.8.5
 platform: ruby
 authors:
 - Esity
@@ -926,6 +926,7 @@ files:
 - lib/legion/workflow/manifest.rb
 - public/governance/index.html
 - public/workflow/index.html
+- scripts/fleet_smoke_test.rb
 - scripts/rollout-ci-workflow.sh
 - scripts/sync-github-labels-topics.sh
 - workflows/autofix-pipeline.yml