tsikol 0.1.0

data/lib/tsikol/lifecycle.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Tsikol
+  # Lifecycle management for servers
+  module Lifecycle
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def before_start(&block)
+        @before_start_hooks ||= []
+        @before_start_hooks << block if block_given?
+        @before_start_hooks
+      end
+      
+      def after_start(&block)
+        @after_start_hooks ||= []
+        @after_start_hooks << block if block_given?
+        @after_start_hooks
+      end
+      
+      def before_stop(&block)
+        @before_stop_hooks ||= []
+        @before_stop_hooks << block if block_given?
+        @before_stop_hooks
+      end
+      
+      def after_stop(&block)
+        @after_stop_hooks ||= []
+        @after_stop_hooks << block if block_given?
+        @after_stop_hooks
+      end
+    end
+    
+    # Instance methods
+    def run_before_start_hooks
+      log :debug, "Running before_start hooks"
+      
+      self.class.before_start.each do |hook|
+        instance_eval(&hook)
+      end
+      
+      @before_start_hooks&.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+    
+    def run_after_start_hooks
+      log :debug, "Running after_start hooks"
+      
+      self.class.after_start.each do |hook|
+        instance_eval(&hook)
+      end
+      
+      @after_start_hooks&.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+    
+    def run_before_stop_hooks
+      log :debug, "Running before_stop hooks"
+      
+      self.class.before_stop.each do |hook|
+        instance_eval(&hook)
+      end
+      
+      @before_stop_hooks&.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+    
+    def run_after_stop_hooks
+      log :debug, "Running after_stop hooks"
+      
+      self.class.after_stop.each do |hook|
+        instance_eval(&hook)
+      end
+      
+      @after_stop_hooks&.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+    
+    # DSL methods for instance-level hooks
+    def before_start(&block)
+      @before_start_hooks ||= []
+      @before_start_hooks << block
+    end
+    
+    def after_start(&block)
+      @after_start_hooks ||= []
+      @after_start_hooks << block
+    end
+    
+    def before_stop(&block)
+      @before_stop_hooks ||= []
+      @before_stop_hooks << block
+    end
+    
+    def after_stop(&block)
+      @after_stop_hooks ||= []
+      @after_stop_hooks << block
+    end
+    
+    # Tool-level hooks
+    def before_tool(name = nil, &block)
+      @before_tool_hooks ||= {}
+      if name
+        @before_tool_hooks[name] = block
+      else
+        @before_tool_hooks[:all] = block
+      end
+    end
+    
+    def after_tool(name = nil, &block)
+      @after_tool_hooks ||= {}
+      if name
+        @after_tool_hooks[name] = block
+      else
+        @after_tool_hooks[:all] = block
+      end
+    end
+    
+    def run_before_tool_hook(tool_name, params)
+      # Run specific hook
+      if @before_tool_hooks&.[](tool_name)
+        @before_tool_hooks[tool_name].call(params)
+      end
+      
+      # Run general hook
+      if @before_tool_hooks&.[](:all)
+        @before_tool_hooks[:all].call(tool_name, params)
+      end
+    end
+    
+    def run_after_tool_hook(tool_name, params, result)
+      # Run specific hook
+      if @after_tool_hooks&.[](tool_name)
+        @after_tool_hooks[tool_name].call(params, result)
+      end
+      
+      # Run general hook
+      if @after_tool_hooks&.[](:all)
+        @after_tool_hooks[:all].call(tool_name, params, result)
+      end
+    end
+  end
+end

