legion-mcp 0.1.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DisableExtension < ::MCP::Tool
+        tool_name 'legion.disable_extension'
+        description 'Disable a Legion extension by ID.'
+
+        input_schema(
+          properties: {
+            id: { type: 'integer', description: 'Extension ID' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            ext = Legion::Data::Model::Extension[id.to_i]
+            return error_response("Extension #{id} not found") unless ext
+
+            ext.update(active: false)
+            ext.refresh
+            text_response(ext.values)
+          rescue StandardError => e
+            error_response("Failed to disable extension: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DiscoverTools < ::MCP::Tool
+        tool_name 'legion.tools'
+        description 'Discover available Legion tools by category or intent. Returns compressed definitions to reduce context.'
+
+        input_schema(
+          properties: {
+            category: {
+              type:        'string',
+              description: 'Tool category: tasks, chains, relationships, extensions, schedules, workers, rbac, status, describe'
+            },
+            intent:   {
+              type:        'string',
+              description: 'Describe what you want to do and relevant tools will be ranked'
+            }
+          }
+        )
+
+        class << self
+          def call(category: nil, intent: nil)
+            if category
+              result = ContextCompiler.category_tools(category.to_sym)
+              return error_response("Unknown category: #{category}") if result.nil?
+
+              text_response(result)
+            elsif intent
+              results = ContextCompiler.match_tools(intent, limit: 5)
+              text_response({ matched_tools: results })
+            else
+              text_response(ContextCompiler.compressed_catalog)
+            end
+          rescue StandardError => e
+            error_response("Failed: #{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/do_action.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DoAction < ::MCP::Tool
+        tool_name 'legion.do'
+        description 'Execute a Legion action by describing what you want to do in natural language. ' \
+                    'Routes to the best matching tool automatically. Learned patterns are served ' \
+                    'instantly without LLM.'
+
+        input_schema(
+          properties: {
+            intent:  {
+              type:        'string',
+              description: 'Natural language description (e.g., "list all running tasks")'
+            },
+            params:  {
+              type:                 'object',
+              description:          'Parameters to pass to the matched tool',
+              additionalProperties: true
+            },
+            context: {
+              type:                 'object',
+              description:          'Additional context (service, environment, etc.)',
+              additionalProperties: true
+            }
+          },
+          required:   ['intent']
+        )
+
+        class << self
+          def call(intent:, params: {}, context: {})
+            # Try Tier 0 first (learned patterns)
+            tier_result = try_tier0(intent, params, context)
+            if tier_result && tier_result[:tier].zero?
+              return text_response(tier_result[:response].merge(
+                                     _meta: { tier:       0,
+                                              latency_ms: tier_result[:latency_ms],
+                                              confidence: tier_result[:pattern_confidence] }
+                                   ))
+            end
+
+            # Fall back to ContextCompiler tool matching (original behavior)
+            matched = ContextCompiler.match_tool(intent)
+            return error_response("No matching tool found for intent: #{intent}") if matched.nil?
+
+            Legion::MCP::Observer.record_intent(intent, matched) if defined?(Legion::MCP::Observer)
+
+            tool_params = params.transform_keys(&:to_sym)
+            if tool_params.empty?
+              matched.call
+            else
+              matched.call(**tool_params)
+            end
+          rescue StandardError => e
+            error_response("Failed: #{e.message}")
+          end
+
+          private
+
+          def try_tier0(intent, params, context)
+            return nil unless defined?(Legion::MCP::TierRouter)
+
+            Legion::MCP::TierRouter.route(
+              intent:  intent,
+              params:  params.transform_keys(&:to_sym),
+              context: context.transform_keys(&:to_sym)
+            )
+          rescue StandardError
+            nil
+          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
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class EnableExtension < ::MCP::Tool
+        tool_name 'legion.enable_extension'
+        description 'Enable a Legion extension by ID.'
+
+        input_schema(
+          properties: {
+            id: { type: 'integer', description: 'Extension ID' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            ext = Legion::Data::Model::Extension[id.to_i]
+            return error_response("Extension #{id} not found") unless ext
+
+            ext.update(active: true)
+            ext.refresh
+            text_response(ext.values)
+          rescue StandardError => e
+            error_response("Failed to enable extension: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class GetConfig < ::MCP::Tool
+        tool_name 'legion.get_config'
+        description 'Get Legion configuration (sensitive values are redacted).'
+
+        input_schema(
+          properties: {
+            section: { type: 'string', description: 'Specific config section (e.g., "transport", "data")' }
+          }
+        )
+
+        SENSITIVE_KEYS = %i[password secret token key cert private_key api_key].freeze
+
+        class << self
+          def call(section: nil)
+            settings = Legion::Settings.loader.to_hash
+
+            if section
+              key = section.to_sym
+              return error_response("Setting '#{section}' not found") unless settings.key?(key)
+
+              value = settings[key]
+              value = redact_hash(value) if value.is_a?(Hash)
+              text_response({ key: key, value: value })
+            else
+              text_response(redact_hash(settings))
+            end
+          rescue StandardError => e
+            error_response("Failed to get config: #{e.message}")
+          end
+
+          private
+
+          def redact_hash(hash)
+            return hash unless hash.is_a?(Hash)
+
+            hash.each_with_object({}) do |(k, v), result|
+              result[k] = if v.is_a?(Hash)
+                            redact_hash(v)
+                          elsif SENSITIVE_KEYS.any? { |s| k.to_s.include?(s.to_s) }
+                            '[REDACTED]'
+                          else
+                            v
+                          end
+            end
+          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
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class GetExtension < ::MCP::Tool
+        tool_name 'legion.get_extension'
+        description 'Get detailed info about an extension including its runners and functions.'
+
+        input_schema(
+          properties: {
+            id: { type: 'integer', description: 'Extension ID' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            ext = Legion::Data::Model::Extension[id.to_i]
+            return error_response("Extension #{id} not found") unless ext
+
+            runners = Legion::Data::Model::Runner.where(extension_id: id.to_i).all
+            result = ext.values.merge(
+              runners: runners.map do |r|
+                functions = Legion::Data::Model::Function.where(runner_id: r.values[:id]).all
+                r.values.merge(functions: functions.map(&:values))
+              end
+            )
+
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to get extension: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class GetStatus < ::MCP::Tool
+        tool_name 'legion.get_status'
+        description 'Get Legion service health status and component info.'
+
+        input_schema(properties: {})
+
+        class << self
+          def call
+            status = {
+              version:    Legion::VERSION,
+              ready:      begin
+                Legion::Readiness.ready?
+              rescue StandardError
+                false
+              end,
+              components: begin
+                Legion::Readiness.to_h
+              rescue StandardError
+                {}
+              end,
+              node:       begin
+                Legion::Settings[:client][:name]
+              rescue StandardError
+                'unknown'
+              end
+            }
+            text_response(status)
+          rescue StandardError => e
+            error_response("Failed to get status: #{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/get_task.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class GetTask < ::MCP::Tool
+        tool_name 'legion.get_task'
+        description 'Get details of a specific task by ID.'
+
+        input_schema(
+          properties: {
+            id: { type: 'integer', description: 'Task ID' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            task = Legion::Data::Model::Task[id.to_i]
+            return error_response("Task #{id} not found") unless task
+
+            text_response(task.values)
+          rescue StandardError => e
+            error_response("Failed to get task: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class GetTaskLogs < ::MCP::Tool
+        tool_name 'legion.get_task_logs'
+        description 'Get execution logs for a specific task.'
+
+        input_schema(
+          properties: {
+            id:    { type: 'integer', description: 'Task ID' },
+            limit: { type: 'integer', description: 'Max log entries (default 50)' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:, limit: 50)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            task = Legion::Data::Model::Task[id.to_i]
+            return error_response("Task #{id} not found") unless task
+
+            limit = limit.to_i.clamp(1, 100)
+            logs = Legion::Data::Model::TaskLog
+                   .where(task_id: id.to_i)
+                   .order(Sequel.desc(:id))
+                   .limit(limit)
+                   .all.map(&:values)
+
+            text_response(logs)
+          rescue StandardError => e
+            error_response("Failed to get task logs: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListChains < ::MCP::Tool
+        tool_name 'legion.list_chains'
+        description 'List all task chains.'
+
+        input_schema(
+          properties: {
+            limit: { type: 'integer', description: 'Max results (default 25, max 100)' }
+          }
+        )
+
+        class << self
+          def call(limit: 25)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('chain data model is not available') unless chain_model?
+
+            limit = limit.to_i.clamp(1, 100)
+            text_response(Legion::Data::Model::Chain.order(:id).limit(limit).all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list chains: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def chain_model? = Legion::Data::Model.const_defined?(:Chain)
+
+          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/list_extensions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListExtensions < ::MCP::Tool
+        tool_name 'legion.list_extensions'
+        description 'List all installed Legion extensions with status.'
+
+        input_schema(
+          properties: {
+            active: { type: 'boolean', description: 'Filter by active status' }
+          }
+        )
+
+        class << self
+          def call(active: nil)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            dataset = Legion::Data::Model::Extension.order(:id)
+            dataset = dataset.where(active: true) if active == true
+            text_response(dataset.all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list extensions: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListRelationships < ::MCP::Tool
+        tool_name 'legion.list_relationships'
+        description 'List all task relationships.'
+
+        input_schema(
+          properties: {
+            limit: { type: 'integer', description: 'Max results (default 25, max 100)' }
+          }
+        )
+
+        class << self
+          def call(limit: 25)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            limit = limit.to_i.clamp(1, 100)
+            text_response(Legion::Data::Model::Relationship.order(:id).limit(limit).all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list relationships: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          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
+    end
+  end
+end