legion-mcp 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19e316cc546a5fae512d371abccff4f2b6eef90d2902ee7df75a97eb5680dc01
-  data.tar.gz: 0b9d4d42b3a3677e66d289454e5d496c0535f8d99e71c1a20a9a2d718c18305a
+  metadata.gz: e7d5c086abd567056b532b2e01df696e4fc025e1e709560b4260c8c81a8f921b
+  data.tar.gz: b00dd7b18bd76e8342d93e7422141bdb26210fa74dc7a638d45e0e6121b2d164
 SHA512:
-  metadata.gz: c15a8d8c104f8fbbfeccbc50e6a58363a7989ca84e28c13d9b8199fe6ea700733e3f449cb619ecc4c5948ca947f9f9b756eda51a707705f765504145faa64543
-  data.tar.gz: 3001f29ecd4a9da497c4ee5824086bdb7288a99db51202d017d031df38a0f987f4db0ba123cf61e527f1e961be5422307aac394001b55250c3a461514e20c466
+  metadata.gz: b06032b5477c79f163db706354ff02913ee3ffeffed4d036276c0acb186842452e0c2987275644bab9da0372392eb7442daba094a345a9bd7cc1ff0faefd92df
+  data.tar.gz: da7f527912b6b96b40b45623c2090715bb91c0b3cf448e97e7fd40cc3546a86644f72dc7d40a0a72b40949ce9c3f9f152132bc6333b23be5a687d5675bf57e27

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [0.6.2] - 2026-03-26
+
+### Fixed
+- `deps_satisfied?` now strips leading `::` and rejects empty parts from dependency strings to avoid `NameError` on constants like `::Legion::MCP`
+- `discover_and_register` prefers `Legion::Extensions.extensions` public accessor with ivar fallback
+- `tool_registry` and `@tool_registry_lock` initialized eagerly at module level to eliminate thread-race on first access
+- Removed `@tool_registry_lock ||=` guard from `register_tool`/`unregister_tool` (lock always present)
+- Added explicit `require 'concurrent'` to `lib/legion/mcp.rb` to prevent `NameError: uninitialized constant Concurrent` in isolation
+
+### Changed
+- Spec descriptions updated from `TOOL_CLASSES` to `tool_registry` / `Server.tool_registry` for accuracy
+
+## [0.6.1] - 2026-03-26
+
+### Changed
+- Replace frozen TOOL_CLASSES with mutable tool_registry for dynamic tool registration
+- Simplify self_generate to detect gaps and publish via AMQP (removed FunctionGenerator)
+- Extract `runner_expose_opts` and `register_function` helpers from `build_tools_from_runner` to reduce cyclomatic complexity
+- Split `Settings.defaults` into focused sub-methods to reduce method length
+
+### Added
+- Codegen self-generate and MCP auto-expose settings defaults
+- Function metadata auto-discovery for dynamic MCP tool registration
+
+### Removed
+- `function_generator.rb` and `capability_generator.rb` (generation moved to lex-codegen)
+
 ## [0.6.0] - 2026-03-26
 
 ### Added

data/CLAUDE.md

@@ -7,7 +7,7 @@
 Standalone gem providing the Model Context Protocol (MCP) server for LegionIO. Extracted from LegionIO to enable independent versioning and reuse. Includes semantic tool matching, observation pipeline, context compilation, tiered inference (Tier 0/1/2), and tool governance.
 
 **GitHub**: https://github.com/LegionIO/legion-mcp
-**Version**: 0.6.0
+**Version**: 0.6.2
 **License**: Apache-2.0
 **Ruby**: >= 3.4
 

data/README.md

@@ -2,7 +2,7 @@
 
 MCP (Model Context Protocol) server for the LegionIO framework. Provides semantic tool matching, observation pipeline, context compilation, and tiered behavioral intelligence (Tier 0/1/2 routing).
 
