tsikol 0.1.0

data/lib/tsikol/stdio_transport.rb

@@ -0,0 +1,108 @@
+module Tsikol
+  class StdioTransport
+    def initialize(server)
+      @server = server
+      @server.set_transport(self)
+    end
+    
+    def send_notification(notification)
+      notification_json = notification.to_json
+      $stdout.puts(notification_json)
+      $stdout.flush
+    end
+    
+    def start
+      # Don't log to stderr during startup - MCP Inspector treats any stderr output as an error
+      
+      # Run lifecycle hooks
+      @server.run_before_start_hooks if @server.respond_to?(:run_before_start_hooks)
+      @server.run_after_start_hooks if @server.respond_to?(:run_after_start_hooks)
+      
+      # Set up signal handlers
+      setup_signal_handlers
+      
+      loop do
+        # Read a line from stdin
+        line = $stdin.gets
+        break unless line
+        
+        line = line.strip
+        next if line.empty?
+        
+        # Check if this is a Content-Length header or raw JSON
+        if line.start_with?('Content-Length:')
+          # Handle Content-Length format
+          headers = { 'content-length' => line.split(':', 2)[1].strip }
+          
+          # Read remaining headers
+          while header_line = $stdin.gets
+            header_line = header_line.strip
+            break if header_line.empty?
+            
+            key, value = header_line.split(': ', 2)
+            headers[key.downcase] = value if key && value
+          end
+          
+          # Read body based on content length
+          content_length = headers['content-length'].to_i
+          body = $stdin.read(content_length)
+        else
+          # Handle raw JSON format (what MCP Inspector sends)
+          body = line
+        end
+        
+        begin
+          # Log incoming message for debugging
+          File.open('/tmp/tsikol-debug.log', 'a') do |f|
+            f.puts "#{Time.now}: Received message: #{body}"
+          end
+          
+          # Process message and get response
+          response = @server.handle_message(body)
+          
+          # Only send response if not nil
+          if response
+            # Write response as plain JSON line (what MCP Inspector expects)
+            response_json = response.to_json
+            $stdout.puts(response_json)
+            $stdout.flush
+            
+            # Log response for debugging
+            File.open('/tmp/tsikol-debug.log', 'a') do |f|
+              f.puts "#{Time.now}: Sent response: #{response_json}"
+            end
+          end
+        rescue => e
+          # Log errors to stderr
+          $stderr.puts "Error: #{e.message}"
+          $stderr.puts e.backtrace.join("\n")
+        end
+      end
+    rescue EOFError
+      $stderr.puts "Connection closed"
+    rescue Interrupt
+      $stderr.puts "Server stopped"
+    ensure
+      shutdown
+    end
+    
+    private
+    
+    def setup_signal_handlers
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          $stderr.puts "Received #{signal} signal, shutting down..."
+          shutdown
+          exit(0)
+        end
+      end
+    end
+    
+    def shutdown
+      return unless @server.respond_to?(:run_before_stop_hooks)
+      
+      @server.run_before_stop_hooks
+      @server.run_after_stop_hooks
+    end
+  end
+end

