legionio 1.7.37 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bafa8899bbfa7e80970cec50a67e3989fc259cc426ebbbf7bc531194bd8b0d8
-  data.tar.gz: 4e768d2523b3a9b962f8d1119061fe25d71c8e101acb071cef793b40695ebb8c
+  metadata.gz: bce17019cfaa062e933bb282732b8ac7261a52d94dbbe1ec9338b293cc11ed7f
+  data.tar.gz: a1740ed3e87db1177227e0644489b245096e5870e01c36069a7c7cb2db0efcef
 SHA512:
-  metadata.gz: c20eb127ef11c1f60ad06c42619354a91072a3c79ff103189454c6f8080e60fa1e1b5ad9bdcb77703ccfd3308079117aadad6c7f063f59c5255a01b635d2c3dc
-  data.tar.gz: 0bcaa14c6e8c8a3fd0c9b5f47d2cb64abba2cee271cb09eadf812a460f0bfe5069147bb497b205e910fffa71da98702c3889805ef8d18f09cd7d7d8714020c38
+  metadata.gz: e4cf3b2db7dc3bfca5ce8deb357bc6491e10cd3eea398d80a48993ef8d982211f75d9afb4fa59a112f4087c4e6660a98050d636631a6802fa804ebcbe0c0e9f7
+  data.tar.gz: 5b66c3b1010022bcfca3ba5c76f758a6878572930cda2e8ccde1f90a934c312e30e58c48ea31f6c29e0468eaef60b0c1d994e79295e53243b5f2e21f05e2181b

data/CHANGELOG.md

@@ -8,6 +8,17 @@
 - Trigger word tool injection: extensions and runners declare trigger words that auto-promote deferred tools when detected in LLM messages
 - `Legion::Tools::TriggerIndex` — Concurrent::Map-backed reverse index for O(1) trigger word lookup
 - `trigger_words` DSL on Extensions::Core, runner modules, and Tools::Base
+- also fixed the stupid thor rspec issue
+
+## [1.8.0] - 2026-04-12
+
+### Added
+- `Legion::Extensions::Builder::Skills` — parallel to `Builders::Runners`, discovers and registers `lex-skill-*` gems into `Legion::LLM::Skills::Registry` at boot
+- `Legion::Extensions::Core` — `skills_required?` guard; extensions declaring this flag are skipped when legion-llm is not loaded
+- `Legion::Chat::Skills` rewritten — delegates to `Legion::LLM::Skills::Registry` instead of YAML file discovery; `discover` returns an Array of skill objects
+- `Legion::API::Skills` — REST endpoints: `GET /api/skills`, `GET /api/skills/:namespace/:name`, `POST /api/skills/invoke`, `DELETE /api/skills/active/:conversation_id`
+- `Legion::CLI::SkillCommand` rewritten — delegates to daemon API instead of local YAML parsing; `list`, `show`, `run` subcommands
+- `Legion::Extensions::Builder::Skills` wired into `Extensions::Core#autobuild` after `Builders::Runners`
 
 ## [1.7.36] - 2026-04-09
 

data/lib/legion/api/llm.rb

@@ -15,8 +15,8 @@ module Legion
                         Legion::LLM.started?
 
               halt 503, { 'Content-Type' => 'application/json' },
-                   Legion::JSON.dump({ error: { code:    'llm_unavailable',
-                                                message: 'LLM subsystem is not available' } })
+                   Legion::JSON.generate({ error: { code:    'llm_unavailable',
+                                                    message: 'LLM subsystem is not available' } })
             end
 
             define_method(:cache_available?) do
@@ -241,7 +241,7 @@ module Legion
 
             unless messages.is_a?(Array)
               halt 400, { 'Content-Type' => 'application/json' },
-                   Legion::JSON.dump({ error: { code: 'invalid_messages', message: 'messages must be an array' } })
+                   Legion::JSON.generate({ error: { code: 'invalid_messages', message: 'messages must be an array' } })
             end
 
             caller_identity = env['legion.tenant_id'] || 'api:inference'