-**Version**: 0.6.0
+**Version**: 0.6.1
 
 Extracted from [LegionIO](https://github.com/LegionIO/LegionIO) for independent versioning and reuse.
 

data/lib/legion/mcp/catalog_bridge.rb

@@ -38,7 +38,7 @@ module Legion
       end
 
       def dynamic_tool_list
-        static = Server::TOOL_CLASSES.map do |klass|
+        static = Server.tool_registry.map do |klass|
           { name: klass.tool_name, description: klass.description,
             input_schema: klass.input_schema, source: :builtin, klass: klass }
         end

data/lib/legion/mcp/context_compiler.rb

@@ -62,7 +62,7 @@ module Legion
         end
       end
 
-      # Returns tools for a specific category, filtered to only those present in TOOL_CLASSES.
+      # Returns tools for a specific category, filtered to only those present in Server.tool_registry.
       # @param category_sym [Symbol] one of the CATEGORIES keys
       # @return [Hash, nil] { category:, summary:, tools: [{ name:, description:, params: }] } or nil
       def category_tools(category_sym)
@@ -82,7 +82,7 @@ module Legion
 
       # Keyword-match intent against tool names and descriptions.
       # @param intent_string [String] natural language intent
-      # @return [Class, nil] best matching tool CLASS from Server::TOOL_CLASSES or nil
+      # @return [Class, nil] best matching tool CLASS from Server.tool_registry or nil
       def match_tool(intent_string)
         scored = scored_tools(intent_string)
         return nil if scored.empty?
@@ -90,7 +90,7 @@ module Legion
         best = scored.max_by { |entry| entry[:score] }
         return nil if best[:score].zero?
 
-        Server::TOOL_CLASSES.find { |klass| klass.tool_name == best[:name] }
+        Server.tool_registry.find { |klass| klass.tool_name == best[:name] }
       end
 
       # Returns top N keyword-matched tools ranked by score.
@@ -118,7 +118,7 @@ module Legion
       end
 
       def build_tool_index
-        Server::TOOL_CLASSES.each_with_object({}) do |klass, idx|
+        Server.tool_registry.each_with_object({}) do |klass, idx|
           raw_schema = klass.input_schema
           schema = raw_schema.is_a?(Hash) ? raw_schema : raw_schema.to_h
           properties = schema[:properties] || {}

data/lib/legion/mcp/function_discovery.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module FunctionDiscovery
+      module_function
+
+      def discover_and_register
+        return unless defined?(Legion::Extensions)
+
+        extensions =
+          if Legion::Extensions.respond_to?(:extensions)
+            Legion::Extensions.extensions || []
+          else
+            Legion::Extensions.instance_variable_get(:@extensions) || []
+          end
+        extensions.each do |ext|
+          next unless ext.respond_to?(:runner_modules)
+
+          ext.runner_modules.each { |runner_mod| build_tools_from_runner(runner_mod) }
+        rescue StandardError => e
+          Legion::Logging.debug("FunctionDiscovery: skipping #{ext}: #{e.message}") if defined?(Legion::Logging)
+        end
+      end
+
+      def build_tools_from_runner(runner_module)
+        return unless runner_module.respond_to?(:settings) && runner_module.settings.is_a?(Hash)
+
+        functions = runner_module.settings[:functions]
+        return if functions.nil? || functions.empty?
+
+        opts = runner_expose_opts(runner_module)
+        functions.each { |func_name, meta| register_function(runner_module, func_name, meta, opts) }
+      end
+
+      def runner_expose_opts(runner_module)
+        class_expose = runner_module.respond_to?(:expose_as_mcp_tool) ? runner_module.expose_as_mcp_tool : nil
+        global_expose = defined?(Legion::Settings) ? (Legion::Settings.dig(:mcp, :auto_expose_runners) || false) : false
+        prefix = runner_module.respond_to?(:mcp_tool_prefix) ? runner_module.mcp_tool_prefix : nil
+        { class_expose: class_expose, global_expose: global_expose, prefix: prefix }
+      end
+
+      def register_function(runner_module, func_name, meta, opts)
+        return unless should_expose?(meta, opts[:class_expose], opts[:global_expose])
+        return unless deps_satisfied?(meta[:requires])
+
+        tool_class = build_tool_class(
+          name:          derive_tool_name(func_name, opts[:prefix]),
+          description:   meta[:desc] || "Auto-discovered: #{func_name}",
+          input_schema:  meta[:options] || { properties: {} },
+          runner_module: runner_module,
+          function_name: func_name
+        )
+
+        Server.register_tool(tool_class)
+      end
+
+      def should_expose?(func_meta, class_level, global_default)
+        return func_meta[:expose] unless func_meta[:expose].nil?
+        return class_level unless class_level.nil?
+
+        global_default || false
+      end
+
+      def derive_tool_name(func_name, prefix)
+        base = prefix || 'legion.generated'
+        "#{base}.#{func_name}"
+      end
+
+      def deps_satisfied?(deps)
+        return true if deps.nil? || deps.empty?
+
+        deps.all? do |dep|
+          parts = dep.delete_prefix('::').split('::').reject(&:empty?)
+          current = Object
+          parts.all? do |part|
+            if current.const_defined?(part, false)
+              current = current.const_get(part, false)
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+
+      def build_tool_class(name:, description:, input_schema:, runner_module:, function_name:)
+        runner_ref = runner_module
+        func_ref = function_name
+
+        Class.new(::MCP::Tool) do
+          tool_name name
+          description description
+          input_schema(input_schema)
+
+          define_singleton_method(:call) do |**params|
+            error = false
+
+            result =
+              if runner_ref.respond_to?(func_ref)
+                begin
+                  runner_ref.public_send(func_ref, **params)
+                rescue StandardError => e
+                  error = true
+                  { error: e.message }
+                end
+              else
+                error = true
+                { error: "function #{func_ref} not found" }
+              end
+
+            text = defined?(Legion::JSON) ? Legion::JSON.dump(result) : result.to_s
+            ::MCP::Tool::Response.new([{ type: 'text', text: text }], error: error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/pattern_compiler.rb

@@ -6,9 +6,9 @@ module Legion
       module_function
 
       def compile_tool_definitions
-        return [] unless defined?(Legion::MCP::Server::TOOL_CLASSES)
+        return [] unless defined?(Legion::MCP::Server)
 
-        Legion::MCP::Server::TOOL_CLASSES.map do |klass|
+        Legion::MCP::Server.tool_registry.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)

data/lib/legion/mcp/self_generate.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'digest'
+require 'time'
 
 module Legion
   module MCP
@@ -10,41 +11,76 @@ module Legion
 
       module_function
 
+      def enabled?
+        return false unless defined?(Legion::Settings)
+
+        Legion::Settings.dig(:codegen, :self_generate, :enabled) == true
+      end
+
       def run_cycle
+        return { success: false, reason: :disabled } unless enabled?
         return { success: false, reason: :cooldown } if in_cooldown?
 
         gaps = GapDetector.detect_gaps
-        return { success: true, gaps_found: 0, generated: 0 } if gaps.empty?
+        return { success: true, gaps_found: 0, published: 0 } if gaps.empty?
 
-        top_gaps = gaps.sort_by { |g| -g[:priority] }.first(MAX_GAPS_PER_CYCLE)
+        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 }
+        published_count = 0
+        top_gaps.each do |gap|
+          published_count += 1 if publish_gap(gap)
         end
 
