legion-mcp 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 918ab35b2f575f24b157f7f4aaf418e13a1f950b58bf387f17f921bd121f8b85
-  data.tar.gz: d1de3e68b031d1c7a169db411d188e54ebd0107a191aec584981a95c852746f2
+  metadata.gz: 2c56ad22d31474ed9a1a64e6b97a4aea17a61a496162916a0d1f3c727c82abd2
+  data.tar.gz: 1d1ebbc6f7dcbcbf26a0a42fa7d92694b6b2f24dd7518089fe8132919d00a6f9
 SHA512:
-  metadata.gz: 42f453718ebe7af183b93b86724f40ec31927fed7f562f17c7abe9732d7732df02f35108d498640a7f330425f5a24d4b3602e4f28cef9166af0d5751a3f49c1e
-  data.tar.gz: ccfce5e16a125063d3e4b74dff0b03fd4a6f0eab6e80b5480539c5de6adc9e61b8466acff2762a2501456a6ada0cb7743f7d0fe6c930ef50786438e5cba93a60
+  metadata.gz: 8fa820c5e258c9fd3690d991b00aab73568c2e72189f5adf7511a264a10f9287f3ca87b96d2091bdb7a5fec8876fe5a54986f7d1067cf9e72c95b20f884039c7
+  data.tar.gz: 1f4111a18475467b942d3faa2628c23ac77ea0c4b7165b78dcc7c222908d7af97ae31eb3f58e610c598413238713d1c5f96fa6fee8201c7fc0144ba36165c336

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # legion-mcp Changelog
 
+## [0.5.4] - 2026-03-24
+
+### Added
+- TBI Phase 5: `GapDetector` — detects unmatched intents, high-failure tools, and stale candidates from Observer/PatternStore data
+- TBI Phase 5: `FunctionGenerator` — LLM-powered tool spec generation from detected gaps, with validation and pattern registration
+- TBI Phase 5: `SelfGenerate` — orchestrates gap detection + function generation cycles with cooldown, history tracking, and status reporting
+- 89 new specs across gap_detector, function_generator, and self_generate
+
+### Changed
+- Rewrote `GapDetector` from frequency-based to gap-type-based detection (unmatched, failure, stale) with priority scoring
+
 ## [0.5.3] - 2026-03-23
 
 ### Changed

