legion-mcp 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bef62b03828f3bda4594cb1eb2fa020da240b3df72db55412a65f854a515f40
-  data.tar.gz: fb5272985978c3d78b03c20b4dafc724cd869f20e7cf25daabdbacae715a889a
+  metadata.gz: 37f03ddf4778cc238c0e69b039b9cd6c55acc2ada6207ef32c777c844d60d5e1
+  data.tar.gz: ffe2b6b6da0930d795ca3965b86f5edabdf8f6b698232b110bd3ae6187ce0c20
 SHA512:
-  metadata.gz: 46793c8c4aa53e27f5831cbfec97984209fda9233325001b2fd2f87bf34502e1ee5a7196243ac90fb79cd5dd2351f2fc3078f952680ee25c735534150bc5b984
-  data.tar.gz: 4cd1ff55314687a3d5aa7028b53393d3997c53e455bd170cf96b1a93a1486dd1b56dab51c4fba9481d194639068e44622ba991caa5b8497099f411b8b051870b
+  metadata.gz: a4c148c867a384494dd92847f6ec4f25b6010d73ce3f076e6d01c0f5ae47c8a7c6d8cfa909da58f067334612f7b7420e87e388c0910fad2edf604ea45a670206
+  data.tar.gz: eb8d5f6536df790298e4613a92f61f8a4e136d16d83ede2a99c92a9507ddfd8f7301fe52a12678f891b0227e1568660b77db008b09bd9e1a98f55644e64a56b2

data/CHANGELOG.md

@@ -1,6 +1,51 @@
 # legion-mcp Changelog
 
-## v0.1.0
+## [0.4.1] - 2026-03-19
+
+### Added
+- `legion.prompt_list` — list all stored prompt templates via lex-prompt Client
+- `legion.prompt_show` — fetch a prompt by name, version, or tag via lex-prompt Client
+- `legion.prompt_run` — render a prompt template with ERB variable substitution via lex-prompt Client
+- `legion.dataset_list` — list all stored datasets via lex-dataset Client
+- `legion.dataset_show` — fetch a dataset with all rows, optionally version-pinned, via lex-dataset Client
+- `legion.experiment_results` — retrieve per-row results and summary for a named experiment from lex-dataset
+- `legion.eval_list` — list available evaluator templates via lex-eval Client
+- `legion.eval_run` — run a single input/output pair through a named evaluator via lex-eval Client
+- `legion.eval_results` — retrieve stored experiment results via lex-dataset experiment store
+- All 9 tools registered in `TOOL_CLASSES`; total tool count raised from 36 to 45
+- Specs for all 9 new tools
+
+## [0.4.0] - 2026-03-20
+
+### Added
+- PatternSchema v1: portable pattern format with trust-level confidence capping on import/export
+- PatternExchange: bulk import/export of patterns via JSON files with deduplication
+- PatternGossip: AMQP-based pattern sharing between instances (org trust level)
+- ColdStart: community pattern loading on first boot when PatternStore is empty
+
+## [0.3.0] - 2026-03-20
+
+### Added
+- GapDetector: analyzes observations for repeated manual patterns and frequent unpatched intents
+- PatternCompiler: generates compressed tool definitions and compiled workflows from promoted patterns
+- CapabilityGenerator: autonomous function generation from detected gaps with LLM code generation
+- Validation pipeline with Ruby syntax check and optional lex-eval integration
+
+## [0.2.0] - 2026-03-20
+
+### Fixed
+- Observer feedback bug: records actual matched tool name instead of 'legion.do'
+- wire_observer skips legion.do calls (feedback handled inside DoAction with correct tool name)
+
+### Added
+- Boot-time L2 → L0 pattern hydration (`PatternStore.hydrate_from_l2`)
+- Pattern confidence decay with archive threshold (`PatternStore.decay_all`)
+- Tier 1 execution: pattern-hinted local/fleet LLM routing in DoAction
+- Tier 2 execution: cloud LLM with compressed catalog context in DoAction
+- `legion.plan` meta-tool for multi-step workflow planning (36 tools total)
+- Response template learning from observed Tier 0 outputs (`PatternStore.learn_response_template`)
+
+## [0.1.0]
 
 ### Added
 - Initial extraction from LegionIO

