legion-mcp 0.7.4 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f74d80bf3fc37b0b0130f77f38d7b1611c3efa6ab193085022d3aa1462e3ad4
-  data.tar.gz: a9ca6d64d2f3c089a787258e4ac88855d9f5d149c22eef1863bfa429157b70ed
+  metadata.gz: dbc548bee22e23b6829490dcb7df334ae19c470f4f0d5d9148831b125083e323
+  data.tar.gz: 56bc136cb3b5801dce2d7fed3ba947ff9de1abd64c3dd996caa67cdffca49cd1
 SHA512:
-  metadata.gz: cd0bf2a74ac997e5ce7db2bee56a6e9d821f6244ba211c41be054700bfeb7037c557079b6616403a4f188193133d2b2087f496a0ea7be43eec96694e6feed9b9
-  data.tar.gz: af2d74fa1eeb888753a815af65e9a4527fc00d44dfdf4941abc9955f1da539606f3284413518b0b618bcd50c71894ef5f37750154cbf3f35ae224390a89b4204
+  metadata.gz: 62db181395833185ab2e9b11b7ef3281a2e49761aab8d61feabce4fd19389fe768af86b26d0e24501ebb0ca2237ec87bd820ca18417b4eda3e77921fade69508
+  data.tar.gz: f5f1429b9cd74bcfaaf61083a38c5c5245644beee9e6ae3910ccb947f0f6809b8e9ef664bdce3d6a4ad3b9ec493788d92bb587c0d53bde7b75d7bed3b5a0fef0

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # legion-mcp Changelog
 
+## [0.8.1] - 2026-04-14
+
+### Fixed
+- `ContextCompiler::CATEGORIES` now includes a `:skills` category listing all four `legion.skill.*` tools (`legion.skill.list`, `legion.skill.describe`, `legion.skill.invoke`, `legion.skill.cancel`). Previously they were absent from `CATEGORIES` so `compressed_catalog` never surfaced them and `legion.do intent:"list all skills"` would misroute to an auto-discovered swarm-github runner, returning "missing keywords: :owner, :repo, :pull_number"
+- `ContextCompiler#keyword_score_map` now adds a +3 bonus per intent keyword that matches tool name terms (split on `.`), preventing semantic-score drift from lifting generic runner stubs above correctly-named skill tools when embeddings are active
+
+## [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/context_compiler.rb

@@ -71,6 +71,10 @@ module Legion
           tools:   %w[legion.eval_list legion.eval_run legion.eval_results],
           summary: 'Evaluation management - list evaluators, run evaluations, view results.'
         },
+        skills:        {
+          tools:   %w[legion.skill.list legion.skill.describe legion.skill.invoke legion.skill.cancel],
+          summary: 'Skill management - list, describe, invoke, and cancel LLM skills.'
+        },
         meta:          {
           tools:   %w[legion.do legion.tools legion.plan_action legion.structural_index],
           summary: 'Meta-tools - natural language routing, tool discovery, planning, structural index.'
@@ -214,6 +218,8 @@ module Legion
         tool_index.values.to_h do |entry|
           haystack = "#{entry[:name].downcase} #{entry[:description].downcase}"
           score = keywords.count { |kw| haystack.include?(kw) }
+          name_terms = entry[:name].downcase.tr('._-', ' ').split
+          score += (keywords & name_terms).length * 3
           [entry[:name], score]
         end
       end

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.1'
   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.1
 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