data/lib/legion/mcp/function_generator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module MCP
+    module FunctionGenerator
+      MAX_GENERATION_ATTEMPTS = 3
+      GENERATION_TIMEOUT      = 60
+
+      module_function
+
+      def generate_from_gap(gap)
+        case gap[:type]
+        when :unmatched_intent
+          generate_tool_for_intent(intent: gap[:intent])
+        when :high_failure_tool
+          generate_fix_for_tool(tool_name: gap[:tool_name], last_error: gap[:last_error])
+        when :stale_candidate
+          generate_tool_for_candidate(intent_text: gap[:intent_text], tool_chain: gap[:tool_chain])
+        else
+          { success: false, reason: :unknown_gap_type }
+        end
+      rescue StandardError => e
+        { success: false, reason: :generation_failed, error: e.message }
+      end
+
+      def generate_tool_for_intent(intent:)
+        return { success: false, reason: :llm_not_available } unless llm_available?
+
+        spec = generate_tool_spec(intent: intent)
+        return spec unless spec[:success]
+
+        validate_spec(spec[:tool_spec])
+      end
+
+      def generate_fix_for_tool(tool_name:, last_error:)
+        return { success: false, reason: :llm_not_available } unless llm_available?
+
+        prompt = build_fix_prompt(tool_name: tool_name, error: last_error)
+        result = llm_ask(prompt)
+        return { success: false, reason: :llm_failed } unless result
+
+        {
+          success:         true,
+          type:            :fix_suggestion,
+          tool_name:       tool_name,
+          suggestion:      result,
+          requires_review: true
+        }
+      end
+
+      def generate_tool_for_candidate(intent_text:, tool_chain:)
+        return { success: false, reason: :llm_not_available } unless llm_available?
+
+        spec = generate_tool_spec(intent: intent_text, existing_chain: tool_chain)
+        return spec unless spec[:success]
+
+        register_generated_pattern(spec[:tool_spec], intent_text)
+
+        spec
+      end
+
+      def generate_tool_spec(intent:, existing_chain: nil)
+        prompt = build_generation_prompt(intent: intent, existing_chain: existing_chain)
+        result = llm_ask(prompt)
+        return { success: false, reason: :llm_failed } unless result
+
+        parsed = parse_tool_spec(result)
+        return { success: false, reason: :parse_failed, raw: result } unless parsed
+
+        { success: true, tool_spec: parsed }
+      end
+
+      def validate_spec(spec)
+        errors = []
+        errors << 'missing name'            unless spec[:name]&.length&.positive?
+        errors << 'missing description'     unless spec[:description]&.length&.positive?
+        errors << 'missing runner_function' unless spec[:runner_function]&.length&.positive?
+
+        if errors.empty?
+          { success: true, tool_spec: spec, valid: true }
+        else
+          { success: false, reason: :invalid_spec, errors: errors, tool_spec: spec }
+        end
+      end
+
+      def llm_available?
+        !!(defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat))
+      end
+
+      def llm_ask(prompt)
+        return nil unless llm_available?
+
+        response = Legion::LLM.chat(
+          message: prompt,
+          caller:  { source: 'legion-mcp', component: 'function_generator' }
+        )
+        response&.content
+      rescue StandardError => e
+        Legion::Logging.warn("FunctionGenerator LLM call failed: #{e.message}") if defined?(Legion::Logging)
+        nil
+      end
+
+      def build_generation_prompt(intent:, existing_chain: nil)
+        chain_context = existing_chain ? "\nExisting tool chain that partially handles this: #{existing_chain.inspect}" : ''
+
+        <<~PROMPT
+          Generate a tool specification for a LegionIO MCP tool that handles this user intent:
+          "#{intent}"
+          #{chain_context}
+          Respond with ONLY a JSON object (no markdown, no explanation):
+          {
+            "name": "legion.tool_name",
+            "description": "What this tool does",
+            "runner_function": "extension_name/runner_name/method_name",
+            "parameters": [{"name": "param1", "type": "string", "required": true, "description": "..."}],
+            "category": "one of: query, action, analysis, utility"
+          }
+        PROMPT
+      end
+
+      def build_fix_prompt(tool_name:, error:)
+        <<~PROMPT
+          The MCP tool "#{tool_name}" has a high failure rate. Last error: #{error}
+          Suggest a fix or replacement approach. Respond concisely (2-3 sentences max).
+        PROMPT
+      end
+
+      def parse_tool_spec(raw)
+        json_match = raw.match(/\{[\s\S]*\}/)
+        return nil unless json_match
+
+        parsed = ::JSON.parse(json_match[0], symbolize_names: true)
+        return nil unless parsed.is_a?(Hash) && parsed[:name]
+
+        parsed
+      rescue ::JSON::ParserError
+        nil
+      end
+
+      def register_generated_pattern(spec, intent_text)
+        return unless defined?(PatternStore)
+
+        normalized   = intent_text.to_s.strip.downcase.gsub(/\s+/, ' ')
+        intent_hash  = Digest::SHA256.hexdigest(normalized)
+
+        PatternStore.promote_candidate(
+          intent_hash: intent_hash,
+          tool_chain:  [spec[:runner_function] || spec[:name]],
+          intent_text: intent_text
+        )
+      rescue StandardError => e
+        Legion::Logging.warn("register_generated_pattern failed: #{e.message}") if defined?(Legion::Logging)
+      end
+    end
+  end
+end

data/lib/legion/mcp/gap_detector.rb

@@ -5,48 +5,101 @@ require 'digest'
 module Legion
   module MCP
     module GapDetector
-      FREQUENCY_THRESHOLD = 5
-      CHAIN_THRESHOLD = 3
+      GAP_INTENT_THRESHOLD = 5
+      FAILURE_RATE_THRESHOLD = 0.4
+      STALE_CANDIDATE_HOURS = 24
+      MAX_GAPS              = 20
 
       module_function
 
-      def analyze
+      def detect_gaps
         gaps = []
