language-operator 0.0.1 → 0.1.31

data/lib/language_operator/config/tool_registry.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'net/http'
+require 'uri'
+
+module LanguageOperator
+  module Config
+    # Fetches and caches tool registry from remote URL
+    class ToolRegistry
+      REGISTRY_URL = 'https://raw.githubusercontent.com/language-operator/language-tools/main/index.yaml'
+      CACHE_TTL = 3600 # 1 hour
+
+      def initialize(registry_url: REGISTRY_URL, api_token: nil)
+        @registry_url = registry_url
+        @api_token = api_token || ENV.fetch('GITHUB_TOKEN', nil)
+        @cache = nil
+        @cache_time = nil
+      end
+
+      # Fetch tools from registry with caching
+      #
+      # @return [Hash] Tool configurations keyed by tool name
+      def fetch
+        # Return cached data if still valid
+        return @cache if @cache && @cache_time && (Time.now - @cache_time) < CACHE_TTL
+
+        # Fetch from remote
+        begin
+          tools = fetch_remote
+          @cache = tools
+          @cache_time = Time.now
+          tools
+        rescue StandardError => e
+          # Fall back to local file if remote fetch fails
+          warn "Failed to fetch remote registry: #{e.message}"
+          warn 'Falling back to local registry'
+          fetch_local
+        end
+      end
+
+      # Clear the cache to force a fresh fetch
+      def clear_cache
+        @cache = nil
+        @cache_time = nil
+      end
+
+      private
+
+      def fetch_remote
+        uri = URI(@registry_url)
+        response = fetch_with_redirects(uri, limit: 5)
+
+        raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+        # Parse YAML response
+        data = YAML.safe_load(response.body)
+
+        # Extract tools from nested structure
+        data['tools'] || {}
+      end
+
+      def fetch_with_redirects(uri, limit: 5)
+        raise 'Too many HTTP redirects' if limit.zero?
+
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "token #{@api_token}" if @api_token
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+
+        case response
+        when Net::HTTPSuccess
+          response
+        when Net::HTTPRedirection
+          location = response['location']
+          # Handle relative redirects by merging with current URI
+          new_uri = uri.merge(location)
+          # Preserve authorization for same host
+          fetch_with_redirects(new_uri, limit: limit - 1)
+        else
+          response
+        end
+      end
+
+      def fetch_local
+        # Fall back to bundled local registry
+        patterns_path = File.join(__dir__, 'tool_patterns.yaml')
+        return {} unless File.exist?(patterns_path)
+
+        YAML.load_file(patterns_path)
+      end
+    end
+  end
+end