@@ -287,6 +287,7 @@ module Legion
                            { requested_by: { identity: caller_identity, type: :user, credential: :api } }
                          end
 
+            caller_metadata = body[:metadata].is_a?(Hash) ? body[:metadata] : {}
             req = Legion::LLM::Pipeline::Request.build(
               messages:        messages,
               system:          body[:system],
@@ -294,7 +295,7 @@ module Legion
               tools:           tool_classes,
               caller:          caller_ctx,
               conversation_id: body[:conversation_id],
-              metadata:        { requested_tools: requested_tools },
+              metadata:        caller_metadata.merge(requested_tools: requested_tools),
               stream:          streaming,
               cache:           { strategy: :default, cacheable: true }
             )

data/lib/legion/api/skills.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Skills
+        def self.registered(app)
+          app.helpers do
+            define_method(:skills_registry_available?) do
+              defined?(Legion::LLM::Skills::Registry)
+            end
+
+            define_method(:skill_descriptor) do |skill|
+              {
+                name:        skill.skill_name,
+                namespace:   skill.namespace,
+                description: skill.description,
+                trigger:     skill.trigger,
+                follows:     skill.follows_skill
+              }
+            end
+          end
+
+          register_list(app)
+          register_show(app)
+          register_invoke(app)
+          register_cancel(app)
+        end
+
+        def self.register_list(app)
+          app.get '/api/skills' do
+            return json_error('skills_unavailable', 'Skills unavailable', status_code: 503) unless skills_registry_available?
+
+            skills = Legion::LLM::Skills::Registry.all.map { |s| skill_descriptor(s) }
+            json_response(skills)
+          end
+        end
+
+        def self.register_show(app)
+          app.get '/api/skills/:namespace/:name' do
+            return json_error('skills_unavailable', 'Skills unavailable', status_code: 503) unless skills_registry_available?
+
+            key   = "#{params[:namespace]}:#{params[:name]}"
+            skill = Legion::LLM::Skills::Registry.find(key)
+            return json_error('not_found', "Skill #{key} not found", status_code: 404) unless skill
+
+            json_response(skill_descriptor(skill).merge(steps: skill.steps))
+          end
+        end
+
+        def self.register_invoke(app)
+          app.post '/api/skills/invoke' do
+            return json_error('skills_unavailable', 'Skills unavailable', status_code: 503) unless skills_registry_available?
+
+            body       = parse_request_body
+            skill_name = body[:skill_name]
+            return json_error('unprocessable', 'skill_name required', status_code: 422) if skill_name.nil? || skill_name.empty?
+
+            skill_class = Legion::LLM::Skills::Registry.find(skill_name)
+            return json_error('not_found', "Skill #{skill_name} not found", status_code: 404) unless skill_class
+
+            conv_id = body[:conversation_id] || "conv_#{SecureRandom.hex(8)}"
+            begin
+              Legion::LLM::ConversationStore.set_skill_state(conv_id, skill_key: skill_name, resume_at: 0)
+              req = Legion::LLM::Pipeline::Request.build(
+                messages:        [{ role: :user, content: body[:initial_message] || 'start skill' }],
+                conversation_id: conv_id,
+                metadata:        (body[:metadata].is_a?(Hash) ? body[:metadata] : {}).merge(skill_invoke: true),
+                stream:          false
+              )
+              result = Legion::LLM::Pipeline::Executor.new(req).call
+              json_response({ conversation_id: conv_id, content: result.message[:content],
+                              skill_name: skill_name })
+            rescue StandardError => e
+              Legion::LLM::ConversationStore.clear_skill_state(conv_id)
+              json_error('internal_error', e.message, status_code: 500)
+            end
+          end
+        end
+
+        def self.register_cancel(app)
+          app.delete '/api/skills/active/:conversation_id' do
+            conv_id = params[:conversation_id]
+            if defined?(Legion::LLM::ConversationStore)
+              state = Legion::LLM::ConversationStore.cancel_skill!(conv_id)
+              if state && defined?(Legion::Events)
+                Legion::Events.emit('skill.cancelled', conversation_id: conv_id,
+                                                       skill_name:      state[:skill_key])
+              end
+            end
+            status 204
+          end
+        end
+
+        private_class_method :register_list, :register_show, :register_invoke, :register_cancel
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -35,6 +35,7 @@ require_relative 'api/capacity'
 require_relative 'api/audit'
 require_relative 'api/metrics'
 require_relative 'api/llm'
