tsikol 0.1.0

data/lib/tsikol/cli/templates/tool.rb.erb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class <%= @class_name %> < Tsikol::Tool
+  description "TODO: Add description for <%= @tool_name %>"
+  
+<% @parameters.each do |param| -%>
+  parameter :<%= param[:name] %> do
+    type :<%= param[:type] %>
+<% if param[:required] -%>
+    required
+<% else -%>
+    optional
+<% end -%>
+    description "TODO: Add description for <%= param[:name] %>"
+<% if param[:type] == 'string' -%>
+    
+    # Add completion for better UX
+    # complete do |partial|
+    #   # Return array of possible values
+    #   options = ["option1", "option2", "option3"]
+    #   options.select { |opt| opt.start_with?(partial) }
+    # end
+<% elsif param[:type] == 'enum' -%>
+    
+    # For enum types, add the allowed values
+    # enum ["option1", "option2", "option3"]
+    # 
+    # And optionally add completion
+    # complete do |partial|
+    #   self.enum_values.select { |val| val.start_with?(partial) }
+    # end
+<% end -%>
+  end
+  
+<% end -%>
+  def execute(<%= @parameters.map { |p| "#{p[:name]}:#{p[:required] ? '' : ' nil'}" }.join(', ') %>)
+    # TODO: Implement <%= @tool_name %> logic
+    log :info, "Executing <%= @tool_name %>" if respond_to?(:log)
+    
+<% if @parameters.any? -%>
+    # Access parameters
+<% @parameters.each do |param| -%>
+    # <%= param[:name] %> - <%= param[:type] %>
+<% end -%>
+    
+<% end -%>
+    "TODO: Return result"
+  end
+  
+  private
+  
+  def set_server(server)
+    @server = server
+    
+    # Enable logging
+    define_singleton_method(:log) do |level, message, data: nil, logger: nil|
+      @server.log(level, message, data: data, logger: logger)
+    end
+  end
+end