data/lib/legion/mcp/capability_generator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module CapabilityGenerator
+      module_function
+
+      def generate_from_gap(gap)
+        name = infer_name(gap)
+        description = infer_description(gap)
+
+        proposal = {
+          name:         name,
+          description:  description,
+          source_gap:   gap,
+          runner_code:  nil,
+          spec_code:    nil,
+          confidence:   :sandbox,
+          generated_at: Time.now
+        }
+
+        if llm_available?
+          proposal[:runner_code] = generate_runner(name, description, gap)
+          proposal[:spec_code] = generate_spec(name, description)
+        end
+
+        proposal
+      rescue StandardError => e
+        { error: e.message, source_gap: gap }
+      end
+
+      def validate(runner_code:, spec_code:) # rubocop:disable Lint/UnusedMethodArgument
+        result = { syntax_valid: false, eval_score: nil }
+
+        result[:syntax_valid] = syntax_valid?(runner_code) if runner_code
+
+        if runner_code && defined?(Legion::Extensions::Eval::Client)
+          begin
+            client = Legion::Extensions::Eval::Client.new
+            eval_result = client.evaluate(code: runner_code, criteria: 'code_quality')
+            result[:eval_score] = eval_result[:score] if eval_result[:success]
+          rescue StandardError
+            nil
+          end
+        end
+
+        result
+      end
+
+      def infer_name(gap)
+        case gap[:type]
+        when :frequent_intent
+          gap[:sample_intents].first.to_s.gsub(/\s+/, '_').downcase.slice(0, 30)
+        when :repeated_chain
+          gap[:chain].join('_then_').slice(0, 30)
+        else
+          "generated_#{Time.now.to_i}"
+        end
+      end
+
+      def infer_description(gap)
+        case gap[:type]
+        when :frequent_intent
+          "Auto-generated from #{gap[:count]} observed intents: #{gap[:sample_intents].first(3).join(', ')}"
+        when :repeated_chain
+          "Auto-generated from #{gap[:count]} observed sequences: #{gap[:chain].join(' -> ')}"
+        else
+          'Auto-generated capability'
+        end
+      end
+
+      def generate_runner(name, description, _gap)
+        return nil unless llm_available?
+
+        prompt = "Generate a Ruby module for a LegionIO runner named '#{name}'. " \
+                 "Description: #{description}. " \
+                 'Follow the pattern: module with module_function methods returning hashes. ' \
+                 'Include proper error handling. Return ONLY the Ruby code.'
+
+        Legion::LLM.ask(prompt)
+      rescue StandardError
+        nil
+      end
+
+      def generate_spec(name, description)
+        return nil unless llm_available?
+
+        prompt = "Generate RSpec tests for a Ruby module named '#{name}'. " \
+                 "Description: #{description}. " \
+                 'Use described_class pattern. Return ONLY the Ruby code.'
+
+        Legion::LLM.ask(prompt)
+      rescue StandardError
+        nil
+      end
+
+      def syntax_valid?(code)
+        RubyVM::InstructionSequence.compile(code)
+        true
+      rescue SyntaxError
+        false
+      end
+
+      def llm_available?
+        defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+      end
+    end
+  end
+end