-        record_cycle(results)
+        if published_count.zero?
+          reason = defined?(Legion::Transport::Messages::Dynamic) ? :publish_failed : :transport_unavailable
+          return {
+            success:    false,
+            reason:     reason,
+            gaps_found: gaps.size,
+            processed:  top_gaps.size,
+            published:  0
+          }
+        end
 
-        generated = results.count { |r| r[:result][:success] }
-        failed    = results.count { |r| !r[:result][:success] }
+        record_cycle(published_count)
 
         {
           success:    true,
           gaps_found: gaps.size,
           processed:  top_gaps.size,
-          generated:  generated,
-          failed:     failed,
-          results:    results
+          published:  published_count
         }
       end
 
+      def publish_gap(gap)
+        return false unless defined?(Legion::Transport::Messages::Dynamic)
+
+        Legion::Transport::Messages::Dynamic.new(
+          function: 'codegen.gap.detected',
+          data:     {
+            gap_id:           gap[:id],
+            gap_type:         gap[:type],
+            intent:           gap[:intent] || gap[:intent_text],
+            occurrence_count: gap[:occurrences] || gap[:observation_count] || gap[:failure_count] || 1,
+            priority:         gap[:priority],
+            metadata:         gap[:metadata] || {},
+            detected_at:      Time.now.iso8601
+          }
+        ).publish
+        true
+      rescue StandardError => e
+        Legion::Logging.warn("SelfGenerate#publish_gap failed: #{e.message}") if defined?(Legion::Logging)
+        false
+      end
+
       def status
         {
           last_cycle_at:      last_cycle_at,
           total_cycles:       cycle_count,
-          total_generated:    total_generated,
+          total_published:    total_published,
           cooldown_remaining: cooldown_remaining,
-          pending_gaps:       GapDetector.detect_gaps.size
+          pending_gaps:       GapDetector.detect_gaps.size,
+          enabled:            enabled?
         }
       rescue StandardError => e
         { error: e.message }