data/lib/tsikol/cli.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+require "erb"
+
+module Tsikol
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("../cli/templates", __FILE__)
+    end
+
+    desc "new PROJECT_NAME", "Create a new Tsikol MCP server project"
+    def new(project_name)
+      @project_name = project_name
+      @class_name = project_name.split(/[-_]/).map(&:capitalize).join
+
+      say "Creating new Tsikol project: #{project_name}", :green
+
+      # Create project directory
+      empty_directory project_name
+      
+      inside project_name do
+        # Create directories
+        empty_directory "app/tools"
+        empty_directory "app/resources"
+        empty_directory "app/prompts"
+        empty_directory "config"
+        empty_directory "test"
+
+        # Create files from templates
+        template "Gemfile.erb", "Gemfile"
+        template "server.rb.erb", "server.rb"
+        template "README.md.erb", "README.md"
+        template "gitignore.erb", ".gitignore"
+        
+        # Make server.rb executable
+        chmod "server.rb", 0755
+      end
+
+      say "\nProject created! Next steps:", :green
+      say "  cd #{project_name}"
+      say "  bundle install"
+      say "  ./server.rb"
+    end
+
+    desc "generate GENERATOR [args]", "Generate new components (aliases: g)"
+    map "g" => :generate
+
+    def generate(generator, name = nil, *args)
+      case generator
+      when "tool", "t"
+        generate_tool(name, *args)
+      when "resource", "r"
+        generate_resource(name, *args)
+      when "prompt", "p"
+        generate_prompt(name, *args)
+      else
+        say "Unknown generator: #{generator}", :red
+        say "Available generators: tool (t), resource (r), prompt (p)"
+      end
+    end
+
+    private
+
+    def generate_tool(name, *params)
+      unless name
+        say "Usage: tsikol generate tool NAME [param1:type param2:type ...]", :red
+        return
+      end
+
+      @tool_name = name
+      @class_name = name.split(/[-_]/).map(&:capitalize).join
+      @parameters = parse_parameters(params)
+
+      # Create tool file
+      file_path = "app/tools/#{name}.rb"
+      template "tool.rb.erb", file_path
+
+      # Update server.rb
+      update_server_file("tool", @class_name)
+
+      say "Generated tool: #{file_path}", :green
+      say "Added to server.rb: tool #{@class_name}", :green
+    end
+
+    def generate_resource(name, *args)
+      unless name
+        say "Usage: tsikol generate resource NAME", :red
+        return
+      end
+
+      @resource_name = name
+      @class_name = name.split(/[-_]/).map(&:capitalize).join
+      @uri = name.gsub('_', '/')
+
+      # Create resource file
+      file_path = "app/resources/#{name}.rb"
+      template "resource.rb.erb", file_path
+
+      # Update server.rb
+      update_server_file("resource", @class_name)
+
+      say "Generated resource: #{file_path}", :green
+      say "Added to server.rb: resource #{@class_name}", :green
+    end
+
+    def generate_prompt(name, *arguments)
+      unless name
+        say "Usage: tsikol generate prompt NAME [arg1:type arg2:type ...]", :red
+        return
+      end
+
+      @prompt_name = name
+      @class_name = name.split(/[-_]/).map(&:capitalize).join
+      @arguments = parse_parameters(arguments)
+
+      # Create prompt file
+      file_path = "app/prompts/#{name}.rb"
+      template "prompt.rb.erb", file_path
+
+      # Update server.rb
+      update_server_file("prompt", @class_name)
+
+      say "Generated prompt: #{file_path}", :green
+      say "Added to server.rb: prompt #{@class_name}", :green
+    end
+
+    def parse_parameters(params)
+      params.map do |param|
+        name, type = param.split(':')
+        type ||= 'string'
+        required = !name.include?('?')
+        name = name.gsub('?', '')
+        
+        {
+          name: name,
+          type: type,
+          required: required
+        }
+      end
+    end
+
+    def update_server_file(component_type, class_name)
+      server_file = "server.rb"
+      return unless File.exist?(server_file)
+
+      # Read current content
+      content = File.read(server_file)
+
+      # Add require statement if not present
+      require_path = "app/#{component_type}s/#{@tool_name || @resource_name || @prompt_name}"
+      require_line = "require_relative '#{require_path}'"
+      
+      unless content.include?(require_line)
+        # Insert require after other requires or at the beginning
+        if content =~ /^require_relative/
+          last_require_index = content.rindex(/^require_relative.*$/)
+          insert_position = content.index("\n", last_require_index) + 1
+        else
+          insert_position = content.index(/^Tsikol\.start/) || 0
+        end
+        
+        content.insert(insert_position, "#{require_line}\n")
+      end
+
+      # Add component to routes if not present
+      component_line = "  #{component_type} #{class_name}"
+      
+      unless content.include?(component_line)
+        # Find the Tsikol.start block
+        if match = content.match(/Tsikol\.start.*?\sdo\s*\n(.*?)\nend/m)
+          block_content = match[1]
+          
+          # Find where to insert (after last component of same type or before end)
+          lines = block_content.split("\n")
+          insert_index = -1
+          
+          lines.each_with_index do |line, i|
+            if line.strip.start_with?("#{component_type} ")
+              insert_index = i
+            end
+          end
+          
+          if insert_index >= 0
+            lines.insert(insert_index + 1, component_line)
+          else
+            # No components of this type yet, add at the beginning
+            lines.unshift(component_line)
+          end
+          
+          new_block = lines.join("\n")
+          content.sub!(block_content, new_block)
+        end
+      end
+
+      # Write updated content
+      File.write(server_file, content)
+    end
+  end
+end