data/lib/tsikol/test_helpers.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Tsikol
+  module TestHelpers
+    # Mock MCP client for testing servers
+    class TestClient
+      attr_reader :server, :responses, :notifications
+      
+      def initialize(server)
+        @server = server
+        @responses = []
+        @notifications = []
+        @request_id = 0
+        
+        # Capture notifications
+        if server.respond_to?(:set_transport)
+          server.set_transport(self)
+        end
+      end
+      
+      # Send notification (called by server)
+      def send_notification(notification)
+        @notifications << notification
+      end
+      
+      # Initialize connection
+      def initialize_connection(client_info = {})
+        request("initialize", {
+          protocolVersion: Tsikol::PROTOCOL_VERSION,
+          capabilities: client_info[:capabilities] || {},
+          clientInfo: {
+            name: client_info[:name] || "test-client",
+            version: client_info[:version] || "1.0.0"
+          }
+        })
+      end
+      
+      # Make a request to the server
+      def request(method, params = nil)
+        message = {
+          "jsonrpc" => "2.0",
+          "id" => next_id,
+          "method" => method
+        }
+        message["params"] = params if params
+        
+        response = @server.handle_message(message.to_json)
+        @responses << response
+        response
+      end
+      
+      # Call a tool
+      def call_tool(name, arguments = {})
+        request("tools/call", {
+          "name" => name,
+          "arguments" => arguments
+        })
+      end
+      
+      # Read a resource
+      def read_resource(uri)
+        request("resources/read", { "uri" => uri })
+      end
+      
+      # Get a prompt
+      def get_prompt(name, arguments = {})
+        request("prompts/get", {
+          "name" => name,
+          "arguments" => arguments
+        })
+      end
+      
+      # List available tools
+      def list_tools
+        request("tools/list")
+      end
+      
+      # List available resources
+      def list_resources
+        request("resources/list")
+      end
+      
+      # List available prompts
+      def list_prompts
+        request("prompts/list")
+      end
+      
+      # Get completion suggestions
+      def complete(ref, argument = nil)
+        params = { "ref" => ref }
+        params["argument"] = argument if argument
+        request("completion/complete", params)
+      end
+      
+      # Request sampling
+      def sample(messages, options = {})
+        params = {
+          "messages" => messages,
+          "modelPreferences" => options[:model_preferences] || {},
+          "systemPrompt" => options[:system_prompt],
+          "maxTokens" => options[:max_tokens]
+        }
+        request("sampling/createMessage", params)
+      end
+      
+      # Set logging level
+      def set_log_level(level)
+        request("logging/setLevel", { "level" => level })
+      end
+      
+      # Send ping
+      def ping
+        request("ping")
+      end
+      
+      # Get last response
+      def last_response
+        @responses.last
+      end
+      
+      # Get last notification
+      def last_notification
+        @notifications.last
+      end
+      
+      # Clear captured data
+      def clear!
+        @responses.clear
+        @notifications.clear
+      end
+      
+      private
+      
+      def next_id
+        @request_id += 1
+      end
+    end
+    
+    # RSpec matchers
+    module Matchers
+      # Check if response was successful
+      class BeSuccessful
+        def matches?(response)
+          response && !response[:error]
+        end
+        
+        def failure_message
+          "expected response to be successful, but got error: #{@response[:error]}"
+        end
+      end
+      
+      # Check if response has error
+      class HaveError
+        def initialize(code = nil, message = nil)
+          @expected_code = code
+          @expected_message = message
+        end
+        
+        def matches?(response)
+          return false unless response && response[:error]
+          
+          if @expected_code
+            return false unless response[:error][:code] == @expected_code
+          end
+          
+          if @expected_message
+            return false unless response[:error][:message].include?(@expected_message)
+          end
+          
+          true
+        end
+        
+        def failure_message
+          "expected response to have error #{@expected_code} with message containing '#{@expected_message}'"
+        end
+      end
+      
+      # Check if server has capability
+      class HaveCapability
+        def initialize(capability)
+          @capability = capability
+        end
+        
+        def matches?(server_or_response)
+          if server_or_response.is_a?(Hash)
+            # Response from initialize
+            capabilities = server_or_response.dig(:result, :capabilities) || {}
+          else
+            # Server instance
+            capabilities = server_or_response.instance_variable_get(:@server_capabilities) || {}
+          end
+          
+          capabilities.key?(@capability.to_sym) || capabilities.key?(@capability.to_s)
+        end
+        
+        def failure_message
+          "expected server to have capability :#{@capability}"
+        end
+      end
+      
+      def be_successful
+        BeSuccessful.new
+      end
+      
+      def have_error(code = nil, message = nil)
+        HaveError.new(code, message)
+      end
+      
+      def have_capability(capability)
+        HaveCapability.new(capability)
+      end
+    end
+    
+    # Test assertions
+    module Assertions
+      def assert_successful_response(response)
+        assert response && !response[:error], 
+               "Expected successful response, got: #{response.inspect}"
+      end
+      
+      def assert_error_response(response, code = nil, message_pattern = nil)
+        assert response && response[:error], 
+               "Expected error response, got: #{response.inspect}"
+        
+        if code
+          assert_equal code, response[:error][:code],
+                       "Expected error code #{code}, got: #{response[:error][:code]}"
+        end
+        
+        if message_pattern
+          assert_match message_pattern, response[:error][:message],
+                       "Expected error message to match #{message_pattern}"
+        end
+      end
+      
+      def assert_has_capability(server, capability)
+        capabilities = server.instance_variable_get(:@server_capabilities) || {}
+        assert capabilities.key?(capability.to_sym) || capabilities.key?(capability.to_s),
+               "Expected server to have capability :#{capability}"
+      end
+      
+      def assert_tool_result(client, tool_name, arguments, expected)
+        response = client.call_tool(tool_name, arguments)
+        assert_successful_response(response)
+        
+        result = response.dig(:result, :content, 0, :text)
+        assert_equal expected, result
+      end
+      
+      def assert_resource_content(client, uri, expected)
+        response = client.read_resource(uri)
+        assert_successful_response(response)
+        
+        content = response.dig(:result, :contents, 0, :text)
+        assert_equal expected, content
+      end
+    end
+  end
+end

