legion-mcp 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f74d80bf3fc37b0b0130f77f38d7b1611c3efa6ab193085022d3aa1462e3ad4
-  data.tar.gz: a9ca6d64d2f3c089a787258e4ac88855d9f5d149c22eef1863bfa429157b70ed
+  metadata.gz: 6a3e25d857f68078fd0cdee66c754af9f90d463b51e781c77fc98101a4f6417e
+  data.tar.gz: 210832fec6116565553d64f5903f9c6c2599b4f98d3aaa30a43d78ab6488322b
 SHA512:
-  metadata.gz: cd0bf2a74ac997e5ce7db2bee56a6e9d821f6244ba211c41be054700bfeb7037c557079b6616403a4f188193133d2b2087f496a0ea7be43eec96694e6feed9b9
-  data.tar.gz: af2d74fa1eeb888753a815af65e9a4527fc00d44dfdf4941abc9955f1da539606f3284413518b0b618bcd50c71894ef5f37750154cbf3f35ae224390a89b4204
+  metadata.gz: 33a52a4ad2246bc5332cdd9d2fa63c8ba285945b43c56c79b5fb22088315a51f53828ff3ccd3507ad39cc8613459dfa272aaccda73362a364c91acf21d5200bf
+  data.tar.gz: 4ebbba0174ae96289f20001c0acdaa2d7b475ae671f783cf0297533ddee50bc54ed889f313aff1442c3a840ef2b56637e990f063d412db369048924897518969

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # legion-mcp Changelog
 
+## [0.8.0] - 2026-04-12
+
+### Added
+- `Tools::SkillList` (`legion.skill.list`) — MCP tool to list all skills registered in the Legion daemon with name, namespace, description, trigger words, and trigger type
+- `Tools::SkillDescribe` (`legion.skill.describe`) — MCP tool to get full detail for a named skill (`namespace:name` or bare `name`)
+- `Tools::SkillInvoke` (`legion.skill.invoke`) — MCP tool to invoke a skill by name with optional `conversation_id` context
+- `Tools::SkillCancel` (`legion.skill.cancel`) — MCP tool to cancel an active skill for a given conversation
+- All four skill tools registered in `MCP_SPECIFIC_TOOLS` (now 10 total)
+- `require_relative 'tools/skills'` added to `tools_loader.rb`
+
 ## [0.7.4] - 2026-04-06
 
 ### Changed

data/lib/legion/mcp/server.rb

@@ -31,7 +31,11 @@ module Legion
         Tools::StructuralIndexTool,
         Tools::ToolAudit,
         Tools::StateDiff,
-        Tools::SearchSessions
+        Tools::SearchSessions,
+        Tools::SkillList,
+        Tools::SkillDescribe,
+        Tools::SkillInvoke,
+        Tools::SkillCancel
       ].freeze
 
       @tool_registry = Concurrent::Array.new(MCP_SPECIFIC_TOOLS)