data/lib/tsikol/error_handler.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Tsikol
+  # Enhanced error handling with context and recovery
+  class ErrorHandler
+    def initialize(server)
+      @server = server
+      @error_counts = Hash.new(0)
+      @circuit_breakers = {}
+    end
+    
+    def handle_error(error, context = {})
+      error_key = "#{context[:method]}:#{error.class.name}"
+      @error_counts[error_key] += 1
+      
+      # Log with context
+      @server.log :error, "Error in #{context[:method]}", 
+        data: {
+          error: error.class.name,
+          message: error.message,
+          context: context,
+          count: @error_counts[error_key],
+          backtrace: error.backtrace&.first(5)
+        }
+      
+      # Check circuit breaker
+      if should_circuit_break?(error_key)
+        raise CircuitBreakerOpen, "Circuit breaker open for #{context[:method]}"
+      end
+      
+      # Determine error response
+      case error
+      when ValidationError
+        [:invalid_params, error.message]
+      when AuthenticationError
+        [:invalid_request, "Authentication failed: #{error.message}"]
+      when RateLimitError
+        [:invalid_request, "Rate limit exceeded: #{error.message}"]
+      when CircuitBreakerOpen
+        [:internal_error, error.message]
+      when NotImplementedError
+        [:method_not_found, "Method not implemented: #{error.message}"]
+      else
+        [:internal_error, sanitize_error_message(error)]
+      end
+    end
+    
+    def wrap_tool_execution(tool_name, &block)
+      circuit_breaker = circuit_breaker_for(tool_name)
+      
+      circuit_breaker.call do
+        block.call
+      end
+    rescue => e
+      handle_error(e, method: "tools/call", tool: tool_name)
+      raise
+    end
+    
+    private
+    
+    def should_circuit_break?(error_key)
+      # Simple circuit breaker: open after 5 errors in 60 seconds
+      recent_errors = @error_counts[error_key]
+      recent_errors >= 5
+    end
+    
+    def circuit_breaker_for(name)
+      @circuit_breakers[name] ||= CircuitBreaker.new(
+        name: name,
+        threshold: 5,
+        timeout: 60,
+        on_open: -> { @server.log :warning, "Circuit breaker opened for #{name}" }
+      )
+    end
+    
+    def sanitize_error_message(error)
+      # Don't expose internal details in production
+      if ENV['TSIKOL_ENV'] == 'production'
+        "Internal server error"
+      else
+        "#{error.class.name}: #{error.message}"
+      end
+    end
+  end
+  
+  # Simple circuit breaker implementation
+  class CircuitBreaker
+    def initialize(name:, threshold: 5, timeout: 60, on_open: nil)
+      @name = name
+      @threshold = threshold
+      @timeout = timeout
+      @on_open = on_open
+      @failures = 0
+      @last_failure_time = nil
+      @state = :closed
+    end
+    
+    def call(&block)
+      case @state
+      when :open
+        if Time.now - @last_failure_time > @timeout
+          @state = :half_open
+        else
+          raise CircuitBreakerOpen, "Circuit breaker is open for #{@name}"
+        end
+      end
+      
+      begin
+        result = block.call
+        # Success - reset on half-open
+        if @state == :half_open
+          @failures = 0
+          @state = :closed
+        end
+        result
+      rescue => e
+        record_failure
+        raise e
+      end
+    end
+    
+    private
+    
+    def record_failure
+      @failures += 1
+      @last_failure_time = Time.now
+      
+      if @failures >= @threshold
+        @state = :open
+        @on_open&.call
+      end
+    end
+  end
+  
+  # Custom error types
+  class TsikolError < StandardError; end
+  class ValidationError < TsikolError; end
+  class AuthenticationError < TsikolError; end
+  class RateLimitError < TsikolError; end
+  class CircuitBreakerOpen < TsikolError; end
+end