@@ -54,7 +90,7 @@ module Legion
         mutex.synchronize do
           @last_cycle_at   = nil
           @cycle_count     = 0
-          @total_generated = 0
+          @total_published = 0
           @cycle_history   = []
         end
       end
@@ -66,27 +102,39 @@ module Legion
       def in_cooldown?
         return false unless last_cycle_at
 
-        Time.now - last_cycle_at < COOLDOWN_SECONDS
+        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 = cooldown_seconds - (Time.now - last_cycle_at)
         [remaining, 0].max.round(1)
       end
 
-      def record_cycle(results)
+      def total_published
+        mutex.synchronize { @total_published || 0 }
+      end
+
+      # private helpers
+
+      def max_gaps_per_cycle
+        val = Legion::Settings.dig(:codegen, :self_generate, :max_gaps_per_cycle) if defined?(Legion::Settings)
+        val || MAX_GAPS_PER_CYCLE
+      end
+
+      def cooldown_seconds
+        val = Legion::Settings.dig(:codegen, :self_generate, :cooldown_seconds) if defined?(Legion::Settings)
+        val || COOLDOWN_SECONDS
+      end
+
+      def record_cycle(published_count)
         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] }
+          @total_published = (@total_published || 0) + published_count
           @cycle_history ||= []
-          @cycle_history << {
-            at:            Time.now,
-            results_count: results.size,
-            generated:     results.count { |r| r[:result][:success] }
-          }
+          @cycle_history << { at: Time.now, published: published_count }
           @cycle_history.shift if @cycle_history.size > 50
         end
       end
@@ -99,10 +147,6 @@ module Legion
         mutex.synchronize { @cycle_count || 0 }
       end
 
-      def total_generated
-        mutex.synchronize { @total_generated || 0 }
-      end
-
       def mutex
         @mutex ||= Mutex.new
       end

data/lib/legion/mcp/server.rb

@@ -48,7 +48,7 @@ require_relative 'context_compiler'
 require_relative 'embedding_index'
 require_relative 'cold_start'
 require_relative 'gap_detector'
-require_relative 'function_generator'
+require_relative 'function_discovery'
 require_relative 'self_generate'
 require_relative 'tools/do_action'
 require_relative 'tools/plan_action'