-        gaps.concat(detect_frequent_intents)
-        gaps.concat(detect_repeated_chains)
-        gaps
+        gaps.concat(detect_unmatched_intents)
+        gaps.concat(detect_high_failure_tools)
+        gaps.concat(detect_stale_candidates)
+
+        gaps.uniq { |g| g[:id] }.first(MAX_GAPS)
       end
 
-      def detect_frequent_intents
-        intents = Observer.recent_intents(Observer::INTENT_BUFFER_MAX)
-        grouped = intents.group_by { |i| i[:matched_tool] }
+      def detect_unmatched_intents
+        return [] unless defined?(Observer)
+
+        recent = Observer.recent_intents(200)
+        unmatched = recent.select { |r| r[:matched_tool].nil? || r[:matched_tool] == 'none' }
+
+        grouped = unmatched.group_by { |r| normalize_intent(r[:intent]) }
 
-        grouped.filter_map do |tool, occurrences|
-          next if occurrences.size < FREQUENCY_THRESHOLD
-          next if PatternStore.pattern_exists?(Digest::SHA256.hexdigest(tool.to_s))
+        grouped.filter_map do |intent_text, occurrences|
+          next if occurrences.size < GAP_INTENT_THRESHOLD
 
-          { type: :frequent_intent, tool: tool, count: occurrences.size,
-            sample_intents: occurrences.last(3).map { |o| o[:intent] } }
+          {
+            id:          "unmatched:#{Digest::SHA256.hexdigest(intent_text)[0, 12]}",
+            type:        :unmatched_intent,
+            intent:      intent_text,
+            occurrences: occurrences.size,
+            first_seen:  occurrences.first[:recorded_at],
+            last_seen:   occurrences.last[:recorded_at],
+            priority:    calculate_priority(occurrences.size, :unmatched)
+          }
         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
+      def detect_high_failure_tools
+        return [] unless defined?(Observer)
+
+        stats = Observer.all_tool_stats
+        stats.filter_map do |tool_name, tool_stat|
+          next unless tool_stat
+          next if tool_stat[:call_count] < 5
+
+          failure_rate = tool_stat[:failure_count].to_f / tool_stat[:call_count]
+          next if failure_rate < FAILURE_RATE_THRESHOLD
+
+          {
+            id:            "failing:#{tool_name}",
+            type:          :high_failure_tool,
+            tool_name:     tool_name,
+            failure_rate:  failure_rate.round(4),
+            call_count:    tool_stat[:call_count],
+            failure_count: tool_stat[:failure_count],
+            last_error:    tool_stat[:last_error],
+            priority:      calculate_priority(tool_stat[:failure_count], :failure)
+          }
         end
+      end
+
+      def detect_stale_candidates
+        return [] unless defined?(PatternStore)
+
+        candidates = PatternStore.candidates
 
-        chains.filter_map do |chain, count|
-          next if count < CHAIN_THRESHOLD
+        candidates.filter_map do |intent_hash, entry|
+          next if entry[:count] < 2
 
-          { type: :repeated_chain, chain: chain.split('->'), count: count }
+          {
+            id:                "stale:#{intent_hash[0, 12]}",
+            type:              :stale_candidate,
+            intent_hash:       intent_hash,
+            intent_text:       entry[:intent_text],
+            observation_count: entry[:count],
+            tool_chain:        entry[:tool_chain],
+            priority:          calculate_priority(entry[:count], :stale)
+          }
         end
       end
 
-      def reset!
-        # No persistent state to clear — analysis reads from Observer
+      def normalize_intent(text)
+        text.to_s.strip.downcase.gsub(/\s+/, ' ')
+      end
+
+      def calculate_priority(count, type)
+        base = case type
+               when :unmatched then 0.8
+               when :failure   then 0.6
+               when :stale     then 0.4
+               else 0.3
+               end
+        (base + [count * 0.02, 0.2].min).clamp(0.0, 1.0).round(4)
       end
     end
   end