data/lib/tsikol/health.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Tsikol
+  # Health monitoring and metrics
+  module Health
+    def self.included(base)
+      base.class_eval do
+        attr_reader :metrics
+      end
+    end
+    
+    def initialize_health_monitoring
+      @metrics = Metrics.new
+      @start_time = Time.now
+      
+      # Add built-in health check resource
+      resource "health" do
+        health_status.to_json
+      end
+      
+      # Add detailed health check
+      resource "health/detailed" do
+        detailed_health_status.to_json
+      end
+      
+      # Add metrics endpoint
+      resource "metrics" do
+        @metrics.to_h.to_json
+      end
+    end
+    
+    def health_status
+      {
+        status: health_check_status,
+        timestamp: Time.now.iso8601,
+        uptime: Time.now - @start_time,
+        version: @version
+      }
+    end
+    
+    def detailed_health_status
+      health_status.merge(
+        checks: {
+          tools: check_tools_health,
+          resources: check_resources_health,
+          memory: check_memory_health,
+          error_rate: check_error_rate
+        },
+        metrics: {
+          requests_total: @metrics.get(:requests_total),
+          errors_total: @metrics.get(:errors_total),
+          active_requests: @metrics.get(:active_requests),
+          average_response_time: @metrics.average(:response_time)
+        }
+      )
+    end
+    
+    private
+    
+    def health_check_status
+      # Simple health logic
+      error_rate = calculate_error_rate
+      
+      if error_rate > 0.5
+        "unhealthy"
+      elsif error_rate > 0.1
+        "degraded"
+      else
+        "healthy"
+      end
+    end
+    
+    def check_tools_health
+      total = @tools.size + @tool_instances.size
+      {
+        total: total,
+        status: total > 0 ? "ok" : "no_tools"
+      }
+    end
+    
+    def check_resources_health
+      total = @resources.size + @resource_instances.size
+      {
+        total: total,
+        status: total > 0 ? "ok" : "no_resources"
+      }
+    end
+    
+    def check_memory_health
+      # Simple memory check (would be more sophisticated in production)
+      {
+        usage: "#{(GC.stat[:heap_live_slots] * 40.0 / 1024 / 1024).round(2)}MB",
+        status: "ok"
+      }
+    end
+    
+    def check_error_rate
+      error_rate = calculate_error_rate
+      {
+        rate: error_rate.round(3),
+        status: error_rate < 0.05 ? "ok" : "high"
+      }
+    end
+    
+    def calculate_error_rate
+      total = @metrics.get(:requests_total)
+      errors = @metrics.get(:errors_total)
+      
+      return 0.0 if total == 0
+      errors.to_f / total
+    end
+  end
+  
+  # Simple metrics collector
+  class Metrics
+    def initialize
+      @counters = Hash.new(0)
+      @gauges = {}
+      @histograms = Hash.new { |h, k| h[k] = [] }
+      @mutex = Mutex.new
+    end
+    
+    def increment(name, value = 1)
+      @mutex.synchronize do
+        @counters[name] += value
+      end
+    end
+    
+    def decrement(name, value = 1)
+      increment(name, -value)
+    end
+    
+    def set(name, value)
+      @mutex.synchronize do
+        @gauges[name] = value
+      end
+    end
+    
+    def record(name, value)
+      @mutex.synchronize do
+        @histograms[name] << value
+        # Keep only last 1000 values
+        @histograms[name] = @histograms[name].last(1000)
+      end
+    end
+    
+    def get(name)
+      @mutex.synchronize do
+        @counters[name] || @gauges[name] || 0
+      end
+    end
+    
+    def average(name)
+      @mutex.synchronize do
+        values = @histograms[name]
+        return 0 if values.empty?
+        values.sum.to_f / values.size
+      end
+    end
+    
+    def percentile(name, p)
+      @mutex.synchronize do
+        values = @histograms[name].sort
+        return 0 if values.empty?
+        
+        index = (values.size * p / 100.0).ceil - 1
+        values[index]
+      end
+    end
+    
+    def to_h
+      @mutex.synchronize do
+        {
+          counters: @counters.dup,
+          gauges: @gauges.dup,
+          histograms: @histograms.transform_values do |values|
+            {
+              count: values.size,
+              average: values.empty? ? 0 : values.sum.to_f / values.size,
+              p50: percentile_for_values(values, 50),
+              p95: percentile_for_values(values, 95),
+              p99: percentile_for_values(values, 99)
+            }
+          end
+        }
+      end
+    end
+    
+    private
+    
+    def percentile_for_values(values, p)
+      return 0 if values.empty?
+      sorted = values.sort
+      index = (sorted.size * p / 100.0).ceil - 1
+      sorted[index]
+    end
+  end
+end

data/lib/tsikol/http_transport.rb

@@ -0,0 +1,72 @@
+require 'sinatra/base'
+require 'json'
+
+module Tsikol
+  class HttpTransport < Sinatra::Base
+    set :logging, false
+    set :quiet, true
+    
+    def initialize(server)
+      super()
+      @server = server
+      @sessions = {}
+    end
+    
+    post '/mcp' do
+      headers['Access-Control-Allow-Origin'] = '*'
+      headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
+      headers['Access-Control-Allow-Headers'] = 'Content-Type, Accept'
+      
+      request_body = request.body.read
+      
+      response = @server.handle_message(request_body)
+      
+      content_type :json
+      response.to_json
+    end
+    
+    get '/mcp' do
+      headers['Content-Type'] = 'text/event-stream'
+      headers['Cache-Control'] = 'no-cache'
+      headers['Connection'] = 'keep-alive'
+      headers['Access-Control-Allow-Origin'] = '*'
+      
+      session_id = params['sessionId'] || SecureRandom.uuid
+      
+      stream do |out|
+        # Send initial connection event
+        out << "event: open\n"
+        out << "data: {\"sessionId\":\"#{session_id}\"}\n\n"
+        
+        # Store the session
+        @sessions[session_id] = { stream: out, queue: Queue.new }
+        
+        # Keep connection alive
+        EventMachine.add_periodic_timer(30) do
+          out << ":ping\n\n" rescue nil
+        end
+        
+        # Wait for messages to send
+        loop do
+          begin
+            message = @sessions[session_id][:queue].pop
+            out << "event: message\n"
+            out << "data: #{message.to_json}\n\n"
+          rescue => e
+            break
+          end
+        end
+        
+        # Clean up on disconnect
+        @sessions.delete(session_id)
+      end
+    end
+    
+    options '/mcp' do
+      headers['Access-Control-Allow-Origin'] = '*'
+      headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
+      headers['Access-Control-Allow-Headers'] = 'Content-Type, Accept'
+      200
+    end
+  end
+end