legionio 1.4.186 → 1.4.187

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe7c5039053d23c8a5870b63ca0059a3c30c1112bdad029206baafa574037fa8
-  data.tar.gz: 9e4a119425469614f68c2a4ad4d966656248ae3601850ba0841e7d31144de583
+  metadata.gz: b09d64e1595a3f95f937031e668f6b9a0fd53eb491a93641c4a539c6d702851b
+  data.tar.gz: c490032828ae6057ef5c4cfb8520c9942b7f0654e46262cc72a06aa3db078975
 SHA512:
-  metadata.gz: 4647975c2d46807169d45b66b7dc3a45f533c7964d17113945e4ee605904efcca32d3efbe1acf061cffcbfb34fb4125c67d14522a1976d1c0824e55c7a9d9d1e
-  data.tar.gz: 73fe8aac0e9a7e64dbf3564b7fa8c0e8427cb507649096664e40c79632aef16ed93b19684fdfcba86ce84129c44ca69077490002aa1eb226ad591a250a991f51
+  metadata.gz: 6c35f063fe1cbbf4f3b5867956acebe29f486a0fda4227d271fd3ae6e0b4c877329aad0d1d8e65d38b39cdca8abbb693da48bb6caab52fffe0e654489056b2df
+  data.tar.gz: c47560f824ba85fe4847c2992a46fbeb6c2504ecdf21de6cfd520fcc547b59de08dac53cb182113651efa316f47995f8a02cccc8ad268e5a00844eb7acc9ecfe

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Legion Changelog
 
+## [1.4.187] - 2026-03-23
+
+### Added
+- `Legion::Extensions::Capability` Data.define struct for extension capability registration
+- `Legion::Extensions::Catalog::Registry` in-memory capability registry with register, find, find_by_intent, for_mcp, for_override, find_by_mcp_name
+- `register_capabilities` populates Catalog::Registry from extension runners at boot
+- `unregister_capabilities` removes capabilities from Catalog on extension unload
+- `Catalog::Registry.on_change` callback for notifying consumers on registry changes
+
 ## [1.4.186] - 2026-03-23
 
 ### Fixed

data/lib/legion/extensions/capability.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    Capability = ::Data.define(
+      :name, :extension, :runner, :function,
+      :description, :parameters, :tags, :loaded_at
+    ) do
+      def self.from_runner(extension:, runner:, function:, **opts)
+        canonical = "#{extension}:#{runner.to_s.gsub(/([A-Z])/, '_\1').sub(/^_/, '').downcase}:#{function}"
+        new(
+          name:        canonical,
+          extension:   extension,
+          runner:      runner.to_s,
+          function:    function.to_s,
+          description: opts[:description],
+          parameters:  opts[:parameters] || {},
+          tags:        Array(opts[:tags]),
+          loaded_at:   Time.now
+        )
+      end
+
+      def matches_intent?(text)
+        words = text.downcase.split(/\s+/)
+        searchable = [description, *tags, extension, runner, function]
+                     .compact.join(' ').downcase
+
+        matching = words.count { |w| searchable.include?(w) }
+        matching.to_f / [words.length, 1].max >= 0.4
+      end
+
+      def to_mcp_tool
+        snake_runner = runner.gsub(/([A-Z])/, '_\1').sub(/^_/, '').downcase
+        tool_name = "legion.#{extension.delete_prefix('lex-').tr('-', '_')}.#{snake_runner}.#{function}"
+        properties = (parameters || {}).transform_values do |v|
+          v.is_a?(Hash) ? v : { type: v.to_s }
+        end
+
+        {
+          name:         tool_name,
+          description:  description || "#{extension} #{runner}##{function}",
+          input_schema: {
+            type:       'object',
+            properties: properties,
+            required:   parameters&.select { |_, v| v.is_a?(Hash) && v[:required] }&.keys&.map(&:to_s) || []
+          }
+        }
+      end
+    end
+  end
+end