+require_relative 'api/skills'
 require_relative 'api/catalog'
 require_relative 'api/org_chart'
 require_relative 'api/workflow'
@@ -197,6 +198,7 @@ module Legion
     register Routes::Audit
     register Routes::Metrics
     mount_library_routes('llm', Routes::Llm, 'Legion::LLM::Routes')
+    register Routes::Skills
     register Routes::ExtensionCatalog
     register Routes::OrgChart
     register Routes::Governance

data/lib/legion/chat/skills.rb

@@ -1,123 +1,62 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Legion
   module Chat
     module Skills
-      SKILL_DIRS = ['.legion/skills', '~/.legionio/skills'].freeze
-
       class << self
         def discover
-          SKILL_DIRS.flat_map do |dir|
-            expanded = File.expand_path(dir)
-            next [] unless Dir.exist?(expanded)
+          return file_discover unless llm_skills_available?
 
-            md_skills = Dir.glob(File.join(expanded, '*.md')).filter_map { |f| parse(f) }
-            rb_skills = Dir.glob(File.join(expanded, '*.rb')).filter_map { |f| parse_rb(f) }
-            md_skills + rb_skills
-          end
+          Legion::LLM::Skills::Registry.all.map { |s| registry_descriptor(s) }
         end
 
         def find(name)
-          discover.find { |s| s[:name] == name.to_s }
-        end
-
-        def parse(path)
-          content = File.read(path)
-          return nil unless content.start_with?('---')
-
-          parts = content.split(/^---\s*$/, 3)
-          return nil if parts.size < 3
+          return file_find(name) unless llm_skills_available?
 
-          frontmatter = YAML.safe_load(parts[1], permitted_classes: [Symbol])
-          body = parts[2]&.strip
-
-          {
-            name:        frontmatter['name'] || File.basename(path, '.md'),
-            description: frontmatter['description'] || '',
-            type:        :prompt,
-            model:       frontmatter['model'],
-            tools:       Array(frontmatter['tools']),
-            prompt:      body,
-            path:        path
-          }
-        rescue StandardError => e
-          Legion::Logging.warn "Skill parse error #{path}: #{e.message}" if defined?(Legion::Logging)
-          nil
+          skill = Legion::LLM::Skills::Registry.find(name)
+          skill ? registry_descriptor(skill) : nil
         end
 
-        def parse_rb(path)
-          content = File.read(path)
+        # execute: REMOVED — all skill execution routes through the daemon API.
+        # `legion skill run` / `legion chat` are thin HTTP clients; no local LLM boot.
 
