mewmew 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 769d8c200467f6133c57ff947521b1a73be13d273c182904b8ba5b51d448f551
+  data.tar.gz: f39f7bceb745991663d71ef9e3e69a924bb978cd2108c06440fdc22f98628c1a
+SHA512:
+  metadata.gz: 6b1fe4ae16186be03d19c9fb2af9e1ad63284ffb21eb9b68ad51791a54318f99b53c5116760b21ed3803e76a1f1d0704ec8e1ffd711d9c03c9e98deafdb72292
+  data.tar.gz: 61322d6cbffd4aca03bd8c4919b28c643443381d0edb992f686f7d76dae3ad51856073cc39da2c598876f954b3fe000a69558290814c47ef712476336e72aeda

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-08-28
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Martin Emde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Mewmew
+
+Just add Mewmew to make any Thor CLI into an MCP server.
+
+Mewmew automatically converts Thor CLI commands into MCP (Model Context Protocol) tools that can be used by AI assistants.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'mewmew'
+```
+
+or add to a gemspec for a command that already uses Thor.
+
+## Usage
+
+### 1. Include Mewmew in your Thor class
+
+Simply add `include Mewmew` to your Thor CLI class:
+
+```ruby
+require 'thor'
+require 'mewmew'
+
+class MyCli < Thor
+  include Mewmew  # MCP command is automatically added!
+
+  # Optional: Customize MCP server options
+  # add_mcp_command(name: "my_custom_name", version: "2.0.0")
+
+  desc "hello NAME", "Say hello to someone"
+  def hello(name)
+    puts "Hello, #{name}!"
+  end
+
+  desc "greet", "Greet the world"
+  method_option :style, type: :string, default: "normal", desc: "Greeting style"
+  def greet
+    style = options[:style]
+    case style
+    when "loud"
+      puts "HELLO WORLD!"
+    when "quiet"
+      puts "hello world..."
+    else
+      puts "Hello world!"
+    end
+  end
+end
+```
+
+### 2. Start the MCP server
+
+Run your CLI with the `mcp` command:
+
+```bash
+ruby my_cli mcp
+```
+
+## Cursor Integration
+
+To use your CLI with Cursor:
+
+1. **Configure MCP in Cursor**: Add this to your `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "my_cli": {
+      "command": "/path/to/ruby",
+      "args": ["/path/to/your/my_cli.rb", "mcp"]
+    }
+  }
+}
+```
+
+2. **Restart Cursor** to pick up the MCP configuration
+
+3. **Use in Cursor**: Your CLI commands will now be available as tools that Cursor can call automatically!
+
+## Example
+
+Check out the complete example in `examples/example_cli.rb` which creates a Wikipedia lookup CLI that can be used with Cursor.
+
+## Features
+
+- 🚀 **Automatic detection**: Just `include Mewmew` in any Thor class
+- ⚡ **Zero configuration**: MCP tools are automatically added - no extra steps needed
+- 🛠️ **Works with existing Thor commands out of the box**
+- 📝 **Full option support**: Method options, descriptions, and arguments are preserved
+- 🔄 **Live updates**: Changes to your CLI are immediately available to Cursor
+
+## Requirements
+
+- Ruby 3.0+
+- Thor gem
+- MCP gem (installed automatically)

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/examples/example_cli.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+begin
+  require "thor"
+rescue LoadError
+  warn "This example requires the 'thor' gem. Install with: gem install thor"
+  exit 1
+end
+
+require "net/http"
+require "json"
+require "uri"
+
+# Load mewmew for MCP integration
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "mewmew"
+
+class McuCli < Thor
+  include Mewmew
+
+  # MCP command is automatically added when Mewmew is included!
+  # You can optionally customize it: add_mcp_command(name: "mcu_cli", version: "1.0.0")
+  desc "lookup [QUERY]", "Lookup a movie/comic item on Wikipedia and print a summary"
+  method_option :lang, type: :string, default: "en", desc: "Wikipedia language code"
+  def lookup(query = nil)
+    lang = options[:lang]
+    normalized_query = normalize_query(query)
+    title = find_best_title(normalized_query, lang) || normalized_query
+    summary = fetch_summary(title, lang)
+
+    if summary && !summary.strip.empty?
+      say "Title: #{title}", :green
+      say summary
+    else
+      say "No summary found for '#{query}'.", :red
+    end
+  end
+
+  desc "hammer", "Show info about Thor's hammer (Mjolnir) a.k.a. 'Mew Mew'"
+  method_option :lang, type: :string, default: "en", desc: "Wikipedia language code"
+  def hammer
+    lookup("Mjolnir")
+  end
+
+  no_commands do
+    def normalize_query(q)
+      return "Mjolnir" if q.nil? || q.strip.empty?
+      key = q.to_s.strip.downcase
+      case key
+      when "mew mew", "meow meow", "mewmew", "meowmeow", "thor's hammer", "thors hammer"
+        "Mjolnir"
+      when "mjolnir", "mjölner", "mjöllnir", "mjolnir (comics)", "mjölnir"
+        "Mjolnir"
+      else
+        q
+      end
+    end
+
+    def find_best_title(query, lang)
+      # Use MediaWiki opensearch to find the closest matching title
+      uri = URI("https://#{lang}.wikipedia.org/w/api.php")
+      uri.query = URI.encode_www_form(
+        action: "opensearch",
+        format: "json",
+        search: query,
+        limit: 5,
+        namespace: 0
+      )
+      data = fetch_json(uri)
+      return nil unless data.is_a?(Array) && data[1].is_a?(Array) && data[1].any?
+
+      titles = data[1]
+      descriptions = data[2] || []
+
+      ranked = titles.each_with_index.sort_by do |title, i|
+        desc = descriptions[i].to_s.downcase
+        score = 0
+        score -= i # earlier results get higher priority
+        score += 3 if title.downcase.include?("mjolnir") || title.downcase.include?("mjölnir")
+        score += 2 if desc.include?("marvel")
+        score += 1 if desc.include?("thor")
+        -score
+      end
+
+      ranked.first&.first
+    rescue StandardError
+      nil
+    end
+
+    def fetch_summary(title, lang)
+      # Use REST summary endpoint which follows redirects and returns plaintext extract
+      # IMPORTANT: Title is a PATH segment, not a query param. Spaces should be underscores, not '+'.
+      slug = title.to_s.strip.tr(" ", "_")
+      uri = URI("https://#{lang}.wikipedia.org/api/rest_v1/page/summary/#{slug}")
+      data = fetch_json(uri)
+      data && (data["extract"] || data["description"])
+    rescue StandardError
+      nil
+    end
+
+    def fetch_json(uri)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        req = Net::HTTP::Get.new(uri)
+        req["User-Agent"] = "mewmew-example-cli/1.0 (https://github.com/martinemde/mewmew)"
+        http.request(req)
+      end
+      return nil unless response.is_a?(Net::HTTPSuccess)
+      JSON.parse(response.body)
+    end
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+end
+
+McuCli.start(ARGV)

data/examples/mcp_server.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd "$(dirname "$0")/.."
+exec bundle exec ruby examples/example_cli.rb mcp

data/lib/mewmew/mcp_integration.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+  require "mcp/server/transports/stdio_transport"
+rescue LoadError
+  raise LoadError, "MCP gem is required. Add 'mcp' to your Gemfile."
+end
+
+module Mewmew
+  # Integrates Thor CLI with MCP server
+  class McpIntegration
+    attr_reader :thor_class, :server_options
+
+    def initialize(thor_class, **server_options)
+      @thor_class = thor_class
+      @server_options = server_options
+    end
+
+    # Start the MCP stdio server
+    def serve
+      server = create_server
+      transport = MCP::Server::Transports::StdioTransport.new(server)
+
+      # Trap signals for graceful shutdown
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          warn "\nShutting down MCP server..."
+          transport.close
+          exit(0)
+        end
+      end
+
+      transport.open
+    end
+
+    # Create an MCP server with Thor tools
+    def create_server
+      tools = ThorIntrospector.new(thor_class).to_mcp_tools
+
+      MCP::Server.new(
+        name: server_name,
+        version: server_version,
+        tools: tools,
+        **server_options
+      )
+    end
+
+    private
+
+    def server_name
+      server_options[:name] || thor_class_name.downcase
+    end
+
+    def server_version
+      server_options[:version] || "1.0.0"
+    end
+
+    def thor_class_name
+      thor_class.name&.split("::")&.last || "ThorCLI"
+    end
+  end
+
+  # Module to be included in Thor classes to add MCP functionality
+  module ThorMcpExtension
+    def self.included(base)
+      base.extend(ClassMethods)
+      # Automatically add the MCP command with default options
+      base.add_mcp_command
+    end
+
+    module ClassMethods
+      # Add the mcp command to the Thor class
+      def add_mcp_command(**server_options)
+        desc "mcp", "Start MCP (Model Context Protocol) server to expose CLI commands as tools"
+        define_method :mcp do
+          Mewmew.serve_cli(self.class, **server_options)
+        end
+      end
+    end
+  end
+end

data/lib/mewmew/thor_introspector.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+begin
+  require "mcp"
+rescue LoadError
+  raise LoadError, "MCP gem is required. Add 'mcp' to your Gemfile."
+end
+
+module Mewmew
+  # Introspects Thor CLI classes and extracts command information
+  class ThorIntrospector
+    attr_reader :thor_class
+
+    def initialize(thor_class)
+      @thor_class = thor_class
+      validate_thor_class!
+    end
+
+    # Get all commands from the Thor class
+    def commands
+      @commands ||= thor_class.commands.reject { |name, _| %w[help mcp].include?(name) }
+    end
+
+      # Convert Thor commands to MCP tools
+  def to_mcp_tools
+    commands.map do |name, command|
+      create_tool_class(name, command, thor_class)
+    end
+  end
+
+  private
+
+  def create_tool_class(command_name, thor_command, thor_class)
+    # Dynamically create a tool class that inherits from MCP::Tool
+    Class.new(MCP::Tool) do
+      # Set the tool metadata
+      tool_name command_name
+      description thor_command.description || "Execute the #{command_name} command"
+
+      # Build input schema from method signature and options
+      schema_properties = {}
+      schema_required = []
+
+      # Handle command arguments from method signature
+      method = thor_class.instance_method(command_name.to_sym)
+      method.parameters.each do |param_type, param_name|
+        case param_type
+        when :req
+          schema_properties[param_name] = {
+            type: "string",
+            description: "#{param_name.to_s.capitalize} argument"
+          }
+          schema_required << param_name.to_s
+        when :opt
+          schema_properties[param_name] = {
+            type: "string",
+            description: "#{param_name.to_s.capitalize} argument (optional)"
+          }
+        when :rest
+          schema_properties[param_name] = {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional #{param_name.to_s.capitalize} arguments"
+          }
+        end
+      end
+
+      # Handle command options
+      if thor_command.options
+        thor_command.options.each do |option_name, option|
+          next if option_name == :help
+
+          schema = {
+            description: option.description || "#{option.name.to_s.gsub('_', ' ').capitalize} option"
+          }
+
+          case option.type
+          when :boolean
+            schema[:type] = "boolean"
+            schema[:default] = option.default if !option.default.nil?
+          when :numeric
+            schema[:type] = "number"
+            schema[:default] = option.default if !option.default.nil?
+          when :array
+            schema[:type] = "array"
+            schema[:items] = { type: "string" }
+            schema[:default] = option.default if option.default
+          else
+            schema[:type] = "string"
+            schema[:default] = option.default if option.default
+          end
+
+          schema_properties[option_name] = schema
+        end
+      end
+
+      input_schema(properties: schema_properties, required: schema_required)
+
+      # Define the class method to execute the command
+      define_singleton_method :call do |server_context: nil, **args|
+        begin
+          # Create a new instance of the Thor class
+          thor_instance = thor_class.new
+
+          # Extract arguments and options
+          method = thor_class.instance_method(command_name.to_sym)
+          arg_names = method.parameters
+            .select { |type, _| [:req, :opt].include?(type) }
+            .map { |_, name| name }
+
+          command_args = []
+          options = {}
+
+          args.each do |key, value|
+            key_sym = key.to_sym
+            if arg_names.include?(key_sym)
+              arg_index = arg_names.index(key_sym)
+              command_args[arg_index] = value
+            else
+              options[key_sym] = value
+            end
+          end
+
+          # Fill in missing arguments with nil
+          command_args.fill(nil, command_args.length, arg_names.length - command_args.length) if arg_names.any?
+
+          # Set up Thor instance with options
+          thor_instance.options = thor_instance.options.merge(options) if options.any?
+
+          # Capture output
+          original_stdout = $stdout
+          stdout_capture = StringIO.new
+
+          # Only capture stdout, leave stderr for debug output
+          $stdout = stdout_capture
+
+          begin
+            thor_instance.send(command_name, *command_args.compact)
+
+            stdout_content = stdout_capture.string
+            output = stdout_content.empty? ? "Command executed successfully" : stdout_content
+          ensure
+            $stdout = original_stdout
+          end
+
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: output
+          }])
+        rescue => e
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "Error executing command '#{command_name}': #{e.message}"
+          }], true)
+        end
+      end
+    end
+  end
+
+    private
+
+    def validate_thor_class!
+      # Check if the class inherits from any Thor-like class
+      unless thor_like_class?(thor_class)
+        raise Error, "Class must inherit from Thor or a Thor-like class. Got: #{thor_class} with superclass: #{thor_class.superclass}"
+      end
+    end
+
+    def thor_like_class?(klass)
+      return false unless klass.is_a?(Class)
+
+      # Check the inheritance chain for Thor-like classes
+      current_class = klass
+      while current_class && current_class != Object
+        parent = current_class.superclass
+        if parent && (parent.name == "Thor" || parent.name&.end_with?("::Thor"))
+          return true
+        end
+        current_class = parent
+      end
+
+      false
+    end
+  end
+end

data/lib/mewmew/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mewmew
+  VERSION = "0.1.0"
+end

data/lib/mewmew.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "mewmew/version"
+require_relative "mewmew/thor_introspector"
+require_relative "mewmew/mcp_integration"
+
+module Mewmew
+  class Error < StandardError; end
+
+  # Auto-detect Thor classes and include MCP functionality
+  def self.included(base)
+    # Check if the base class is a Thor class by looking for Thor inheritance
+    if thor_class?(base)
+      base.include(Mewmew::ThorMcpExtension)
+    end
+  end
+
+  class << self
+    # Convert a Thor CLI class to MCP tools and start a server
+    def serve_cli(thor_class, **server_options)
+      McpIntegration.new(thor_class, **server_options).serve
+    end
+
+    # Get MCP tools for a Thor CLI class without starting server
+    def tools_for_cli(thor_class)
+      ThorIntrospector.new(thor_class).to_mcp_tools
+    end
+
+    private
+
+    # Check if a class is a Thor class
+    def thor_class?(klass)
+      # Check if it's a subclass of Thor or includes Thor::Base
+      return true if defined?(::Thor) && klass <= ::Thor
+      return true if defined?(::Thor::Base) && klass.include?(::Thor::Base)
+      false
+    rescue
+      false
+    end
+  end
+end

data/sig/mewmew.rbs

@@ -0,0 +1,4 @@
+module Mewmew
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/integration_test.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+class MCPIntegrationTest
+  attr_reader :test_results, :total_tests, :passed_tests
+
+  def initialize
+    @test_results = []
+    @total_tests = 0
+    @passed_tests = 0
+  end
+
+  def run_all_tests
+    puts "🧪 Running MCP Integration Tests"
+    puts "=" * 50
+
+    test_tools_list
+    test_lookup_with_query
+    test_lookup_with_options
+    test_hammer_command
+    test_invalid_tool
+    test_missing_args
+    test_boolean_option
+
+    print_summary
+    exit(@passed_tests == @total_tests ? 0 : 1)
+  end
+
+  private
+
+  def test_tools_list
+    test_name = "Tools List"
+    puts "\n🔍 Testing: #{test_name}"
+
+    result = run_mcp_command("tools/list")
+
+    if result[:success] && result[:data]
+      tools = result[:data]["tools"]
+      expected_tools = %w[lookup hammer]
+      actual_tools = tools.map { |t| t["name"] }.sort
+
+      if actual_tools == expected_tools.sort
+        assert_pass(test_name, "Found expected tools: #{actual_tools.join(', ')}")
+
+        # Check tool schemas
+        lookup_tool = tools.find { |t| t["name"] == "lookup" }
+        if lookup_tool && lookup_tool["inputSchema"]["properties"]["query"]
+          assert_pass("#{test_name} - Schema", "Lookup tool has query parameter")
+        else
+          assert_fail("#{test_name} - Schema", "Lookup tool missing query parameter")
+        end
+      else
+        assert_fail(test_name, "Expected tools: #{expected_tools}, got: #{actual_tools}")
+      end
+    else
+      assert_fail(test_name, "Failed to get tools list: #{result[:error]}")
+    end
+  end
+
+  def test_lookup_with_query
+    test_name = "Lookup with Query"
+    puts "\n🔍 Testing: #{test_name}"
+
+    result = run_mcp_command("tools/call", tool_name: "lookup", args: { query: "mjolnir" })
+
+    if result[:success] && result[:data]
+      content = result[:data]["content"]
+      if content && content[0] && content[0]["text"]
+        text = content[0]["text"]
+        # The CLI should return some result (even if it's "No summary found")
+        if text.length > 0
+          assert_pass(test_name, "Returned text: #{text.strip}")
+        else
+          assert_fail(test_name, "Empty response text")
+        end
+      else
+        assert_fail(test_name, "No text content in response")
+      end
+    else
+      assert_fail(test_name, "Tool call failed: #{result[:error]}")
+    end
+  end
+
+  def test_lookup_with_options
+    test_name = "Lookup with Language Option"
+    puts "\n🔍 Testing: #{test_name}"
+
+    result = run_mcp_command("tools/call", tool_name: "lookup", args: { query: "thor", lang: "en" })
+
+    if result[:success] && result[:data]
+      content = result[:data]["content"]
+      if content && content[0] && content[0]["text"]
+        text = content[0]["text"]
+        # Should execute without error (even if no results found)
+        assert_pass(test_name, "Executed with lang option: #{text.strip}")
+      else
+        assert_fail(test_name, "No text content in response")
+      end
+    else
+      assert_fail(test_name, "Tool call failed: #{result[:error]}")
+    end
+  end
+
+  def test_hammer_command
+    test_name = "Hammer Command"
+    puts "\n🔍 Testing: #{test_name}"
+
+    result = run_mcp_command("tools/call", tool_name: "hammer")
+
+    if result[:success] && result[:data]
+      content = result[:data]["content"]
+      if content && content[0] && content[0]["text"]
+        text = content[0]["text"]
+        # Hammer command calls lookup("Mjolnir") internally
+        assert_pass(test_name, "Hammer command executed: #{text.strip}")
+      else
+        assert_fail(test_name, "No text content in response")
+      end
+    else
+      assert_fail(test_name, "Tool call failed: #{result[:error]}")
+    end
+  end
+
+  def test_invalid_tool
+    test_name = "Invalid Tool Name"
+    puts "\n🔍 Testing: #{test_name}"
+
+    result = run_mcp_command("tools/call", tool_name: "nonexistent")
+
+    if result[:success]
+      assert_fail(test_name, "Should have failed for invalid tool name")
+    else
+      # Should get an error for invalid tool
+      assert_pass(test_name, "Correctly rejected invalid tool: #{result[:error]}")
+    end
+  end
+
+  def test_missing_args
+    test_name = "Missing Arguments"
+    puts "\n🔍 Testing: #{test_name}"
+
+    # Test calling lookup without query (it's optional but let's see what happens)
+    result = run_mcp_command("tools/call", tool_name: "lookup", args: {})
+
+    if result[:success] && result[:data]
+      content = result[:data]["content"]
+      if content && content[0] && content[0]["text"]
+        # Should work with no query (optional parameter)
+        assert_pass(test_name, "Handled missing optional parameter correctly")
+      else
+        assert_fail(test_name, "No content returned")
+      end
+    else
+      assert_fail(test_name, "Unexpected failure: #{result[:error]}")
+    end
+  end
+
+  def test_boolean_option
+    test_name = "Boolean Option"
+    puts "\n🔍 Testing: #{test_name}"
+
+    # Test with lang option (string) - should work
+    result = run_mcp_command("tools/call", tool_name: "lookup", args: { query: "test", lang: "fr" })
+
+    if result[:success] && result[:data]
+      assert_pass(test_name, "Boolean/string options handled correctly")
+    else
+      assert_fail(test_name, "Failed with options: #{result[:error]}")
+    end
+  end
+
+  def run_mcp_command(method, tool_name: nil, args: {})
+    cmd_parts = [
+      "npx", "@modelcontextprotocol/inspector",
+      "--cli", "./examples/mcp_server.sh",
+      "--method", method
+    ]
+
+    if tool_name
+      cmd_parts += ["--tool-name", tool_name]
+    end
+
+    args.each do |key, value|
+      cmd_parts += ["--tool-arg", "#{key}=#{value}"]
+    end
+
+    puts "  💻 Running: #{cmd_parts.join(' ')}"
+
+    stdout, stderr, status = Open3.capture3(*cmd_parts)
+
+    if status.success?
+      begin
+        data = JSON.parse(stdout)
+        { success: true, data: data }
+      rescue JSON::ParserError => e
+        { success: false, error: "JSON parse error: #{e.message}, output: #{stdout}" }
+      end
+    else
+      { success: false, error: "Command failed (#{status.exitstatus}): #{stderr}" }
+    end
+  rescue => e
+    { success: false, error: "Exception: #{e.message}" }
+  end
+
+  def assert_pass(test_name, message)
+    @total_tests += 1
+    @passed_tests += 1
+    @test_results << { name: test_name, status: :pass, message: message }
+    puts "  ✅ PASS: #{message}"
+  end
+
+  def assert_fail(test_name, message)
+    @total_tests += 1
+    @test_results << { name: test_name, status: :fail, message: message }
+    puts "  ❌ FAIL: #{message}"
+  end
+
+  def print_summary
+    puts "\n" + "=" * 50
+    puts "📊 TEST SUMMARY"
+    puts "=" * 50
+
+    @test_results.each do |result|
+      icon = result[:status] == :pass ? "✅" : "❌"
+      puts "#{icon} #{result[:name]}: #{result[:message]}"
+    end
+
+    puts "\n📈 Results: #{@passed_tests}/#{@total_tests} tests passed"
+
+    if @passed_tests == @total_tests
+      puts "🎉 All tests passed!"
+    else
+      puts "💥 #{@total_tests - @passed_tests} test(s) failed"
+    end
+  end
+end
+
+# Run the tests if this file is executed directly
+if __FILE__ == $0
+  MCPIntegrationTest.new.run_all_tests
+end

data/test/run_tests.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Test runner for MCP integration tests
+
+set -e
+
+echo "🧪 MCP Integration Test Runner"
+echo "=============================="
+
+# Change to project root
+cd "$(dirname "$0")/.."
+
+echo "📍 Working directory: $(pwd)"
+
+# Ensure bundle is available
+echo "📦 Checking bundle..."
+if ! command -v bundle &> /dev/null; then
+    echo "❌ Bundle not found. Please install bundler."
+    exit 1
+fi
+
+# Install dependencies
+echo "📥 Installing dependencies..."
+bundle install --quiet
+
+# Run smoke test first
+echo ""
+echo "🔥 Running smoke test..."
+bundle exec ruby test/smoke_test.rb
+
+# Run full integration tests
+echo ""
+echo "🚀 Running full integration tests..."
+bundle exec ruby test/integration_test.rb
+
+echo ""
+echo "✨ All tests completed successfully!"

data/test/smoke_test.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+puts "🔥 MCP Smoke Test"
+puts "=" * 30
+
+# Test 1: Basic server startup and tools list
+puts "\n1. Testing basic server startup..."
+
+stdout, stderr, status = Open3.capture3(
+  "npx", "@modelcontextprotocol/inspector",
+  "--cli", "./examples/mcp_server.sh",
+  "--method", "tools/list"
+)
+
+if status.success?
+  begin
+    data = JSON.parse(stdout)
+    tools = data["tools"]
+    puts "✅ Server started successfully"
+    puts "✅ Found #{tools.length} tools: #{tools.map { |t| t['name'] }.join(', ')}"
+  rescue JSON::ParserError => e
+    puts "❌ JSON parse error: #{e.message}"
+    puts "Raw output: #{stdout}"
+    exit 1
+  end
+else
+  puts "❌ Server failed to start"
+  puts "stderr: #{stderr}"
+  puts "stdout: #{stdout}"
+  exit 1
+end
+
+# Test 2: Simple tool call
+puts "\n2. Testing simple tool call..."
+
+stdout, stderr, status = Open3.capture3(
+  "npx", "@modelcontextprotocol/inspector",
+  "--cli", "./examples/mcp_server.sh",
+  "--method", "tools/call",
+  "--tool-name", "hammer"
+)
+
+if status.success?
+  begin
+    data = JSON.parse(stdout)
+    content = data["content"]
+    if content && content[0] && content[0]["text"]
+      puts "✅ Tool call successful"
+      puts "✅ Response: #{content[0]['text'].strip[0..100]}..."
+    else
+      puts "❌ No content in response"
+      exit 1
+    end
+  rescue JSON::ParserError => e
+    puts "❌ JSON parse error: #{e.message}"
+    exit 1
+  end
+else
+  puts "❌ Tool call failed"
+  puts "stderr: #{stderr}"
+  exit 1
+end
+
+puts "\n🎉 Smoke test passed! Ready for full integration tests."

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: mewmew
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Emde
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Load any Thor CLI directly as a StdIO MCP server
+email:
+- me@martinemde.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/example_cli.rb
+- examples/mcp_server.sh
+- lib/mewmew.rb
+- lib/mewmew/mcp_integration.rb
+- lib/mewmew/thor_introspector.rb
+- lib/mewmew/version.rb
+- sig/mewmew.rbs
+- test/integration_test.rb
+- test/run_tests.sh
+- test/smoke_test.rb
+homepage: https://github.com/martinemde/mewmew
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/martinemde/mewmew
+  source_code_uri: https://github.com/martinemde/mewmew
+  changelog_uri: https://github.com/martinemde/mewmew/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Make any thor command an MCP
+test_files: []