data/lib/legion/mcp/cold_start.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'pattern_store'
+require_relative 'pattern_exchange'
+
+module Legion
+  module MCP
+    module ColdStart
+      module_function
+
+      def load_community_patterns(path: nil)
+        return { skipped: true, reason: 'store not empty' } unless PatternStore.empty?
+
+        path ||= configured_path
+        return { skipped: true, reason: 'no path configured' } unless path
+
+        PatternExchange.import_from_file(path, trust_level: :community)
+      rescue StandardError => e
+        { error: e.message, imported: 0 }
+      end
+
+      def configured_path
+        return nil unless defined?(Legion::Settings)
+
+        Legion::Settings.dig(:mcp, :cold_start, :patterns_path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/legion/mcp/gap_detector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module MCP
+    module GapDetector
+      FREQUENCY_THRESHOLD = 5
+      CHAIN_THRESHOLD = 3
+
+      module_function
+
+      def analyze
+        gaps = []
+        gaps.concat(detect_frequent_intents)
+        gaps.concat(detect_repeated_chains)
+        gaps
+      end
+
+      def detect_frequent_intents
+        intents = Observer.recent_intents(Observer::INTENT_BUFFER_MAX)
+        grouped = intents.group_by { |i| i[:matched_tool] }
+
+        grouped.filter_map do |tool, occurrences|
+          next if occurrences.size < FREQUENCY_THRESHOLD
+          next if PatternStore.pattern_exists?(Digest::SHA256.hexdigest(tool.to_s))
+
+          { type: :frequent_intent, tool: tool, count: occurrences.size,
+            sample_intents: occurrences.last(3).map { |o| o[:intent] } }
+        end
+      end
+
+      def detect_repeated_chains
+        recent = Observer.recent(Observer::RING_BUFFER_MAX)
+        chains = {}
+        recent.each_cons(2) do |a, b|
+          key = "#{a[:tool_name]}->#{b[:tool_name]}"
+          chains[key] = (chains[key] || 0) + 1
+        end
+
+        chains.filter_map do |chain, count|
+          next if count < CHAIN_THRESHOLD
+
+          { type: :repeated_chain, chain: chain.split('->'), count: count }
+        end
+      end
+
+      def reset!
+        # No persistent state to clear — analysis reads from Observer
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_compiler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module PatternCompiler
+      module_function
+
+      def compile_tool_definitions
+        return [] unless defined?(Legion::MCP::Server::TOOL_CLASSES)
+
+        Legion::MCP::Server::TOOL_CLASSES.map do |klass|
+          name = klass.respond_to?(:tool_name) ? klass.tool_name : klass.name
+          desc = klass.respond_to?(:description) ? klass.description : ''
+          params = extract_params(klass)
+
+          compressed = "#{name}(#{params.join(', ')}) -- #{desc.split('.').first}"
+          { name: name, compressed: compressed.slice(0, 200), full_description: desc }
+        end
+      end
+
+      def compile_workflows
+        PatternStore.patterns.filter_map do |_hash, pattern|
+          next if (pattern[:confidence] || 0) < 0.6
+
+          {
+            intent:     pattern[:intent_text],
+            tools:      pattern[:tool_chain],
+            confidence: pattern[:confidence],
+            template:   pattern[:response_template]
+          }
+        end
+      end
+
+      def extract_params(klass)
+        return [] unless klass.respond_to?(:input_schema)
+
+        schema = klass.input_schema
+        props = if schema.is_a?(Hash)
+                  schema[:properties] || schema['properties']
+                elsif schema.respond_to?(:to_h)
+                  schema.to_h[:properties]
+                end
+        return [] unless props
+
+        props.keys.map(&:to_s)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_exchange.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'pattern_schema'
+require_relative 'pattern_store'
+
+module Legion
+  module MCP
+    module PatternExchange
+      module_function
+
+      def export_all(min_confidence: 0.5)
+        PatternStore.patterns.filter_map do |_hash, pattern|
+          next if (pattern[:confidence] || 0) < min_confidence
+
+          PatternSchema.export(pattern)
+        end
+      end
+
+      def import_all(patterns, trust_level: :community)
+        imported = 0
+        skipped = 0
+
+        Array(patterns).each do |external|
+          next unless PatternSchema.validate_schema(external)
+
+          internal = PatternSchema.import(external, trust_level: trust_level)
+          if PatternStore.pattern_exists?(internal[:intent_hash])
+            skipped += 1
+            next
+          end
+
+          PatternStore.store(internal)
+          imported += 1
+        end
+
+        { imported: imported, skipped: skipped }
+      end
+
+      def export_to_file(path, min_confidence: 0.5)
+        data = export_all(min_confidence: min_confidence)
+        File.write(path, ::JSON.pretty_generate(data))
+        { exported: data.size, path: path }
+      end
+
+      def import_from_file(path, trust_level: :community)
+        raw = File.read(path)
+        patterns = ::JSON.parse(raw, symbolize_names: true)
+        patterns = [patterns] if patterns.is_a?(Hash)
+        import_all(patterns, trust_level: trust_level)
+      rescue StandardError => e
+        { error: e.message, imported: 0 }
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_gossip.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'pattern_schema'
+
+module Legion
+  module MCP
+    module PatternGossip
+      EXCHANGE_NAME = 'tbi.patterns'
+      ANNOUNCE_TTL = 86_400
+
+      module_function
+
+      def announce(pattern)
+        return nil unless transport_available?
+
+        exported = PatternSchema.export(pattern)
+        message = {
+          action:     'announce',
+          pattern_id: exported[:pattern_id],
+          pattern:    exported,
+          origin:     { instance_id: instance_id },
+          ttl:        ANNOUNCE_TTL,
+          version:    1
+        }
+
+        Legion::Transport::Messages::Dynamic.new(
+          function: "#{EXCHANGE_NAME}.announce",
+          data:     message
+        ).publish
+
+        { published: true, pattern_id: exported[:pattern_id] }
+      rescue StandardError
+        nil
+      end
+
+      def receive(message)
+        return nil unless message.is_a?(Hash) && message[:pattern]
+
+        PatternSchema.import(message[:pattern], trust_level: :org)
+      rescue StandardError
+        nil
+      end
+
+      def transport_available?
+        defined?(Legion::Transport) &&
+          Legion::Transport.respond_to?(:connected?) &&
+          Legion::Transport.connected?
+      end
+
+      def instance_id
+        @instance_id ||= SecureRandom.uuid
+      end
+
+      def reset!
+        @instance_id = nil
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_schema.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module MCP
+    module PatternSchema
+      SCHEMA_VERSION = '1.0'
+      REQUIRED_FIELDS = %i[schema_version pattern_id intent capability_chain confidence metadata].freeze
+
+      TRUST_LEVELS = {
+        local:     0.5,
+        org:       0.4,
+        community: 0.3
+      }.freeze
+
+      module_function
+
+      def export(pattern)
+        {
+          schema_version:    SCHEMA_VERSION,
+          pattern_id:        pattern[:intent_hash],
+          intent:            {
+            description: pattern[:intent_text],
+            keywords:    extract_keywords(pattern[:intent_text])
+          },
+          capability_chain:  Array(pattern[:tool_chain]).map { |t| { tool: t, params_template: {} } },
+          response_template: pattern[:response_template] ? { engine: 'mustache', template: pattern[:response_template] } : nil,
+          confidence:        {
+            suggested_initial: [pattern[:confidence], 0.5].min,
+            source_hits:       pattern[:hit_count] || 0,
+            source_misses:     pattern[:miss_count] || 0
+          },
+          metadata:          {
+            source:      'local',
+            sensitivity: 'public',
+            created_at:  pattern[:created_at]&.iso8601
+          }
+        }
+      end
+
+      def import(external, trust_level: :community)
+        confidence = external.dig(:confidence, :suggested_initial) || TRUST_LEVELS.fetch(trust_level, 0.3)
+        confidence = [confidence, TRUST_LEVELS.fetch(trust_level, 0.3)].min
+
+        intent_text = external.dig(:intent, :description) || ''
+        intent_hash = external[:pattern_id] || Digest::SHA256.hexdigest(intent_text.downcase.strip)
+        tool_chain = Array(external[:capability_chain]).map { |c| c[:tool] || c.to_s }
+
+        template = external.dig(:response_template, :template)
+
+        {
+          intent_hash:          intent_hash,
+          intent_text:          intent_text,
+          intent_vector:        nil,
+          tool_chain:           tool_chain,
+          response_template:    template,
+          confidence:           confidence,
+          hit_count:            0,
+          miss_count:           0,
+          last_hit_at:          nil,
+          created_at:           Time.now,
+          context_requirements: nil
+        }
+      end
+
+      def validate_schema(data)
+        return false unless data.is_a?(Hash)
+
+        REQUIRED_FIELDS.all? { |f| data.key?(f) }
+      end
+
+      def extract_keywords(text)
+        return [] unless text
+
+        text.downcase.split(/\s+/).uniq.reject { |w| w.length < 3 }
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_store.rb

@@ -4,10 +4,11 @@ require 'json'
 
 module Legion
   module MCP
-    module PatternStore
+    module PatternStore # rubocop:disable Metrics/ModuleLength
       CONFIDENCE_SUCCESS_DELTA = 0.02
       CONFIDENCE_FAILURE_DELTA = -0.05
       SEEDED_CONFIDENCE        = 0.5
+      DECAY_ARCHIVE_THRESHOLD  = 0.1
 
       module_function
 
@@ -129,6 +130,10 @@ module Legion
         mutex.synchronize { patterns_l0.size }
       end
 
+      def empty?
+        size.zero?
+      end
+
       def stats
         total_hits = 0
         total_conf = 0.0
@@ -149,9 +154,59 @@ module Legion
         }
       end
 