data/lib/tsikol/middleware.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Tsikol
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+    
+    # Called before processing a request
+    def before_request(message)
+      # Default: pass through
+      message
+    end
+    
+    # Called after processing a response
+    def after_response(response, original_message)
+      # Default: pass through
+      response
+    end
+    
+    # Called on error
+    def on_error(error, message)
+      # Default: re-raise
+      raise error
+    end
+    
+    def call(message)
+      # Pre-process request
+      processed_message = before_request(message)
+      
+      # Call next middleware or handler
+      response = @app.call(processed_message)
+      
+      # Post-process response
+      after_response(response, message)
+    rescue => e
+      on_error(e, message)
+    end
+  end
+  
+  # Common middleware implementations
+  
+  class LoggingMiddleware < Middleware
+    def initialize(app, logger: nil)
+      super(app)
+      @logger = logger
+    end
+    
+    def before_request(message)
+      log :debug, "Request: #{message['method']}", data: { id: message['id'], params: message['params'] }
+      message
+    end
+    
+    def after_response(response, original_message)
+      if response
+        status = response['error'] ? 'error' : 'success'
+        log :debug, "Response for #{original_message['method']} (#{status})", 
+            data: { id: response['id'], error: response['error'] }
+      end
+      response
+    end
+    
+    def on_error(error, message)
+      log :error, "Error processing #{message['method']}: #{error.message}", 
+          data: { error: error.class.name, backtrace: error.backtrace.first(5) }
+      raise error
+    end
+    
+    private
+    
+    def log(level, message, data: nil)
+      if @logger && @logger.respond_to?(:log)
+        @logger.log(level, message, data: data)
+      else
+        puts "[#{level.upcase}] #{message} #{data ? "- #{data.inspect}" : ""}"
+      end
+    end
+  end
+  
+  class RateLimitMiddleware < Middleware
+    def initialize(app, max_requests: 100, window: 60)
+      super(app)
+      @max_requests = max_requests
+      @window = window
+      @requests = {}
+    end
+    
+    def before_request(message)
+      client_id = message["id"] # In real usage, identify client better
+      now = Time.now.to_i
+      
+      # Clean old entries
+      @requests.delete_if { |_, time| now - time > @window }
+      
+      # Check rate limit
+      client_requests = @requests.select { |id, _| id.to_s.start_with?(client_id.to_s[0..8]) }
+      if client_requests.size >= @max_requests
+        raise "Rate limit exceeded: #{@max_requests} requests per #{@window} seconds"
+      end
+      
+      # Track request
+      @requests[message["id"]] = now
+      
+      message
+    end
+  end
+  
+  class AuthenticationMiddleware < Middleware
+    def initialize(app, &auth_block)
+      super(app)
+      @auth_block = auth_block
+    end
+    
+    def before_request(message)
+      # Extract auth info (this is simplified - real auth would be more complex)
+      auth_info = message["metadata"] || {}
+      
+      unless @auth_block.call(auth_info, message)
+        raise "Authentication failed"
+      end
+      
+      message
+    end
+  end
+  
+  class ValidationMiddleware < Middleware
+    def before_request(message)
+      # Validate JSON-RPC structure
+      unless message["jsonrpc"] == "2.0"
+        raise "Invalid JSON-RPC version"
+      end
+      
+      unless message["method"]
+        raise "Missing method"
+      end
+      
+      message
+    end
+  end
+  
+  # Middleware stack manager
+  class MiddlewareStack
+    def initialize(base_handler)
+      @base_handler = base_handler
+      @middlewares = []
+    end
+    
+    def use(middleware_class, *args, **kwargs, &block)
+      @middlewares << [middleware_class, args, kwargs, block]
+      self
+    end
+    
+    def build
+      # Build middleware chain from inside out
+      @middlewares.reverse.reduce(@base_handler) do |app, (klass, args, kwargs, block)|
+        if block
+          klass.new(app, *args, **kwargs, &block)
+        else
+          klass.new(app, *args, **kwargs)
+        end
+      end
+    end
+    
+    def call(message)
+      build.call(message)
+    end
+  end
+end