data/lib/legion/mcp/tools/skills.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module MCP
+    module Tools
+      class SkillList < ::MCP::Tool
+        tool_name 'legion.skill.list'
+        description 'List all skills available in this Legion instance.'
+
+        input_schema(properties: {})
+
+        class << self
+          include Legion::Logging::Helper
+
+          def call
+            log.info('Starting legion.mcp.tools.skill_list.call')
+            return error_response('Skills not available: legion-llm not loaded') unless defined?(Legion::LLM::Skills::Registry)
+
+            skills = Legion::LLM::Skills::Registry.all.map do |s|
+              {
+                name:          s.skill_name,
+                namespace:     s.namespace,
+                description:   s.description,
+                trigger_words: s.trigger_words,
+                trigger:       s.trigger
+              }
+            end
+            text_response({ skills: skills, count: skills.size })
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'legion.mcp.tools.skill_list.call')
+            log.warn("SkillList#call failed: #{e.message}")
+            error_response("Failed to list skills: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+
+      class SkillDescribe < ::MCP::Tool
+        tool_name 'legion.skill.describe'
+        description 'Describe a specific skill by its namespace:name key or bare name.'
+
+        input_schema(
+          properties: {
+            name: {
+              type:        'string',
+              description: 'Skill key in namespace:name format (e.g. "superpowers:brainstorming") or bare skill name'
+            }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          include Legion::Logging::Helper
+
+          def call(name:)
+            log.info('Starting legion.mcp.tools.skill_describe.call')
+            return error_response('Skills not available: legion-llm not loaded') unless defined?(Legion::LLM::Skills::Registry)
+
+            skill = find_skill(name)
+            return error_response("Skill '#{name}' not found") if skill.nil?
+
+            text_response({
+                            name:          skill.skill_name,
+                            namespace:     skill.namespace,
+                            description:   skill.description,
+                            trigger_words: skill.trigger_words,
+                            trigger:       skill.trigger,
+                            follows_skill: skill.follows_skill,
+                            steps:         skill.steps
+                          })
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'legion.mcp.tools.skill_describe.call')
+            log.warn("SkillDescribe#call failed: #{e.message}")
+            error_response("Failed to describe skill: #{e.message}")
+          end
+
+          private
+
+          def find_skill(name)
+            skill = Legion::LLM::Skills::Registry.find(name)
+            return skill unless skill.nil?
+            return nil if name.include?(':')
+
+            Legion::LLM::Skills::Registry.all.find { |s| s.skill_name == name }
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+
+      class SkillInvoke < ::MCP::Tool
+        tool_name 'legion.skill.invoke'
+        description 'Invoke a skill for a conversation. The skill will run its configured steps.'
+
+        input_schema(
+          properties: {
+            name:            {
+              type:        'string',
+              description: 'Skill key in namespace:name format (e.g. "superpowers:brainstorming")'
+            },
+            conversation_id: {
+              type:        'string',
+              description: 'Conversation ID to associate the skill run with (optional — generated if omitted)'
+            },
+            initial_message: {
+              type:        'string',
+              description: 'Optional initial message to seed the skill run (defaults to "start skill")'
+            }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          include Legion::Logging::Helper
+
+          def call(name:, conversation_id: nil, initial_message: nil)
+            log.info('Starting legion.mcp.tools.skill_invoke.call')
+            return error_response('Skills not available: legion-llm not loaded') unless defined?(Legion::LLM::Skills::Registry)
+
+            skill = Legion::LLM::Skills::Registry.find(name)
+            return error_response("Skill '#{name}' not found") if skill.nil?
+
+            conv_id = conversation_id || "conv_#{::SecureRandom.hex(8)}"
+            invoke_skill(name, conv_id, initial_message)
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'legion.mcp.tools.skill_invoke.call')
+            log.warn("SkillInvoke#call failed: #{e.message}")
+            error_response("Failed to invoke skill: #{e.message}")
+          end
+
+          private
+
+          def invoke_skill(name, conv_id, initial_message)
+            return error_response('ConversationStore not available — cannot invoke skill') unless defined?(Legion::LLM::ConversationStore)
+
+            unless defined?(Legion::LLM::Pipeline::Executor) && defined?(Legion::LLM::Pipeline::Request)
+              Legion::LLM::ConversationStore.set_skill_state(conv_id, skill_key: name, resume_at: 0)
+              return text_response({ invoked: false, skill: name, conversation_id: conv_id,
+                                     note: 'skill state queued — pipeline executor not available' })
+            end
+
+            Legion::LLM::ConversationStore.set_skill_state(conv_id, skill_key: name, resume_at: 0)
+            req = Legion::LLM::Pipeline::Request.build(
+              messages:        [{ role: :user, content: initial_message || 'start skill' }],
+              conversation_id: conv_id,
+              metadata:        { skill_invoke: true },
+              stream:          false
+            )
+            result = Legion::LLM::Pipeline::Executor.new(req).call
+            text_response({ invoked: true, skill: name, conversation_id: conv_id,
+                            content: result.message[:content] })
+          rescue StandardError => e
+            Legion::LLM::ConversationStore.clear_skill_state(conv_id) if defined?(Legion::LLM::ConversationStore)
+            raise e
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+
+      class SkillCancel < ::MCP::Tool
+        tool_name 'legion.skill.cancel'
+        description 'Cancel an active skill run for a conversation.'
+
+        input_schema(
+          properties: {
+            conversation_id: {
+              type:        'string',
+              description: 'Conversation ID whose active skill should be cancelled'
+            }
+          },
+          required:   ['conversation_id']
+        )
+
+        class << self
+          include Legion::Logging::Helper
+
+          def call(conversation_id:)
+            log.info('Starting legion.mcp.tools.skill_cancel.call')
+            return error_response('ConversationStore not available') unless defined?(Legion::LLM::ConversationStore)
+
+            result = Legion::LLM::ConversationStore.cancel_skill!(conversation_id)
+            if result
+              text_response({ cancelled: true, skill_key: result[:skill_key] })
+            else
+              text_response({ cancelled: false, reason: 'not_running' })
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'legion.mcp.tools.skill_cancel.call')
+            log.warn("SkillCancel#call failed: #{e.message}")
+            error_response("Failed to cancel skill: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools_loader.rb

@@ -69,3 +69,4 @@ require_relative 'tools/structural_index'
 require_relative 'tools/tool_audit'
 require_relative 'tools/state_diff'
 require_relative 'tools/search_sessions'
+require_relative 'tools/skills'

data/lib/legion/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module MCP
-    VERSION = '0.7.4'
+    VERSION = '0.8.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-mcp
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.0
 platform: ruby
 authors:
 - Esity
@@ -209,6 +209,7 @@ files:
 - lib/legion/mcp/tools/run_task.rb
 - lib/legion/mcp/tools/search_sessions.rb
 - lib/legion/mcp/tools/show_worker.rb
+- lib/legion/mcp/tools/skills.rb
 - lib/legion/mcp/tools/state_diff.rb
 - lib/legion/mcp/tools/structural_index.rb
 - lib/legion/mcp/tools/team_summary.rb