legion-mcp 0.1.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class UpdateSchedule < ::MCP::Tool
+        tool_name 'legion.update_schedule'
+        description 'Update an existing schedule.'
+
+        input_schema(
+          properties: {
+            id:          { type: 'integer', description: 'Schedule ID' },
+            cron:        { type: 'string', description: 'New cron expression' },
+            interval:    { type: 'integer', description: 'New interval in seconds' },
+            active:      { type: 'boolean', description: 'Active status' },
+            function_id: { type: 'integer', description: 'New function ID' },
+            payload:     { type: 'object', description: 'New payload', additionalProperties: true }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:, **attrs)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('lex-scheduler is not loaded') unless scheduler_loaded?
+
+            record = Legion::Extensions::Scheduler::Data::Model::Schedule[id.to_i]
+            return error_response("Schedule #{id} not found") unless record
+
+            updates = {}
+            updates[:cron] = attrs[:cron] if attrs.key?(:cron)
+            updates[:interval] = attrs[:interval].to_i if attrs.key?(:interval)
+            updates[:active] = attrs[:active] if attrs.key?(:active)
+            updates[:function_id] = attrs[:function_id].to_i if attrs.key?(:function_id)
+            updates[:payload] = Legion::JSON.dump(attrs[:payload]) if attrs.key?(:payload)
+
+            record.update(updates) unless updates.empty?
+            record.refresh
+            text_response(record.values)
+          rescue StandardError => e
+            error_response("Failed to update schedule: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def scheduler_loaded? = defined?(Legion::Extensions::Scheduler)
+
+          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/worker_costs.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class WorkerCosts < ::MCP::Tool
+        tool_name 'legion.worker_costs'
+        description 'Retrieve cost data for a digital worker. Returns a stub response until lex-metering is available.'
+
+        input_schema(
+          properties: {
+            worker_id: { type: 'string', description: 'UUID of the digital worker' },
+            period:    { type: 'string', description: 'Reporting period: daily, weekly, monthly (default: weekly)' }
+          },
+          required:   ['worker_id']
+        )
+
+        class << self
+          def call(worker_id:, period: 'weekly')
+            return error_response('legion-data is not connected') unless data_connected?
+
+            worker = Legion::DigitalWorker.find(worker_id: worker_id)
+            return error_response("Worker not found: #{worker_id}") unless worker
+
+            text_response({
+                            worker_id:   worker_id,
+                            period:      period,
+                            available:   false,
+                            message:     'Cost metering is not yet available. Install lex-metering to enable worker cost tracking.',
+                            worker_name: worker.values[:name]
+                          })
+          rescue StandardError => e
+            error_response("Failed to fetch worker costs: #{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/worker_lifecycle.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class WorkerLifecycle < ::MCP::Tool
+        tool_name 'legion.worker_lifecycle'
+        description 'Transition a digital worker to a new lifecycle state (bootstrap, active, paused, retired, terminated).'
+
+        input_schema(
+          properties: {
+            worker_id: { type: 'string', description: 'UUID of the digital worker' },
+            to_state:  { type: 'string', description: 'Target lifecycle state' },
+            by:        { type: 'string', description: 'MSID or identifier of the person performing the transition' },
+            reason:    { type: 'string', description: 'Optional reason for the transition' }
+          },
+          required:   %w[worker_id to_state by]
+        )
+
+        class << self
+          def call(worker_id:, to_state:, by:, reason: nil)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            worker = Legion::DigitalWorker.find(worker_id: worker_id)
+            return error_response("Worker not found: #{worker_id}") unless worker
+
+            updated = Legion::DigitalWorker::Lifecycle.transition!(worker, to_state: to_state, by: by, reason: reason)
+            text_response(updated.values)
+          rescue Legion::DigitalWorker::Lifecycle::InvalidTransition => e
+            error_response("Invalid transition: #{e.message}")
+          rescue StandardError => e
+            error_response("Lifecycle transition failed: #{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/usage_filter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module UsageFilter
+      ESSENTIAL_TOOLS = %w[
+        legion.do legion.tools legion.run_task legion.get_status legion.describe_runner
+      ].freeze
+
+      FREQUENCY_WEIGHT = 0.5
+      RECENCY_WEIGHT   = 0.3
+      KEYWORD_WEIGHT   = 0.2
+      BASELINE_SCORE   = 0.1
+
+      module_function
+
+      def score_tools(tool_names, keywords: [])
+        all_stats = Observer.all_tool_stats
+        call_counts = tool_names.map { |n| all_stats.dig(n, :call_count) || 0 }
+        max_calls   = call_counts.max || 0
+
+        tool_names.each_with_object({}) do |name, hash|
+          stats = all_stats[name]
+
+          freq_score = if max_calls.positive? && stats
+                         (stats[:call_count].to_f / max_calls) * FREQUENCY_WEIGHT
+                       else
+                         0.0
+                       end
+
+          rec_score = if stats&.dig(:last_used)
+                        recency_decay(stats[:last_used]) * RECENCY_WEIGHT
+                      else
+                        0.0
+                      end
+
+          kw_score = keyword_match(name, keywords) * KEYWORD_WEIGHT
+
+          total = freq_score + rec_score + kw_score
+          total = BASELINE_SCORE if total.zero?
+
+          hash[name] = total.round(6)
+        end
+      end
+
+      def ranked_tools(tool_names, limit: nil, keywords: [])
+        scores = score_tools(tool_names, keywords: keywords)
+        ranked = tool_names.sort_by { |n| -scores.fetch(n, BASELINE_SCORE) }
+        limit ? ranked.first(limit) : ranked
+      end
+
+      def prune_dead_tools(tool_names, prune_after_seconds: 86_400 * 30)
+        stats = Observer.stats
+        window = stats[:since]
+        elapsed = window ? (Time.now - window) : 0
+
+        return tool_names if elapsed < prune_after_seconds
+
+        all_stats = Observer.all_tool_stats
+        tool_names.reject do |name|
+          next false if ESSENTIAL_TOOLS.include?(name)
+
+          calls = all_stats.dig(name, :call_count) || 0
+          calls.zero?
+        end
+      end
+
+      def recency_decay(last_used)
+        return 0.0 unless last_used
+
+        age_seconds = Time.now - last_used
+        return 1.0 if age_seconds <= 0
+
+        decay = 1.0 - (age_seconds / 86_400.0)
+        decay.clamp(0.0, 1.0)
+      end
+
+      def keyword_match(tool_name, keywords)
+        return 0.0 if keywords.nil? || keywords.empty?
+
+        hits = keywords.count { |kw| tool_name.include?(kw.to_s) }
+        hits.to_f / keywords.size
+      end
+    end
+  end
+end

data/lib/legion/mcp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    VERSION = '0.1.0'
+  end
+end

data/lib/legion/mcp.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'mcp'
+require 'legion/json'
+require_relative 'mcp/version'
+
+require_relative 'mcp/auth'
+require_relative 'mcp/tool_governance'
+require_relative 'mcp/server'
+
+module Legion
+  module MCP
+    class << self
+      def server
+        @server ||= Server.build
+      end
+
+      def server_for(token:)
+        auth_result = Auth.authenticate(token)
+        return { error: auth_result[:error] } unless auth_result[:authenticated]
+
+        Server.build(identity: auth_result[:identity])
+      end
+
+      def reset!
+        @server = nil
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: legion-mcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Model Context Protocol server with semantic tool matching, observation
+  pipeline, and tiered inference for LegionIO
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- legion-mcp.gemspec
+- lib/legion/mcp.rb
+- lib/legion/mcp/auth.rb
+- lib/legion/mcp/context_compiler.rb
+- lib/legion/mcp/context_guard.rb
+- lib/legion/mcp/embedding_index.rb
+- lib/legion/mcp/observer.rb
+- lib/legion/mcp/pattern_store.rb
+- lib/legion/mcp/resources/extension_info.rb
+- lib/legion/mcp/resources/runner_catalog.rb
+- lib/legion/mcp/server.rb
+- lib/legion/mcp/tier_router.rb
+- lib/legion/mcp/tool_governance.rb
+- lib/legion/mcp/tools/create_chain.rb
+- lib/legion/mcp/tools/create_relationship.rb
+- lib/legion/mcp/tools/create_schedule.rb
+- lib/legion/mcp/tools/delete_chain.rb
+- lib/legion/mcp/tools/delete_relationship.rb
+- lib/legion/mcp/tools/delete_schedule.rb
+- lib/legion/mcp/tools/delete_task.rb
+- lib/legion/mcp/tools/describe_runner.rb
+- lib/legion/mcp/tools/disable_extension.rb
+- lib/legion/mcp/tools/discover_tools.rb
+- lib/legion/mcp/tools/do_action.rb
+- lib/legion/mcp/tools/enable_extension.rb
+- lib/legion/mcp/tools/get_config.rb
+- lib/legion/mcp/tools/get_extension.rb
+- lib/legion/mcp/tools/get_status.rb
+- lib/legion/mcp/tools/get_task.rb
+- lib/legion/mcp/tools/get_task_logs.rb
+- lib/legion/mcp/tools/list_chains.rb
+- lib/legion/mcp/tools/list_extensions.rb
+- lib/legion/mcp/tools/list_relationships.rb
+- lib/legion/mcp/tools/list_schedules.rb
+- lib/legion/mcp/tools/list_tasks.rb
+- lib/legion/mcp/tools/list_workers.rb
+- lib/legion/mcp/tools/rbac_assignments.rb
+- lib/legion/mcp/tools/rbac_check.rb
+- lib/legion/mcp/tools/rbac_grants.rb
+- lib/legion/mcp/tools/routing_stats.rb
+- lib/legion/mcp/tools/run_task.rb
+- lib/legion/mcp/tools/show_worker.rb
+- lib/legion/mcp/tools/team_summary.rb
+- lib/legion/mcp/tools/update_chain.rb
+- lib/legion/mcp/tools/update_relationship.rb
+- lib/legion/mcp/tools/update_schedule.rb
+- lib/legion/mcp/tools/worker_costs.rb
+- lib/legion/mcp/tools/worker_lifecycle.rb
+- lib/legion/mcp/usage_filter.rb
+- lib/legion/mcp/version.rb
+homepage: https://github.com/LegionIO/legion-mcp
+licenses:
+- Apache-2.0
+metadata:
+  bug_tracker_uri: https://github.com/LegionIO/legion-mcp/issues
+  changelog_uri: https://github.com/LegionIO/legion-mcp/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/LegionIO/legion-mcp
+  homepage_uri: https://github.com/LegionIO/LegionIO
+  source_code_uri: https://github.com/LegionIO/legion-mcp
+  wiki_uri: https://github.com/LegionIO/legion-mcp/wiki
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: MCP server for the LegionIO framework
+test_files: []