data/lib/tsikol/prompt.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Tsikol
+  class Prompt
+    class << self
+      attr_reader :prompt_description, :arguments_config
+      
+      def description(desc)
+        @prompt_description = desc
+      end
+      
+      def argument(name, &block)
+        @arguments_config ||= {}
+        arg = ArgumentBuilder.new(name)
+        arg.instance_eval(&block) if block_given?
+        @arguments_config[name] = arg.build
+      end
+      
+      def prompt_name
+        # Convert class name to prompt name
+        # Weather::Chat -> weather:chat
+        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.prompt_description || "Prompt: #{self.class.prompt_name}"
+    end
+    
+    def arguments
+      self.class.arguments_config || {}
+    end
+    
+    def generate(**args)
+      raise NotImplementedError, "Subclasses must implement generate method"
+    end
+    
+    # Convert to MCP format
+    def to_mcp
+      {
+        name: self.class.prompt_name,
+        description: description,
+        arguments: build_arguments
+      }
+    end
+    
+    # Get messages for MCP prompt
+    def get_messages(**args)
+      content = generate(**args)
+      
+      [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: content
+          }
+        }
+      ]
+    end
+    
+    private
+    
+    def build_arguments
+      arguments.map do |name, config|
+        {
+          name: name.to_s,
+          description: config[:description] || "Argument: #{name}",
+          required: config[:required] || false
+        }
+      end
+    end
+  end
+  
+  class ArgumentBuilder
+    def initialize(name)
+      @name = name
+      @config = { name: name }
+    end
+    
+    def required(val = true)
+      @config[:required] = val
+    end
+    
+    def optional
+      @config[:required] = false
+    end
+    
+    def description(desc)
+      @config[:description] = desc
+    end
+    
+    def complete(&block)
+      @config[:completion] = block
+    end
+    
+    def build
+      @config
+    end
+  end
+end

data/lib/tsikol/resource.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Tsikol
+  class Resource
+    class << self
+      attr_reader :resource_description, :resource_uri, :resource_mime_type
+      
+      def uri(u)
+        @resource_uri = u
+      end
+      
+      def description(desc)
+        @resource_description = desc
+      end
+      
+      def mime_type(type)
+        @resource_mime_type = type
+      end
+      
+      def resource_name
+        # Convert class name to resource name
+        # Weather::Alerts -> weather/alerts
+        name.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      end
+    end
+    
+    def uri
+      self.class.resource_uri || self.class.resource_name
+    end
+    
+    def description
+      self.class.resource_description || "Resource: #{uri}"
+    end
+    
+    def mime_type
+      self.class.resource_mime_type || "text/plain"
+    end
+    
+    def read
+      raise NotImplementedError, "Subclasses must implement read method"
+    end
+    
+    # Convert to MCP format
+    def to_mcp
+      {
+        uri: uri,
+        name: uri,
+        description: description,
+        mimeType: mime_type
+      }
+    end
+  end
+end