@@ -74,7 +74,7 @@ require_relative 'resources/extension_info'
 module Legion
   module MCP
     module Server
-      TOOL_CLASSES = [
+      STATIC_TOOLS = [
         Tools::RunTask,
         Tools::DescribeRunner,
         Tools::ListTasks,
@@ -136,14 +136,40 @@ module Legion
         Tools::KnowledgeContext
       ].freeze
 
+      @tool_registry = Concurrent::Array.new(STATIC_TOOLS)
+      @tool_registry_lock = Mutex.new
+
       class << self
         include CatalogBridge
 
+        attr_reader :tool_registry
+
+        def register_tool(tool_class)
+          @tool_registry_lock.synchronize do
+            return if tool_registry.any? { |tc| tc.tool_name == tool_class.tool_name }
+
+            tool_registry << tool_class
+            reset_caches!
+          end
+        end
+
+        def unregister_tool(tool_name)
+          @tool_registry_lock.synchronize do
+            tool_registry.reject! { |tc| tc.tool_name == tool_name }
+            reset_caches!
+          end
+        end
+
+        def reset_caches!
+          ContextCompiler.reset! if defined?(ContextCompiler)
+          EmbeddingIndex.reset! if defined?(EmbeddingIndex) && EmbeddingIndex.respond_to?(:reset!)
+        end
+
         def build(identity: nil)
           tools = if ToolGovernance.governance_enabled?
-                    ToolGovernance.filter_tools(TOOL_CLASSES, identity)
+                    ToolGovernance.filter_tools(tool_registry, identity)
                   else
-                    TOOL_CLASSES
+                    tool_registry
                   end
 
           server = ::MCP::Server.new(
@@ -171,6 +197,10 @@ module Legion
           # Cold-start: load community patterns if store is still empty after hydration
           ColdStart.load_community_patterns if defined?(ColdStart)
 
+          # Discover and register runner functions before building the embedding index
+          # so all tools are present when embeddings are populated
+          FunctionDiscovery.discover_and_register if defined?(Legion::Extensions)
+
           # Populate embedding index for semantic tool matching (lazy — no-op if LLM unavailable)
           populate_embedding_index
 
@@ -219,10 +249,10 @@ module Legion
         end
 
         def build_filtered_tool_list(keywords: [])
-          tool_names = TOOL_CLASSES.map { |tc| tc.respond_to?(:tool_name) ? tc.tool_name : tc.name }
+          tool_names = tool_registry.map { |tc| tc.respond_to?(:tool_name) ? tc.tool_name : tc.name }
           ranked     = UsageFilter.ranked_tools(tool_names, keywords: keywords)
           ranked.filter_map do |name|
-            TOOL_CLASSES.find do |tc|
+            tool_registry.find do |tc|
               (tc.respond_to?(:tool_name) ? tc.tool_name : tc.name) == name
             end
           end

data/lib/legion/mcp/settings.rb

@@ -11,7 +11,65 @@ module Legion
           overrides:       {},
           tool_cache_ttl:  300,
           connect_timeout: 10,
-          call_timeout:    30
+          call_timeout:    30,
+          codegen:         { self_generate: self_generate_defaults },
+          mcp:             { auto_expose_runners: false }
+        }
+      end
+
+      def self_generate_defaults
+        {
+          enabled:            false,
+          cooldown_seconds:   300,
+          max_gaps_per_cycle: 5,
+          tier:               self_generate_tier_defaults,
+          runner_method:      { output_dir: '~/.legionio/generated/runners', namespace: 'Legion::Generated' },
+          full_extension:     { output_dir: '~/.legionio/generated/extensions', auto_bundle: false },
+          validation:         self_generate_validation_defaults,
+          approval:           { required: false, auto_approve_confidence: 0.9, auto_approve_gap_types: [] },
+          hot_register:       { mcp_tools: true, full_load_on_boot: true },
+          corroboration:      self_generate_corroboration_defaults,
+          github:             self_generate_github_defaults
+        }
+      end
+
+      def self_generate_tier_defaults
+        {
+          simple_max_occurrences:    10,
+          complex_min_occurrences:   11,
+          recurrence_window_seconds: 86_400
+        }
+      end
+
+      def self_generate_validation_defaults
+        {
+          syntax_check: true,
+          run_specs:    true,
+          llm_review:   true,
+          max_retries:  2,
+          quality_gate: { enabled: false, threshold: 0.8 }
+        }
+      end
+
+      def self_generate_corroboration_defaults
+        {
+          enabled:                      true,
+          min_agents:                   2,
+          apollo_query_before_generate: true,
+          priority_boost_per_agent:     0.15
+        }
+      end
+
+      def self_generate_github_defaults
+        {
+          enabled:               false,
+          auto_branch:           true,
+          auto_pr:               true,
+          auto_merge:            false,
+          target_repo:           nil,
+          target_branch:         'main',
+          pr_labels:             %w[auto-generated needs-review],
+          adversarial_reviewers: 3
         }
       end
     end

data/lib/legion/mcp/tier_router.rb

@@ -102,9 +102,9 @@ module Legion
       end
 
       def find_tool_class(tool_name)
-        return nil unless defined?(Legion::MCP::Server::TOOL_CLASSES)
+        return nil unless defined?(Legion::MCP::Server)
 
-        Legion::MCP::Server::TOOL_CLASSES.find do |klass|
+        Legion::MCP::Server.tool_registry.find do |klass|
           klass.respond_to?(:tool_name) && klass.tool_name == tool_name
         end
       end

data/lib/legion/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module MCP
-    VERSION = '0.6.0'
+    VERSION = '0.6.2'
   end
 end

data/lib/legion/mcp.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'concurrent'
 require 'mcp'
 require 'legion/json'
 require_relative 'mcp/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Esity
@@ -120,7 +120,6 @@ files:
 - legion-mcp.gemspec
 - lib/legion/mcp.rb
 - lib/legion/mcp/auth.rb
-- lib/legion/mcp/capability_generator.rb
 - lib/legion/mcp/catalog_bridge.rb
 - lib/legion/mcp/client.rb
 - lib/legion/mcp/client/connection.rb
@@ -130,7 +129,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/function_discovery.rb
 - lib/legion/mcp/gap_detector.rb
 - lib/legion/mcp/observer.rb
 - lib/legion/mcp/override_broadcast.rb

data/lib/legion/mcp/capability_generator.rb

@@ -1,114 +0,0 @@
-# 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
-        Legion::Logging.warn("CapabilityGenerator#generate_from_gap failed: #{e.message}") if defined?(Legion::Logging)
-        { 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 => e
-            Legion::Logging.warn("CapabilityGenerator#validate eval failed: #{e.message}") if defined?(Legion::Logging)
-            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, caller: { extension: 'legion-mcp', operation: 'capability_gen', phase: 'runner' })
-      rescue StandardError => e
-        Legion::Logging.warn("CapabilityGenerator#generate_runner failed: #{e.message}") if defined?(Legion::Logging)
-        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, caller: { extension: 'legion-mcp', operation: 'capability_gen', phase: 'spec' })
-      rescue StandardError => e
-        Legion::Logging.warn("CapabilityGenerator#generate_spec failed: #{e.message}") if defined?(Legion::Logging)
-        nil
-      end
-
-      def syntax_valid?(code)
-        RubyVM::InstructionSequence.compile(code)
-        true
-      rescue SyntaxError => e
-        Legion::Logging.debug("CapabilityGenerator#syntax_valid? syntax error: #{e.message}") if defined?(Legion::Logging)
-        false
-      end
-
-      def llm_available?
-        defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
-      end
-    end
-  end
-end

data/lib/legion/mcp/function_generator.rb

@@ -1,158 +0,0 @@
-# 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