data/lib/legion/mcp/self_generate.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module MCP
+    module SelfGenerate
+      MAX_GAPS_PER_CYCLE = 5
+      COOLDOWN_SECONDS   = 300
+
+      module_function
+
+      def run_cycle
+        return { success: false, reason: :cooldown } if in_cooldown?
+
+        gaps = GapDetector.detect_gaps
+        return { success: true, gaps_found: 0, generated: 0 } if gaps.empty?
+
+        top_gaps = gaps.sort_by { |g| -g[:priority] }.first(MAX_GAPS_PER_CYCLE)
+
+        results = top_gaps.map do |gap|
+          result = FunctionGenerator.generate_from_gap(gap)
+          { gap: gap[:id], type: gap[:type], result: result }
+        end
+
+        record_cycle(results)
+
+        generated = results.count { |r| r[:result][:success] }
+        failed    = results.count { |r| !r[:result][:success] }
+
+        {
+          success:    true,
+          gaps_found: gaps.size,
+          processed:  top_gaps.size,
+          generated:  generated,
+          failed:     failed,
+          results:    results
+        }
+      end
+
+      def status
+        {
+          last_cycle_at:      last_cycle_at,
+          total_cycles:       cycle_count,
+          total_generated:    total_generated,
+          cooldown_remaining: cooldown_remaining,
+          pending_gaps:       GapDetector.detect_gaps.size
+        }
+      rescue StandardError => e
+        { error: e.message }
+      end
+
+      def reset!
+        mutex.synchronize do
+          @last_cycle_at   = nil
+          @cycle_count     = 0
+          @total_generated = 0
+          @cycle_history   = []
+        end
+      end
+
+      def cycle_history(limit = 10)
+        mutex.synchronize { (@cycle_history || []).last(limit) }
+      end
+
+      def in_cooldown?
+        return false unless last_cycle_at
+
+        Time.now - last_cycle_at < COOLDOWN_SECONDS
+      end
+
+      def cooldown_remaining
+        return 0 unless last_cycle_at
+
+        remaining = COOLDOWN_SECONDS - (Time.now - last_cycle_at)
+        [remaining, 0].max.round(1)
+      end
+
+      def record_cycle(results)
+        mutex.synchronize do
+          @last_cycle_at   = Time.now
+          @cycle_count     = (@cycle_count || 0) + 1
+          @total_generated = (@total_generated || 0) + results.count { |r| r[:result][:success] }
+          @cycle_history ||= []
+          @cycle_history << {
+            at:            Time.now,
+            results_count: results.size,
+            generated:     results.count { |r| r[:result][:success] }
+          }
+          @cycle_history.shift if @cycle_history.size > 50
+        end
+      end
+
+      def last_cycle_at
+        mutex.synchronize { @last_cycle_at }
+      end
+
+      def cycle_count
+        mutex.synchronize { @cycle_count || 0 }
+      end
+
+      def total_generated
+        mutex.synchronize { @total_generated || 0 }
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+    end
+  end
+end

data/lib/legion/mcp/server.rb

@@ -47,6 +47,9 @@ require_relative 'tools/eval_results'
 require_relative 'context_compiler'
 require_relative 'embedding_index'
 require_relative 'cold_start'
+require_relative 'gap_detector'
+require_relative 'function_generator'
+require_relative 'self_generate'
 require_relative 'tools/do_action'
 require_relative 'tools/plan_action'
 require_relative 'tools/discover_tools'

data/lib/legion/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module MCP
-    VERSION = '0.5.3'
+    VERSION = '0.5.4'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-mcp
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Esity
@@ -128,6 +128,7 @@ files:
 - lib/legion/mcp/context_compiler.rb
 - lib/legion/mcp/context_guard.rb
 - lib/legion/mcp/embedding_index.rb
+- lib/legion/mcp/function_generator.rb
 - lib/legion/mcp/gap_detector.rb
 - lib/legion/mcp/observer.rb
 - lib/legion/mcp/override_broadcast.rb
@@ -138,6 +139,7 @@ files:
 - lib/legion/mcp/pattern_store.rb
 - lib/legion/mcp/resources/extension_info.rb
 - lib/legion/mcp/resources/runner_catalog.rb
+- lib/legion/mcp/self_generate.rb
 - lib/legion/mcp/server.rb
 - lib/legion/mcp/settings.rb
 - lib/legion/mcp/tier_router.rb