+      def learn_response_template(intent_hash, result_data, threshold: 3)
+        return unless result_data.is_a?(Hash)
+
+        template_mutex.synchronize do
+          buffer = template_observations[intent_hash] ||= []
+          buffer << result_data.keys.sort
+          buffer.shift if buffer.size > 10
+
+          return unless buffer.size >= threshold
+
+          if buffer.last(threshold).uniq.size == 1
+            keys = buffer.last.sort
+            template = keys.map { |k| "#{k}: {{#{k}}}" }.join(', ')
+            mutex.synchronize do
+              pattern = patterns_l0[intent_hash]
+              pattern[:response_template] = template if pattern
+            end
+            sync_to_persistence(intent_hash)
+          end
+        end
+      end
+
+      def decay_all(factor: 0.998)
+        archived = []
+        mutex.synchronize do
+          patterns_l0.each do |hash, pattern|
+            pattern[:confidence] = (pattern[:confidence] * factor).clamp(0.0, 1.0)
+            archived << hash if pattern[:confidence] < DECAY_ARCHIVE_THRESHOLD
+          end
+          archived.each { |hash| patterns_l0.delete(hash) }
+        end
+
+        archived.each { |hash| archive_l2(hash) }
+        sync_all_to_persistence unless archived.empty?
+      end
+
+      def hydrate_from_l2
+        return unless local_db_available?
+
+        table = ensure_local_table
+        table.each do |row|
+          pattern = deserialize_pattern(row)
+          mutex.synchronize { patterns_l0[pattern[:intent_hash]] = pattern }
+          persist_l1(pattern[:intent_hash], pattern)
+        end
+      rescue StandardError
+        nil
+      end
+
       def reset!
         mutex.synchronize { patterns_l0.clear }
         candidates_mutex.synchronize { candidates_buffer.clear }