data/lib/legion/extensions/catalog/registry.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Catalog
+      module Registry
+        @capabilities = []
+        @by_name = {}
+        @mutex = Mutex.new
+        @on_change_callbacks = []
+
+        module_function
+
+        def register(capability)
+          @mutex.synchronize do
+            return if @by_name.key?(capability.name)
+
+            @capabilities << capability
+            @by_name[capability.name] = capability
+          end
+          notify_change
+        end
+
+        def unregister(name)
+          @mutex.synchronize do
+            cap = @by_name.delete(name)
+            @capabilities.delete(cap) if cap
+            return unless cap
+          end
+          notify_change
+        end
+
+        def unregister_extension(extension_name)
+          @mutex.synchronize do
+            removed = @capabilities.select { |c| c.extension == extension_name }
+            removed.each do |cap|
+              @by_name.delete(cap.name)
+              @capabilities.delete(cap)
+            end
+            return if removed.empty?
+          end
+          notify_change
+        end
+
+        def capabilities
+          @mutex.synchronize { @capabilities.dup.freeze }
+        end
+
+        def find(name:)
+          @mutex.synchronize { @by_name[name] }
+        end
+
+        def find_by_intent(text)
+          @mutex.synchronize do
+            @capabilities.select { |c| c.matches_intent?(text) }
+          end
+        end
+
+        def for_mcp
+          @mutex.synchronize { @capabilities.dup }
+        end
+
+        def find_by_mcp_name(mcp_name)
+          @mutex.synchronize do
+            @capabilities.find { |cap| cap.to_mcp_tool[:name] == mcp_name }
+          end
+        end
+
+        def for_override(tool_name)
+          @mutex.synchronize do
+            normalized = tool_name.downcase.tr('-', '_')
+            @capabilities.find do |cap|
+              cap.function.downcase == normalized ||
+                cap.name.downcase.end_with?(normalized) ||
+                cap.tags.any? { |t| t.downcase == normalized }
+            end
+          end
+        end
+
+        def count
+          @mutex.synchronize { @capabilities.length }
+        end
+
+        def on_change(&block)
+          @mutex.synchronize { @on_change_callbacks << block }
+        end
+
+        def reset!
+          @mutex.synchronize do
+            @capabilities.clear
+            @by_name.clear
+            @on_change_callbacks.clear
+          end
+        end
+
+        def notify_change
+          callbacks = @mutex.synchronize { @on_change_callbacks.dup }
+          callbacks.each do |cb|
+            cb.call
+          rescue StandardError => e
+            Legion::Logging.warn("Catalog::Registry on_change error: #{e.message}") if defined?(Legion::Logging)
+          end
+        end
+
+        private_class_method :notify_change
+      end
+    end
+  end
+end

data/lib/legion/extensions/catalog.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'catalog/registry'
+
 module Legion
   module Extensions
     module Catalog

data/lib/legion/extensions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/core'
+require 'legion/extensions/capability'
 require 'legion/extensions/catalog'
 require 'legion/extensions/permissions'
 require 'legion/runner'
@@ -45,7 +46,10 @@ module Legion
         @timer_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
         @poll_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
 
-        @loaded_extensions.each { |name| Catalog.transition(name, :stopped) }
+        @loaded_extensions.each do |name|
+          Catalog.transition(name, :stopped)
+          unregister_capabilities(name)
+        end
         Legion::Logging.info 'Successfully shut down all actors'
       end
 
@@ -158,6 +162,8 @@ module Legion
         require 'legion/transport/messages/lex_register'
         Legion::Transport::Messages::LexRegister.new(function: 'save', opts: extension.runners).publish
 
+        register_capabilities(entry[:gem_name], extension.runners) if extension.respond_to?(:runners)
+
         if extension.respond_to?(:meta_actors) && extension.meta_actors.is_a?(Hash)
           extension.meta_actors.each_value do |actor|
             extension.log.debug("deferring meta actor: #{actor}") if has_logger
@@ -345,6 +351,36 @@ module Legion
 
       public
 
+      def unregister_capabilities(gem_name)
+        Extensions::Catalog::Registry.unregister_extension(gem_name)
+      end
+
+      def register_capabilities(gem_name, runners)
+        runners.each_value do |runner_meta|
+          runner_name = runner_meta[:runner_name]
+          (runner_meta[:class_methods] || {}).each do |fn_name, fn_meta|
+            next if fn_name.to_s.start_with?('_')
+
+            params = {}
+            (fn_meta[:args] || []).each do |arg|
+              type, name = arg
+              params[name] = { type: :string, required: type == :keyreq }
+            end
+
+            cap = Extensions::Capability.from_runner(
+              extension:  gem_name,
+              runner:     runner_name.to_s.split('_').map(&:capitalize).join,
+              function:   fn_name.to_s,
+              parameters: params,
+              tags:       [gem_name.delete_prefix('lex-')]
+            )
+            Extensions::Catalog::Registry.register(cap)
+          end
+        rescue StandardError => e
+          Legion::Logging.warn("Catalog registration error for #{gem_name}: #{e.message}") if defined?(Legion::Logging)
+        end
+      end
+
       def gem_load(entry)
         gem_name     = entry[:gem_name]
         require_path = entry[:require_path]

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.186
+  version: 1.4.187
 platform: ruby
 authors:
 - Esity
@@ -689,7 +689,9 @@ files:
 - lib/legion/extensions/builders/hooks.rb
 - lib/legion/extensions/builders/routes.rb
 - lib/legion/extensions/builders/runners.rb
+- lib/legion/extensions/capability.rb
 - lib/legion/extensions/catalog.rb
+- lib/legion/extensions/catalog/registry.rb
 - lib/legion/extensions/core.rb
 - lib/legion/extensions/data.rb
 - lib/legion/extensions/data/migrator.rb