data/lib/language_operator/config.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  # Configuration loading helpers for environment variables
+  #
+  # Provides utilities for loading, validating, and type-converting
+  # configuration from environment variables with support for:
+  # - Key-to-env-var mappings
+  # - Prefixes (e.g., SMTP_HOST from prefix: 'SMTP')
+  # - Default values
+  # - Type conversion (string, integer, boolean, float)
+  # - Required config validation
+  #
+  # @example Load SMTP configuration
+  #   config = LanguageOperator::Config.load(
+  #     { host: 'HOST', port: 'PORT', user: 'USER', password: 'PASSWORD' },
+  #     prefix: 'SMTP',
+  #     required: [:host, :user, :password],
+  #     defaults: { port: '587', tls: 'true' },
+  #     types: { port: :integer, tls: :boolean }
+  #   )
+  #   # => { host: "smtp.example.com", port: 587, user: "user@example.com",
+  #   #      password: "secret", tls: true }
+  module Config
+    # Load configuration from environment variables
+    #
+    # @param mappings [Hash{Symbol => String}] Map of config keys to env var names
+    # @param prefix [String, nil] Optional prefix to prepend to env var names
+    # @param defaults [Hash{Symbol => Object}] Default values for optional config
+    # @param types [Hash{Symbol => Symbol}] Type conversion (:string, :integer, :boolean, :float)
+    # @return [Hash{Symbol => Object}] Configuration hash with values from env vars or defaults
+    #
+    # @example Basic usage
+    #   config = Config.from_env(
+    #     { database_url: 'DATABASE_URL' },
+    #     defaults: { database_url: 'sqlite://localhost/db.sqlite3' }
+    #   )
+    #
+    # @example With prefix and types
+    #   config = Config.from_env(
+    #     { host: 'HOST', port: 'PORT' },
+    #     prefix: 'REDIS',
+    #     defaults: { port: '6379' },
+    #     types: { port: :integer }
+    #   )
+    #   # Reads REDIS_HOST and REDIS_PORT env vars
+    def self.from_env(mappings, prefix: nil, defaults: {}, types: {})
+      config = {}
+
+      mappings.each do |key, env_var|
+        full_var = prefix ? "#{prefix}_#{env_var}" : env_var
+        raw_value = ENV[full_var] || defaults[key]
+
+        config[key] = convert_type(raw_value, types[key] || :string)
+      end
+
+      config
+    end
+
+    # Validate that required configuration keys are present and non-empty
+    #
+    # @param config [Hash] Configuration hash
+    # @param required_keys [Array<Symbol>] Keys that must be present
+    # @raise [RuntimeError] If any required keys are missing or empty
+    #
+    # @example
+    #   Config.validate_required!(config, [:host, :user, :password])
+    def self.validate_required!(config, required_keys)
+      missing = required_keys.select { |key| config[key].nil? || config[key].to_s.strip.empty? }
+      return if missing.empty?
+
+      raise LanguageOperator::Errors.missing_config(missing.map(&:to_s).map(&:upcase))
+    end
+
+    # Convert a string value to the specified type
+    #
+    # @param value [String, nil] Raw string value from environment
+    # @param type [Symbol] Target type (:string, :integer, :boolean, :float)
+    # @return [Object] Converted value
+    #
+    # @example String conversion
+    #   Config.convert_type('hello', :string) # => "hello"
+    #
+    # @example Integer conversion
+    #   Config.convert_type('42', :integer) # => 42
+    #
+    # @example Boolean conversion
+    #   Config.convert_type('true', :boolean) # => true
+    #   Config.convert_type('1', :boolean) # => true
+    #   Config.convert_type('yes', :boolean) # => true
+    #   Config.convert_type('false', :boolean) # => false
+    #
+    # @example Float conversion
+    #   Config.convert_type('3.14', :float) # => 3.14
+    def self.convert_type(value, type)
+      return nil if value.nil?
+
+      case type
+      when :string
+        value.to_s
+      when :integer
+        value.to_i
+      when :float
+        value.to_f
+      when :boolean
+        %w[true 1 yes on].include?(value.to_s.downcase)
+      else
+        value
+      end
+    end
+
+    # Load configuration with validation in one call
+    #
+    # Combines from_env and validate_required! for convenience.
+    #
+    # @param mappings [Hash] Config key to env var mappings
+    # @param required [Array<Symbol>] Required config keys
+    # @param defaults [Hash] Default values
+    # @param types [Hash] Type conversions
+    # @param prefix [String, nil] Env var prefix
+    # @return [Hash] Validated configuration
+    # @raise [RuntimeError] If required keys are missing
+    #
+    # @example Complete configuration loading
+    #   config = Config.load(
+    #     { host: 'HOST', port: 'PORT', user: 'USER', password: 'PASSWORD' },
+    #     prefix: 'SMTP',
+    #     required: [:host, :user, :password],
+    #     defaults: { port: '587' },
+    #     types: { port: :integer }
+    #   )
+    def self.load(mappings, required: [], defaults: {}, types: {}, prefix: nil)
+      config = from_env(mappings, prefix: prefix, defaults: defaults, types: types)
+      validate_required!(config, required) unless required.empty?
+      config
+    end
+  end
+end