+        template_mutex.synchronize { template_observations.clear }
       end
 
       # --- Private helpers ---
@@ -224,6 +279,19 @@ module Legion
         persist_l2(intent_hash, pattern)
       end
 
+      def archive_l2(intent_hash)
+        return unless local_db_available?
+
+        table = ensure_local_table
+        table.where(intent_hash: intent_hash).delete
+      rescue StandardError
+        nil
+      end
+
+      def sync_all_to_persistence
+        mutex.synchronize { patterns_l0.keys.dup }.each { |h| sync_to_persistence(h) }
+      end
+
       def local_db_available?
         defined?(Legion::Data::Local) &&
           Legion::Data::Local.respond_to?(:connected?) &&
@@ -298,6 +366,14 @@ module Legion
       def candidates_mutex
         @candidates_mutex ||= Mutex.new
       end
+
+      def template_observations
+        @template_observations ||= {}
+      end
+
+      def template_mutex
+        @template_mutex ||= Mutex.new
+      end
     end
   end
 end

data/lib/legion/mcp/server.rb

@@ -35,9 +35,20 @@ require_relative 'tools/routing_stats'
 require_relative 'tools/rbac_check'
 require_relative 'tools/rbac_assignments'
 require_relative 'tools/rbac_grants'
+require_relative 'tools/prompt_list'
+require_relative 'tools/prompt_show'
+require_relative 'tools/prompt_run'
+require_relative 'tools/dataset_list'
+require_relative 'tools/dataset_show'
+require_relative 'tools/experiment_results'
+require_relative 'tools/eval_list'
+require_relative 'tools/eval_run'
+require_relative 'tools/eval_results'
 require_relative 'context_compiler'
 require_relative 'embedding_index'
+require_relative 'cold_start'
 require_relative 'tools/do_action'
+require_relative 'tools/plan_action'
 require_relative 'tools/discover_tools'
 require_relative 'resources/runner_catalog'
 require_relative 'resources/extension_info'
@@ -79,7 +90,17 @@ module Legion
         Tools::RbacCheck,
         Tools::RbacAssignments,
         Tools::RbacGrants,
+        Tools::PromptList,
+        Tools::PromptShow,
+        Tools::PromptRun,
+        Tools::DatasetList,
+        Tools::DatasetShow,
+        Tools::ExperimentResults,
+        Tools::EvalList,
+        Tools::EvalRun,
+        Tools::EvalResults,
         Tools::DoAction,
+        Tools::PlanAction,
         Tools::DiscoverTools
       ].freeze
 
@@ -110,6 +131,12 @@ module Legion
             build_filtered_tool_list.map(&:to_h)
           end
 
+          # Hydrate pattern store from L2 persistence (SQLite) on boot
+          PatternStore.hydrate_from_l2 if defined?(PatternStore)
+
+          # Cold-start: load community patterns if store is still empty after hydration
+          ColdStart.load_community_patterns if defined?(ColdStart)
+
           # Populate embedding index for semantic tool matching (lazy — no-op if LLM unavailable)
           populate_embedding_index
 
@@ -141,8 +168,11 @@ module Legion
             error:       data[:error]
           )
 
-          # Wire pattern promotion feedback loop for do_action calls
-          return unless data[:tool_name] == 'legion.do' && data[:tool_arguments]&.dig(:intent)
+          # Pattern promotion for legion.do is handled inside DoAction itself
+          # (which knows the actual resolved tool name). For other tools called
+          # directly, we record the intent+result here if an intent is present.
+          return if data[:tool_name] == 'legion.do'
+          return unless data[:tool_arguments]&.dig(:intent)
 
           Observer.record_intent_with_result(
             intent:    data[:tool_arguments][:intent],