-          name = File.basename(path, '.rb')
-          description = content.match(/^\s*#\s*description:\s*(.+)$/i)&.captures&.first || ''
-          model = content.match(/^\s*#\s*model:\s*(.+)$/i)&.captures&.first
+        private
 
-          {
-            name:        name,
-            description: description.strip,
-            type:        :ruby,
-            model:       model&.strip,
-            tools:       [],
-            prompt:      nil,
-            path:        path
-          }
-        rescue StandardError => e
-          Legion::Logging.warn "Skill parse_rb error #{path}: #{e.message}" if defined?(Legion::Logging)
-          nil
+        def llm_skills_available?
+          defined?(Legion::LLM::Skills) &&
+            Legion::LLM.respond_to?(:started?) &&
+            Legion::LLM.started?
         end
 
-        def execute(skill, input: nil)
-          case skill[:type]
-          when :ruby
-            execute_rb(skill, input: input)
-          when :prompt
-            execute_prompt(skill, input: input)
-          else
-            { success: false, error: "unknown skill type: #{skill[:type]}" }
-          end
+        def registry_descriptor(skill)
+          { name: skill.skill_name, namespace: skill.namespace, prompt: nil,
+            description: skill.description, source: :registry }
         end
 
-        private
-
-        def execute_prompt(skill, input: nil)
-          return { success: false, error: 'Legion::LLM not available' } unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat_direct)
-
-          prompt = skill[:prompt]
-          prompt = "#{prompt}\n\nUser input: #{input}" if input
-
-          session = Legion::LLM.chat_direct(model: skill[:model], provider: nil)
-          response = session.ask(prompt)
-          content = response.respond_to?(:content) ? response.content : response.to_s
-
-          { success: true, output: content }
-        rescue StandardError => e
-          { success: false, error: e.message }
+        def file_discover
+          dirs = skill_directories
+          dirs.flat_map { |dir| ::Dir.glob(::File.join(dir, '*.{md,rb,yml,yaml}')) }
+              .map { |f| { name: ::File.basename(f, '.*'), path: f, source: :file } }
         end
 
-        def execute_rb(skill, input: nil)
-          begin
-            real_path = File.realpath(skill[:path])
-          rescue Errno::ENOENT
-            return { success: false, error: "skill file not found: #{skill[:path]}" }
-          end
-          allowed = SKILL_DIRS.filter_map do |dir|
-            expanded = File.expand_path(dir)
-            File.realpath(expanded) if Dir.exist?(expanded)
-          end
-          unless allowed.any? { |dir| real_path.start_with?("#{dir}/") }
-            return { success: false, error: "skill path outside allowed directories: #{real_path}" }
-          end
+        def file_find(name)
+          dirs = skill_directories
+          dirs.each do |dir|
+            %w[.md .rb .yml .yaml].each do |ext|
+              path = ::File.join(dir, "#{name}#{ext}")
+              next unless ::File.exist?(path)
 
-          mod = Module.new
-          mod.module_eval(File.read(real_path), real_path)
-          return { success: false, error: "#{skill[:name]}.rb must define a module-level `self.call` method" } unless mod.respond_to?(:call)
+              return { name: name, path: path, prompt: ::File.read(path), source: :file }
+            end
+          end
+          nil
+        end
 
-          result = mod.call(input: input)
-          { success: true, output: result }
-        rescue StandardError => e
-          { success: false, error: e.message }
+        def skill_directories
+          [
+            ::File.expand_path('.legion/skills'),
+            ::File.expand_path('~/.legionio/skills')
+          ].select { |d| ::File.directory?(d) }
         end
       end
     end

data/lib/legion/cli/skill_command.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'net/http'
+require 'json'
+require 'uri'
 
 module Legion
   module CLI
@@ -9,45 +12,50 @@ module Legion
         true
       end
 
-      desc 'list', 'List all discovered skills'
+      desc 'list', 'List all registered skills'
       def list
-        require 'legion/chat/skills'
-        skills = Legion::Chat::Skills.discover
+        response = daemon_get('/api/skills')
+        unless response.is_a?(::Net::HTTPSuccess)
+          say "Error fetching skills: #{response.code}", :red
+          exit 1
+        end
+
+        skills = ::JSON.parse(response.body, symbolize_names: true)[:data] || []
         if skills.empty?
-          say 'No skills found. Create skills in .legion/skills/ or ~/.legionio/skills/'
+          say 'No skills registered. Start the daemon with legion-llm loaded.'
           return
         end
 
         skills.each do |s|
-          type_label = s[:type] == :ruby ? '[rb]' : '[md]'
-          say "  /#{s[:name]} #{type_label} — #{s[:description]}", :green
-          say "    model: #{s[:model] || 'default'}, tools: #{s[:tools].empty? ? 'none' : s[:tools].join(', ')}"
+          say "  #{s[:namespace]}:#{s[:name]}  [#{s[:trigger]}]  #{s[:description]}", :green
         end
       end
 
-      desc 'show NAME', 'Display skill definition'
+      desc 'show NAMESPACE:NAME', 'Show skill details'
       def show(name)
-        require 'legion/chat/skills'
-        skill = Legion::Chat::Skills.find(name)
-        if skill
-          say "Name: #{skill[:name]}", :green
-          say "Description: #{skill[:description]}"
-          say "Model: #{skill[:model] || 'default'}"
-          say "Tools: #{skill[:tools].empty? ? 'none' : skill[:tools].join(', ')}"
-          say "Path: #{skill[:path]}"
-          say "\n--- Prompt ---\n#{skill[:prompt]}"
-        else
+        ns, nm = name.include?(':') ? name.split(':', 2) : ['default', name]
+        response = daemon_get("/api/skills/#{ns}/#{nm}")
+        unless response.is_a?(::Net::HTTPSuccess)
           say "Skill '#{name}' not found", :red
+          exit 1
         end
+
+        result = ::JSON.parse(response.body, symbolize_names: true)
+        data   = result[:data] || {}
+        say "Name:        #{data[:namespace]}:#{data[:name]}", :green
+        say "Description: #{data[:description]}"
+        say "Trigger:     #{data[:trigger]}"
+        say "Steps:       #{Array(data[:steps]).join(', ')}"
       end
 
       desc 'create NAME', 'Scaffold a new skill file'
       def create(name)
+        require 'fileutils'
         dir = '.legion/skills'
         FileUtils.mkdir_p(dir)
-        path = File.join(dir, "#{name}.md")
+        path = ::File.join(dir, "#{name}.md")
 
-        if File.exist?(path)
+        if ::File.exist?(path)
           say "Skill already exists: #{path}", :red
           return
         end
@@ -55,35 +63,49 @@ module Legion
         content = <<~SKILL
           ---
           name: #{name}
+          namespace: local
           description: Describe what this skill does
-          model:
-          tools: []
+          trigger: on_demand
           ---
 
           You are a helpful assistant. Describe the skill's behavior here.
         SKILL
 
-        File.write(path, content)
+        ::File.write(path, content)
         say "Created: #{path}", :green
       end
 
-      desc 'execute NAME [INPUT]', 'Run a skill outside of chat'
-      map 'run' => :execute
-      def execute(name, *input)
-        require 'legion/chat/skills'
-        skill = Legion::Chat::Skills.find(name)
-        unless skill
-          say "Skill '#{name}' not found", :red
-          return
-        end
+      desc 'run NAME', 'Run a skill via the daemon'
+      map 'run' => :run_skill
+      def run_skill(name)
+        url     = "#{daemon_base_url}/api/skills/invoke"
+        payload = { skill_name: name }.to_json
 
-        user_input = input.empty? ? nil : input.join(' ')
-        result = Legion::Chat::Skills.execute(skill, input: user_input)
+        response = ::Net::HTTP.post(
+          ::URI.parse(url),
+          payload,
+          'Content-Type' => 'application/json'
+        )
 
-        if result[:success]
-          say result[:output].to_s
+        if response.is_a?(::Net::HTTPSuccess)
+          result = ::JSON.parse(response.body, symbolize_names: true)
+          say result.dig(:data, :content).to_s
         else
-          say "Skill failed: #{result[:error]}", :red
+          say "Error: #{response.code} #{response.body}", :red
+          exit 1
+        end
+      end
+
+      no_commands do
+        def daemon_base_url
+          host = Legion::Settings.dig(:api, :host) || 'localhost'
+          port = Legion::Settings.dig(:api, :port) || 4567
+          "http://#{host}:#{port}"
+        end
+
+        def daemon_get(path)
+          uri = ::URI.parse("#{daemon_base_url}#{path}")
+          ::Net::HTTP.get_response(uri)
         end
       end
     end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Builder
+      module Skills
+        include Legion::Extensions::Builder::Base
+
+        attr_reader :skills
+
+        def build_skills
+          return unless Object.const_defined?('Legion::LLM::Skills', false)
+          return unless Object.const_defined?('Legion::LLM', false) &&
+                        Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+          return if Legion::LLM.settings.dig(:skills, :enabled) == false
+
+          @skills = {}
+          lex_mod = lex_class.is_a?(::Module) ? lex_class : ::Kernel.const_get(lex_class.to_s)
+          lex_mod.const_set(:Skills, ::Module.new) unless lex_mod.const_defined?(:Skills, false)
+          require_files(skill_files)
+          build_skill_list
+        end
+
+        def build_skill_list
+          skill_files.each do |file|
+            skill_name       = file.split('/').last.sub('.rb', '')
+            skill_class_name = "#{lex_class}::Skills::#{skill_name.split('_').collect(&:capitalize).join}"
+            loaded_skill     = Kernel.const_get(skill_class_name)
+            Legion::LLM::Skills::Registry.register(loaded_skill)
+            @skills[skill_name.to_sym] = {
+              skill_class:  skill_class_name,
+              skill_module: loaded_skill
+            }
+            Legion::Logging.debug "[Skills] registered: #{skill_class_name}" if defined?(Legion::Logging)
+          end
+        end
+
+        def skill_files
+          @skill_files ||= find_files('skills')
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/core.rb

@@ -7,6 +7,7 @@ require_relative 'builders/helpers'
 require_relative 'builders/hooks'
 require_relative 'builders/routes'
 require_relative 'builders/runners'
+require_relative 'builders/skills'
 
 require_relative 'helpers/segments'
 require_relative 'helpers/core'
@@ -57,6 +58,7 @@ module Legion
       include Legion::Extensions::Builder::Actors
       include Legion::Extensions::Builder::Hooks
       include Legion::Extensions::Builder::Routes
+      include Legion::Extensions::Builder::Skills
 
       def autobuild
         Legion::Logging.debug "[Core] autobuild start: #{name}" if defined?(Legion::Logging)
@@ -81,6 +83,7 @@ module Legion
         build_actors
         build_hooks
         build_routes
+        build_skills if skills_required?
         Legion::Logging.debug "[Core] autobuild complete: #{name}" if defined?(Legion::Logging)
       end
 
@@ -108,6 +111,10 @@ module Legion
         false
       end
 
+      def skills_required?
+        false
+      end
+
       def remote_invocable?
         true
       end

data/lib/legion/extensions.rb

@@ -266,6 +266,12 @@ module Legion
           return false
         end
 
+        if extension.respond_to?(:skills_required?) && extension.skills_required? &&
+           !Object.const_defined?('Legion::LLM::Skills', false)
+          Legion::Logging.warn "#{ext_name} requires Legion::LLM::Skills but isn't loaded, skipping"
+          return false
+        end
+
         has_logger = extension.respond_to?(:log)
         extension.autobuild
 

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.37
+  version: 1.8.0
 platform: ruby
 authors:
 - Esity
@@ -516,6 +516,7 @@ files:
 - lib/legion/api/router.rb
 - lib/legion/api/schedules.rb
 - lib/legion/api/settings.rb
+- lib/legion/api/skills.rb
 - lib/legion/api/stats.rb
 - lib/legion/api/sync_dispatch.rb
 - lib/legion/api/tasks.rb
@@ -817,6 +818,7 @@ files:
 - lib/legion/extensions/builders/hooks.rb
 - lib/legion/extensions/builders/routes.rb
 - lib/legion/extensions/builders/runners.rb
+- lib/legion/extensions/builders/skills.rb
 - lib/legion/extensions/capability.rb
 - lib/legion/extensions/catalog.rb
 - lib/legion/extensions/catalog/available.rb