data/lib/tsikol/tool.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Tsikol
+  class Tool
+    class << self
+      attr_reader :tool_description, :parameters_config
+      
+      def description(desc)
+        @tool_description = desc
+      end
+      
+      def parameter(name, &block)
+        @parameters_config ||= {}
+        param = ParameterBuilder.new(name)
+        param.instance_eval(&block) if block_given?
+        @parameters_config[name] = param.build
+      end
+      
+      def tool_name
+        # Convert class name to tool name
+        # Weather::GetCurrent -> weather:get_current
+        name.gsub('::', ':').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      end
+    end
+    
+    def description
+      self.class.tool_description || "Tool: #{self.class.tool_name}"
+    end
+    
+    def parameters
+      self.class.parameters_config || {}
+    end
+    
+    def execute(**args)
+      raise NotImplementedError, "Subclasses must implement execute method"
+    end
+    
+    # Convert to MCP format
+    def to_mcp
+      {
+        name: self.class.tool_name,
+        description: description,
+        inputSchema: build_input_schema
+      }
+    end
+    
+    private
+    
+    def build_input_schema
+      properties = {}
+      required = []
+      
+      parameters.each do |name, config|
+        properties[name.to_s] = {
+          type: config[:type].to_s,
+          description: config[:description]
+        }
+        
+        properties[name.to_s][:enum] = config[:enum] if config[:enum]
+        properties[name.to_s][:default] = config[:default] if config.key?(:default)
+        
+        required << name.to_s if config[:required]
+      end
+      
+      {
+        type: "object",
+        properties: properties,
+        required: required
+      }
+    end
+  end
+  
+  class ParameterBuilder
+    def initialize(name)
+      @name = name
+      @config = { name: name }
+    end
+    
+    def type(t)
+      @config[:type] = t
+    end
+    
+    def required(val = true)
+      @config[:required] = val
+    end
+    
+    def optional
+      @config[:required] = false
+    end
+    
+    def description(desc)
+      @config[:description] = desc
+    end
+    
+    def default(val)
+      @config[:default] = val
+    end
+    
+    def enum(values)
+      @config[:enum] = values
+    end
+    
+    def complete(&block)
+      @config[:completion] = block
+    end
+    
+    def build
+      @config
+    end
+  end
+end

data/lib/tsikol/version.rb

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

data/lib/tsikol.rb

@@ -0,0 +1,72 @@
+require 'json'
+require_relative 'tsikol/version'
+require_relative 'tsikol/server'
+require_relative 'tsikol/stdio_transport'
+require_relative 'tsikol/http_transport'
+require_relative 'tsikol/tool'
+require_relative 'tsikol/resource'
+require_relative 'tsikol/prompt'
+require_relative 'tsikol/router'
+require_relative 'tsikol/middleware'
+require_relative 'tsikol/error_handler'
+require_relative 'tsikol/lifecycle'
+require_relative 'tsikol/health'
+require_relative 'tsikol/cli' if defined?(Thor)
+
+module Tsikol
+
+  PROTOCOL_VERSION = "2025-06-18"
+
+  module Errors
+    PARSE_ERROR       = -32700
+    INVALID_REQUEST   = -32600
+    METHOD_NOT_FOUND  = -32601
+    INVALID_PARAMS    = -32602
+    INTERNAL_ERROR    = -32603
+  end
+
+  # For stdio transport (MCP Inspector, CLI tools)
+  def self.server(name, version: VERSION, &block)
+    server = Server.new(name: name, version: version)
+    server.instance_eval(&block) if block_given?
+
+    transport = StdioTransport.new(server)
+    transport.start
+  end
+  
+  # For HTTP transport (web services)
+  def self.http_server(name, version: VERSION, port: 4567, &block)
+    server = Server.new(name: name, version: version)
+    server.instance_eval(&block) if block_given?
+    
+    app = HttpTransport.new(server)
+    app.run! do |server|
+      server.port = port
+    end
+  end
+  
+  # New structure with routes file or inline routes
+  def self.start(name: nil, version: VERSION, transport: :stdio, &block)
+    # Determine server name
+    server_name = name || "tsikol-server"
+    
+    # Create server
+    server = Server.new(name: server_name, version: version)
+    
+    # Check if block contains route definitions
+    if block_given?
+      # Create a router and evaluate the block
+      router = Router.new(server)
+      router.instance_eval(&block)
+    end
+    
+    # Start transport
+    case transport
+    when :stdio
+      transport = StdioTransport.new(server)
+      transport.start
+    when :http
+      # TODO: HTTP transport
+    end
+  end
+end