data/lib/language_operator/dsl/adapter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module LanguageOperator
+  module Dsl
+    # Adapter to bridge our DSL to the official MCP Ruby SDK
+    #
+    # Converts LanguageOperator::Dsl::ToolDefinition objects into MCP::Tool classes
+    # that can be used with the official MCP Ruby SDK.
+    #
+    # @example Convert a tool definition
+    #   tool_class = Adapter.tool_definition_to_mcp_tool(tool_def)
+    #   server = MCP::Server.new(tools: [tool_class])
+    class Adapter
+      # Convert our ToolDefinition to an MCP::Tool class
+      def self.tool_definition_to_mcp_tool(tool_def)
+        # Build input schema from our parameter definitions
+        schema = build_input_schema(tool_def.parameters)
+
+        # Create a dynamic class that extends MCP::Tool
+        Class.new(MCP::Tool) do
+          # Set the tool name
+          define_singleton_method(:name) { tool_def.name }
+
+          # Set the description
+          description tool_def.description
+
+          # Set input schema
+          input_schema(schema)
+
+          # Define the call method
+          define_singleton_method(:call) do |server_context: {}, **args|
+            # Convert args to string keys to match our DSL expectations
+            params = args.transform_keys(&:to_s)
+
+            # Execute the tool using our DSL
+            result = tool_def.call(params)
+
+            # Convert result to MCP::Tool::Response
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: result.to_s }
+                                    ])
+          rescue ArgumentError => e
+            # Return error as text response
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: "Error: #{e.message}" }
+                                    ])
+          rescue StandardError => e
+            # Return error as text response
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: "Error: #{e.message}" }
+                                    ])
+          end
+        end
+      end
+
+      # Build MCP input schema from our parameter definitions
+      def self.build_input_schema(parameters)
+        properties = {}
+        required = []
+
+        parameters.each do |name, param_def|
+          properties[name.to_sym] = build_parameter_schema(param_def)
+          required << name if param_def.required
+        end
+
+        schema = { properties: properties }
+        schema[:required] = required unless required.empty?
+        schema
+      end
+
+      # Build schema for a single parameter
+      def self.build_parameter_schema(param_def)
+        # Access instance variables directly since the DSL methods are setters
+        param_type = param_def.instance_variable_get(:@type)
+        param_desc = param_def.instance_variable_get(:@description)
+        param_enum = param_def.instance_variable_get(:@enum)
+        param_default = param_def.instance_variable_get(:@default)
+
+        schema = {
+          type: map_type(param_type),
+          description: param_desc || '' # MCP requires description to be a string
+        }
+
+        schema[:enum] = param_enum if param_enum
+        schema[:default] = param_default if param_default
+
+        schema
+      end
+
+      # Map our type symbols to JSON schema types
+      def self.map_type(ruby_type)
+        case ruby_type
+        when :string then 'string'
+        when :number, :integer then 'number'
+        when :boolean then 'boolean'
+        when :array then 'array'
+        when :object then 'object'
+        else 'string'
+        end
+      end
+
+      # Convert a registry of tools to MCP::Tool classes
+      def self.registry_to_mcp_tools(registry)
+        registry.all.map do |tool_def|
+          tool_definition_to_mcp_tool(tool_def)
+        end
+      end
+
+      # Create an MCP::Server from our registry
+      def self.create_mcp_server(registry, server_name: 'langop-mcp', server_context: {})
+        tools = registry_to_mcp_tools(registry)
+
+        MCP::Server.new(
+          name: server_name,
+          version: LanguageOperator::VERSION,
+          tools: tools,
+          server_context: server_context
+        )
+      end
+    end
+  end
+end

data/lib/language_operator/dsl/agent_context.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Dsl
+    # DSL context for defining agents
+    #
+    # Provides the evaluation context for agent definition files. Agents are
+    # defined using the `agent` method within this context.
+    #
+    # @example Agent definition file
+    #   agent "news-summarizer" do
+    #     description "Daily news summarization"
+    #
+    #     schedule "0 12 * * *"
+    #
+    #     objectives [
+    #       "Search for recent news",
+    #       "Summarize findings"
+    #     ]
+    #
+    #     workflow do
+    #       step :search, tool: "web_search"
+    #       step :summarize, depends_on: :search
+    #     end
+    #   end
+    class AgentContext
+      # Initialize context with registry
+      #
+      # @param registry [LanguageOperator::Dsl::AgentRegistry] Agent registry
+      def initialize(registry)
+        @registry = registry
+      end
+
+      # Define an agent
+      #
+      # @param name [String] Agent name
+      # @yield Agent definition block
+      # @return [void]
+      def agent(name, &)
+        agent_def = AgentDefinition.new(name)
+        agent_def.instance_eval(&) if block_given?
+        @registry.register(agent_def)
+      end
+    end
+
+    # Registry for agents (similar to tool registry)
+    class AgentRegistry
+      def initialize
+        @agents = {}
+      end
+
+      # Register an agent
+      #
+      # @param agent_def [AgentDefinition] Agent definition
+      # @return [void]
+      def register(agent_def)
+        @agents[agent_def.name] = agent_def
+      end
+
+      # Get an agent by name
+      #
+      # @param name [String] Agent name
+      # @return [AgentDefinition, nil] Agent definition
+      def get(name)
+        @agents[name.to_s]
+      end
+
+      # Get all agents
+      #
+      # @return [Array<AgentDefinition>] All registered agents
+      def all
+        @agents.values
+      end
+
+      # Clear all agents
+      #
+      # @return [void]
+      def clear
+        @agents.clear
+      end
+
+      # Get count of registered agents
+      #
+      # @return [Integer] Number of agents
+      def count
+        @agents.size
+      end
+    end
+  end
+end