data/lib/tsikol/router.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Tsikol
+  class Router
+    attr_reader :tools, :resources, :prompts, :server
+    
+    def initialize(server)
+      @server = server
+      @tools = {}
+      @resources = {}
+      @prompts = {}
+    end
+    
+    # DSL methods for routes.rb
+    def tool(name_or_class, from: nil, &block)
+      if name_or_class.is_a?(Class)
+        # Direct class reference: tool GetCurrentWeather
+        tool_instance = name_or_class.new
+        @server.register_tool_instance(tool_instance)
+      elsif from
+        # Load from file with explicit path
+        load_tool_from_file(name_or_class, from)
+      elsif name_or_class.is_a?(String) && !block_given?
+        # Auto-infer from name: tool "get_current_weather"
+        inferred_path = name_or_class.gsub('-', '_')
+        load_tool_from_file(name_or_class, inferred_path)
+      elsif block_given?
+        # Inline definition (backward compatibility)
+        @server.tool(name_or_class, &block)
+      end
+    end
+    
+    def resource(uri_or_class, from: nil, &block)
+      if uri_or_class.is_a?(Class)
+        # Direct class reference
+        resource_instance = uri_or_class.new
+        @server.register_resource_instance(resource_instance)
+      elsif from
+        # Load from file with explicit path
+        load_resource_from_file(uri_or_class, from)
+      elsif uri_or_class.is_a?(String) && !block_given?
+        # Auto-infer from URI: resource "weather/alerts" -> weather_alerts.rb
+        inferred_path = uri_or_class.gsub('/', '_').gsub('-', '_')
+        load_resource_from_file(uri_or_class, inferred_path)
+      elsif block_given?
+        # Inline definition
+        @server.resource(uri_or_class, &block)
+      end
+    end
+    
+    def prompt(name_or_class, from: nil, &block)
+      if name_or_class.is_a?(Class)
+        # Direct class reference
+        prompt_instance = name_or_class.new
+        @server.register_prompt_instance(prompt_instance)
+      elsif from
+        # Load from file with explicit path
+        load_prompt_from_file(name_or_class, from)
+      elsif name_or_class.is_a?(String) && !block_given?
+        # Auto-infer from name: prompt "weather_chat"
+        inferred_path = name_or_class.gsub('-', '_')
+        load_prompt_from_file(name_or_class, inferred_path)
+      elsif block_given?
+        # Inline definition
+        @server.prompt(name_or_class, &block)
+      end
+    end
+    
+    # Mount multiple items
+    def mount_tools(from:)
+      pattern = from.end_with?('/*') ? from : "#{from}/*"
+      base_path = "app/tools"
+      
+      Dir.glob("#{base_path}/#{pattern}.rb").each do |file|
+        # Extract name from file path
+        name = file.sub("#{base_path}/", '').sub('.rb', '')
+        load_tool_from_file(nil, name)
+      end
+    end
+    
+    def mount_resources(from:)
+      pattern = from.end_with?('/*') ? from : "#{from}/*"
+      base_path = "app/resources"
+      
+      Dir.glob("#{base_path}/#{pattern}.rb").each do |file|
+        uri = file.sub("#{base_path}/", '').sub('.rb', '')
+        load_resource_from_file(nil, uri)
+      end
+    end
+    
+    def mount_prompts(from:)
+      pattern = from.end_with?('/*') ? from : "#{from}/*"
+      base_path = "app/prompts"
+      
+      Dir.glob("#{base_path}/#{pattern}.rb").each do |file|
+        name = file.sub("#{base_path}/", '').sub('.rb', '')
+        load_prompt_from_file(nil, name)
+      end
+    end
+    
+    # Auto-discover all components
+    def auto_discover!
+      mount_tools(from: "**/*") if Dir.exist?("app/tools")
+      mount_resources(from: "**/*") if Dir.exist?("app/resources")
+      mount_prompts(from: "**/*") if Dir.exist?("app/prompts")
+    end
+    
+    private
+    
+    def load_tool_from_file(name, from)
+      file_path = "app/tools/#{from}.rb"
+      
+      # Try to require the file
+      begin
+        require_relative "../../../#{file_path}"
+      rescue LoadError
+        # If relative path fails, try absolute
+        require File.expand_path(file_path)
+      end
+      
+      # Convert file path to class name
+      # weather/get_current -> Weather::GetCurrent
+      class_name = from.split('/').map { |part| 
+        part.split('_').map(&:capitalize).join 
+      }.join('::')
+      
+      # Try to get the class
+      klass = begin
+        Object.const_get(class_name)
+      rescue NameError
+        # If namespaced class not found, try without namespace
+        class_name.split('::').last.then { |n| Object.const_get(n) }
+      end
+      
+      tool_instance = klass.new
+      
+      # Register with server
+      @server.register_tool_instance(tool_instance, name: name)
+    end
+    
+    def load_resource_from_file(uri, from)
+      file_path = "app/resources/#{from}.rb"
+      
+      begin
+        require_relative "../../../#{file_path}"
+      rescue LoadError
+        require File.expand_path(file_path)
+      end
+      
+      class_name = from.split('/').map { |part| 
+        part.split('_').map(&:capitalize).join 
+      }.join('::')
+      
+      klass = begin
+        Object.const_get(class_name)
+      rescue NameError
+        class_name.split('::').last.then { |n| Object.const_get(n) }
+      end
+      
+      resource_instance = klass.new
+      
+      @server.register_resource_instance(resource_instance, uri: uri)
+    end
+    
+    def load_prompt_from_file(name, from)
+      file_path = "app/prompts/#{from}.rb"
+      
+      begin
+        require_relative "../../../#{file_path}"
+      rescue LoadError
+        require File.expand_path(file_path)
+      end
+      
+      class_name = from.split('/').map { |part| 
+        part.split('_').map(&:capitalize).join 
+      }.join('::')
+      
+      klass = begin
+        Object.const_get(class_name)
+      rescue NameError
+        class_name.split('::').last.then { |n| Object.const_get(n) }
+      end
+      
+      prompt_instance = klass.new
+      
+      @server.register_prompt_instance(prompt_instance, name: name)
+    end
+  end
+  
+end