legate 0.1.0

data/lib/legate/cli/tool_commands.rb

@@ -0,0 +1,261 @@
+# File: lib/legate/cli/tool_commands.rb
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'base_command'
+require_relative 'output_helper' # OutputHelper is included below
+require_relative '../global_tool_manager' # Require the global manager
+require_relative '../tool_context' # <--- ADDED require
+require 'securerandom' # <-- ADDED require for dummy context
+
+module Legate
+  module CLI
+    # CLI commands for tool management using ToolRegistry
+    class ToolCommands < BaseCommand
+      include OutputHelper
+
+      desc 'list', 'List available tools from the registry'
+      method_option :json, type: :boolean, default: false,
+                           desc: 'Output result in JSON format'
+      def list
+        tools = Legate::GlobalToolManager.list_all_tools
+        if json_mode?
+          puts JSON.generate({ tools: tools.map { |t| { name: t[:name].to_s, description: t[:description] } } })
+        elsif tools.empty?
+          say 'No tools registered.'
+        else
+          say 'Available tools:', :bold
+          tools.each do |tool_info|
+            say "- #{tool_info[:name]}: #{tool_info[:description]}"
+          end
+        end
+      end
+
+      desc 'info NAME', 'Show information about a tool from the registry'
+      def info(name)
+        tool_name_sym = name.to_sym
+        tool = Legate::GlobalToolManager.create_instance(tool_name_sym) # Create instance to get params
+
+        if tool
+          say "Tool: #{tool.name}"
+          say "Description: #{tool.description}"
+          if tool.parameters.empty?
+            say "\nParameters: None"
+          else
+            say "\nParameters:"
+            tool.parameters.each do |param_name, param_info|
+              required = param_info[:required] ? 'required' : 'optional'
+              type = param_info[:type] || 'any'
+              say "  - #{param_name} (#{type}, #{required})"
+              say "    #{param_info[:description]}"
+            end
+          end
+        else
+          say "Tool '#{name}' not found in registry.", :red
+        end
+      end
+
+      desc 'execute NAME [param1=value1 param2=value2 ...]', 'Execute a tool directly using key=value arguments'
+      long_desc <<-LONGDESC
+      Executes a specified tool directly with key=value pair arguments.
+
+      Example:
+        legate tool execute calculator operand1=10 operand2=5 operation=add
+
+      Arguments should be provided as `key=value`. If a value contains spaces,
+      it might need quoting depending on your shell.
+
+      If the tool execution results in a :pending status (e.g., for an async job),
+      the job_id will be printed. Use the check_job_status tool
+      in a subsequent call to get the final result.
+      LONGDESC
+      method_option :quiet, type: :boolean, default: false, aliases: '-q',
+                            desc: 'Suppress status messages, only output result'
+      method_option :json, type: :boolean, default: false,
+                           desc: 'Output result in JSON format (implies --quiet)'
+      method_option :user_id, type: :string, default: 'cli_user', desc: 'User ID for the tool context'
+      def execute(name, *args)
+        # Suppress all logging in JSON mode for clean output
+        Legate.logger.level = Logger::FATAL if json_mode?
+
+        tool_name_sym = name.to_sym
+        tool = Legate::GlobalToolManager.create_instance(tool_name_sym)
+
+        unless tool
+          output_error("Tool '#{name}' not found in registry.", metadata: { tool: name })
+          exit(1)
+        end
+
+        params_to_execute = {}
+        valid_param_names = tool.parameters.keys.map(&:to_s)
+
+        args.each do |arg|
+          parts = arg.split('=', 2)
+          if parts.length == 2
+            key = parts[0].strip
+            value = parts[1]
+
+            unless valid_param_names.include?(key)
+              status_message("Warning: Provided parameter '#{key}' is not defined for tool '#{name}'. Ignoring.", :yellow)
+              next
+            end
+
+            params_to_execute[key.to_sym] = value # Store as symbol key
+            status_message("  Parsed: #{key} = '#{value}'")
+          elsif args.length == 1 && tool.parameters.length == 1 && tool.parameters.values.first[:required]
+            # Simplified single arg handling
+            single_key = tool.parameters.keys.first
+            status_message("Info: Assuming single argument '#{arg}' maps to required parameter '#{single_key}'.", :cyan)
+            params_to_execute[single_key] = arg
+          elsif !args.empty?
+            status_message("Warning: Argument '#{arg}' ignored. Please use 'key=value' format for parameters.", :yellow)
+          end
+        end
+
+        begin
+          status_message("Executing tool '#{name}' with parsed params: #{params_to_execute.inspect}")
+          # --- Create a dummy context for direct tool execution ---
+          dummy_context = Legate::ToolContext.new(session_id: "cli_direct_#{SecureRandom.hex(4)}", user_id: options[:user_id],
+                                                  app_name: 'cli_tool_exec')
+
+          # --- Call execute with context ---
+          result_hash = tool.execute(params_to_execute, dummy_context)
+
+          status_message("\nResult:", :bold)
+          output_result(result_hash, metadata: { tool: name }, format_method: :format_tool_result)
+        rescue Legate::Error, ArgumentError => e
+          output_error(e, metadata: { tool: name })
+          exit(1)
+        rescue StandardError => e
+          output_error(e, metadata: { tool: name })
+          puts e.backtrace.first(5).join("\n") unless json_mode?
+          exit(1)
+        end
+      end # end execute
+
+      no_commands do
+        # Format tool result in human-readable format
+        def format_tool_result(result_hash)
+          if result_hash.is_a?(Hash) && result_hash.key?(:status)
+            case result_hash[:status]
+            when :success
+              say 'Success:', :green
+              say "  Output: #{result_hash[:result]}"
+            when :pending
+              say 'Pending:', :yellow
+              say "  Job ID: #{result_hash[:job_id]}"
+              say "  Message: #{result_hash[:message]}" if result_hash[:message]
+            when :error
+              say 'Error:', :red
+              say "  Message: #{result_hash[:error_message]}"
+            else
+              say 'Unknown Status:', :yellow
+              say "  Data: #{result_hash.inspect}"
+            end
+          else
+            say 'Unknown Result Format:', :yellow
+            say "  Data: #{result_hash.inspect}"
+          end
+        end
+      end
+
+      desc 'ai_generate', 'Generate tool class code using AI from a natural language description'
+      long_desc <<-LONGDESC
+        Uses AI (Gemini LLM) to generate a production-ready tool class based on
+        your natural language description. The AI automatically determines if the
+        tool should be a simple tool, HTTP API tool, or async tool.
+
+        Input sources (in priority order):
+          1. --description / -d : Inline description
+          2. --prompt-file / -f : Read description from a file
+          3. stdin : Pipe description via stdin (auto-enables stdout output)
+
+        Output destinations:
+          - Default: Writes to ./<suggested_name>.rb
+          - --output / -o : Custom output file path
+          - --stdout : Output to stdout instead of file
+          - When reading from stdin: Auto-outputs to stdout
+
+        Examples:
+          legate tool ai_generate -d "A tool that converts temperatures between Celsius and Fahrenheit"
+          legate tool ai_generate -d "A tool that checks if a URL is reachable" -o ./tools/url_checker.rb
+          echo "A calculator that adds two numbers" | legate tool ai_generate
+          echo "A weather API tool" | legate tool ai_generate > weather_tool.rb
+
+        Requires GOOGLE_API_KEY environment variable to be set.
+      LONGDESC
+      method_option :description, aliases: '-d', type: :string, desc: 'Description of the tool to generate'
+      method_option :prompt_file, aliases: '-f', type: :string, desc: 'Read description from a file'
+      method_option :output, aliases: '-o', type: :string, desc: 'Output file path (default: ./<suggested_name>.rb)'
+      method_option :stdout, type: :boolean, default: false, desc: 'Output to stdout instead of file'
+      method_option :force, type: :boolean, default: false, desc: 'Overwrite existing file without prompting'
+      def ai_generate
+        require_relative '../generators'
+
+        description = nil
+        from_stdin = false
+
+        # Priority: --description > --prompt-file > stdin
+        if options[:description] && !options[:description].strip.empty?
+          description = options[:description].strip
+        elsif options[:prompt_file]
+          unless File.exist?(options[:prompt_file])
+            say "Error: Prompt file '#{options[:prompt_file]}' not found.", :red
+            exit(1)
+          end
+          description = File.read(options[:prompt_file]).strip
+        elsif !$stdin.tty?
+          # Reading from stdin (piped input)
+          description = $stdin.read.strip
+          from_stdin = true
+        end
+
+        if description.nil? || description.empty?
+          say 'Error: No description provided. Use --description, --prompt-file, or pipe via stdin.', :red
+          exit(1)
+        end
+
+        # Determine output mode
+        output_to_stdout = options[:stdout] || from_stdin
+
+        say 'Generating tool code via AI...', :cyan unless output_to_stdout
+
+        begin
+          result = Legate::Generators::ToolGenerator.generate(description: description)
+          code = result[:code]
+          suggested_name = result[:suggested_name]
+          tool_type = result[:tool_type]
+
+          if output_to_stdout
+            puts code
+          else
+            # Write to file
+            file_path = options[:output] || "./#{suggested_name}.rb"
+
+            if File.exist?(file_path) && !options[:force] && !yes?("File '#{file_path}' already exists. Overwrite? [y/N]", :yellow)
+              say 'Generation cancelled.', :yellow
+              exit(0)
+            end
+
+            File.write(file_path, code)
+            say "Tool code generated and saved to '#{file_path}'", :green
+            say "  Suggested name: #{suggested_name}", :cyan
+            say "  Tool type: #{tool_type}", :cyan
+          end
+        rescue Legate::Generators::ToolGenerator::ApiKeyMissingError => e
+          say "Error: #{e.message}", :red
+          exit(1)
+        rescue Legate::Generators::ToolGenerator::ApiError => e
+          say "Error: #{e.message}", :red
+          exit(1)
+        rescue Legate::Generators::ToolGenerator::GenerationError => e
+          say "Error: #{e.message}", :red
+          exit(1)
+        rescue StandardError => e
+          say "Unexpected error: #{e.class} - #{e.message}", :red
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/legate/cli/web_commands.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'rack' # Required for Rack::Builder
+require 'rack/handler/puma' # Use Rack::Handler for Rack 2.x compatibility
+require_relative '../web' # Loads the web UI (and core, if not already loaded)
+require_relative 'base_command'
+# Webhook listener required conditionally below
+
+module Legate
+  module CLI
+    # CLI commands for web interface
+    class WebCommands < BaseCommand
+      # Conventional directories to scan for custom tools and agents
+      TOOL_DIRECTORIES = [
+        'lib/tools',
+        'agents/lib/tools',
+        'tools'
+      ].freeze
+
+      AGENT_DIRECTORIES = [
+        'lib/agents',
+        'agents/lib/agents',
+        'agents'
+      ].freeze
+
+      # Optional initializer file that runs before auto-loading
+      INIT_FILES = [
+        'legate_init.rb',
+        'config/legate_init.rb',
+        'agents/legate_init.rb'
+      ].freeze
+
+      desc 'start', 'Start the web interface'
+      method_option :port, type: :numeric, default: 4567, desc: 'Port to listen on'
+      method_option :host, type: :string, default: 'localhost', desc: 'Host to bind to'
+      method_option :no_autoload, type: :boolean, default: false, desc: 'Disable auto-loading of custom tools and agents'
+      def start
+        # Auto-load custom tools and agents unless disabled
+        unless options[:no_autoload]
+          load_custom_initializer
+          load_custom_tools
+          load_custom_agents
+        end
+
+        # Access config early
+        webhook_config = Legate.config.webhooks
+        listener_enabled = webhook_config.listener_enabled
+        listener_base_path = webhook_config.base_path
+
+        # Build the Rack application stack
+        app = Rack::Builder.new do
+          # Conditionally mount the Webhook Listener
+          if listener_enabled
+            Legate.logger.info "Webhook listener enabled, mounting at #{listener_base_path}"
+            begin
+              require_relative '../web/webhook_listener'
+              map listener_base_path do
+                run Legate::Web::WebhookListener.new
+              end
+            rescue LoadError => e
+              Legate.logger.error "Failed to load WebhookListener: #{e.message}. Listener will not be mounted."
+            rescue StandardError => e
+              Legate.logger.error "Error initializing WebhookListener: #{e.message}. Listener will not be mounted."
+            end
+          else
+            Legate.logger.debug 'Webhook listener is disabled.'
+          end
+
+          # Mount the main Legate Web App at the root
+          run Legate::Web::App.new
+        end.to_app # Convert builder block to a Rack app
+
+        # Start the server using Rack::Handler::Puma (Rack 2.x compatible)
+        say "Starting Legate web interface on http://#{options[:host]}:#{options[:port]}"
+        Rack::Handler::Puma.run(
+          app,
+          Host: options[:host],
+          Port: options[:port],
+          Silent: false
+        )
+      end
+
+      private
+
+      # Load optional initializer file if present
+      def load_custom_initializer
+        INIT_FILES.each do |init_file|
+          full_path = File.expand_path(init_file, Dir.pwd)
+          next unless File.exist?(full_path)
+
+          Legate.logger.info "Loading custom initializer: #{full_path}"
+          begin
+            require full_path
+            Legate.logger.info "Successfully loaded initializer: #{init_file}"
+            break # Only load the first one found
+          rescue LoadError, StandardError => e
+            Legate.logger.error "Error loading initializer #{init_file}: #{e.class} - #{e.message}"
+            Legate.logger.debug e.backtrace.first(5).join("\n") if e.backtrace
+          end
+        end
+      end
+
+      # Auto-discover and load custom tools from conventional directories
+      def load_custom_tools
+        tools_loaded = 0
+        base_dir = Dir.pwd
+
+        TOOL_DIRECTORIES.each do |tool_dir|
+          full_dir = File.join(base_dir, tool_dir)
+          next unless Dir.exist?(full_dir)
+
+          # Find all .rb files in the directory (and subdirectories)
+          Dir.glob(File.join(full_dir, '**', '*.rb')).sort.each do |tool_file|
+            # Skip files that look like tests or specs
+            next if tool_file.include?('_spec.rb') || tool_file.include?('_test.rb')
+
+            begin
+              require tool_file
+              tools_loaded += 1
+              Legate.logger.debug "Loaded custom tool file: #{tool_file}"
+            rescue LoadError, StandardError => e
+              Legate.logger.warn "Failed to load tool file #{tool_file}: #{e.class} - #{e.message}"
+              Legate.logger.debug e.backtrace.first(3).join("\n") if e.backtrace
+            end
+          end
+        end
+
+        return unless tools_loaded.positive?
+
+        Legate.logger.info "Auto-loaded #{tools_loaded} custom tool file(s). " \
+                        "Registered tools: #{Legate::GlobalToolManager.registered_tool_names.inspect}"
+      end
+
+      # Auto-discover and load custom agent definitions from conventional directories
+      def load_custom_agents
+        agents_loaded = 0
+        base_dir = Dir.pwd
+
+        AGENT_DIRECTORIES.each do |agent_dir|
+          full_dir = File.join(base_dir, agent_dir)
+          next unless Dir.exist?(full_dir)
+
+          # Find all .rb files in the directory (and subdirectories)
+          Dir.glob(File.join(full_dir, '**', '*.rb')).sort.each do |agent_file|
+            # Skip files that look like tests, specs, or tools
+            next if agent_file.include?('_spec.rb') || agent_file.include?('_test.rb')
+            next if agent_file.include?('/tools/') # Don't load tools from agent directories
+
+            begin
+              require agent_file
+              agents_loaded += 1
+              Legate.logger.debug "Loaded custom agent file: #{agent_file}"
+            rescue LoadError, StandardError => e
+              Legate.logger.warn "Failed to load agent file #{agent_file}: #{e.class} - #{e.message}"
+              Legate.logger.debug e.backtrace.first(3).join("\n") if e.backtrace
+            end
+          end
+        end
+
+        return unless agents_loaded.positive?
+
+        registered_agents = begin
+          Legate::GlobalDefinitionRegistry.all.keys
+        rescue StandardError
+          []
+        end
+        Legate.logger.info "Auto-loaded #{agents_loaded} custom agent file(s). " \
+                        "Registered agents: #{registered_agents.inspect}"
+
+        # Sync loaded agents to the definition store so they appear in the Web UI
+        sync_agents_to_definition_store
+      end
+
+      # Agents auto-loaded from files are already in GlobalDefinitionRegistry,
+      # which serves as the definition store. No sync needed.
+      def sync_agents_to_definition_store
+        # No-op: GlobalDefinitionRegistry is the sole definition store.
+        Legate.logger.debug 'Agents are already in GlobalDefinitionRegistry (in-memory definition store).'
+      end
+    end
+  end
+end

data/lib/legate/cli.rb

@@ -0,0 +1,40 @@
+# File: lib/legate/cli.rb
+# frozen_string_literal: true
+
+require 'thor'
+# Require the files that DEFINE the command classes first
+require_relative 'cli/base_command'
+require_relative 'cli/output_helper'
+require_relative 'cli/agent_commands'
+require_relative 'cli/tool_commands'
+require_relative 'cli/web_commands'
+require_relative 'cli/session_commands'
+require_relative 'cli/deployment_commands'
+require_relative 'cli/skaffold_commands'
+require_relative 'cli/auth_commands'
+
+module Legate
+  module CLI
+    # Main CLI class that provides the entry point for all Legate commands
+    class Main < BaseCommand
+      desc 'version', 'Display the Legate version'
+      def version
+        puts "Legate version #{Legate::VERSION}"
+      end
+
+      # Register subcommands
+      register(AgentCommands, 'agent', 'agent <command>',
+               'Manage Legate agents and execution (list, save, delete, generate, execute, start)')
+      register(ToolCommands, 'tool', 'tool <command>', 'Manage Legate tools')
+      register(WebCommands, 'web', 'web <command>', 'Manage Legate web interface')
+      register(SessionCommands, 'session', 'session <command>', 'Manage Legate sessions')
+      register(DeploymentCommands, 'deployment', 'deployment <command>',
+               'Generate deployment assets for cloud platforms')
+      register(SkaffoldCommands, 'skaffold', 'skaffold [PROJECT_NAME]',
+               'Generate a new Legate project structure (alias: new, init)')
+      register(AuthCommands, 'auth', 'auth <command>',
+               'Manage authentication schemes, credentials, and URL mappings')
+    end
+    # --- End Main class definition ---
+  end # End CLI module
+end # End Legate module

data/lib/legate/configuration/webhooks.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'legate/session_service/base'
+
+module Legate
+  class Configuration
+    # Configuration settings for the inbound webhook listener and processing.
+    class Webhooks
+      # @return [Boolean] Whether the webhook listener is enabled. Defaults to false.
+      attr_accessor :listener_enabled
+
+      # @return [String] The IP address the listener should bind to. Defaults to '127.0.0.1'.
+      attr_accessor :listen_address
+
+      # @return [Integer] The port the listener should bind to. Defaults to 9292.
+      attr_accessor :listen_port
+
+      # @return [String] The base path for all webhook routes. Defaults to '/webhooks'.
+      attr_accessor :base_path
+
+      # @return [Boolean] Whether the dynamic agent handler route is enabled. Defaults to false.
+      attr_accessor :enable_dynamic_agent_handler
+
+      # @return [String] The path pattern for the dynamic agent handler. Defaults to '/agents/:agent_name/trigger'.
+      attr_accessor :dynamic_agent_route_pattern
+
+      # @return [Symbol, Proc, nil] A global validator to apply if an agent doesn't specify one.
+      attr_accessor :global_validator
+
+      # @return [String, nil] The secret key used by the global validator (e.g., for HMAC).
+      attr_accessor :global_secret
+
+      # @return [Legate::SessionService::Base, nil] The default session service instance to use in the webhook worker.
+      attr_accessor :default_session_service
+
+      def initialize
+        @listener_enabled = true # Enable listener by default for easier testing/use
+        @listen_address = '127.0.0.1' # Default to loopback for security
+        @listen_port = 9292
+        @base_path = '/webhooks'
+        @enable_dynamic_agent_handler = true # Enable dynamic handler by default for easier testing
+        @dynamic_agent_route_pattern = '/agents/:agent_name/trigger'
+        @global_validator = nil
+        @global_secret = nil
+        @default_session_service = nil
+        @validators = {}
+        @static_routes = {} # Store static routes: path -> RouteConfig
+      end
+
+      # Registers a named validator proc/lambda.
+      #
+      # @param name [Symbol] The name to register the validator under.
+      # @yield [request, secret] The block that performs validation.
+      # @yieldparam request The Rack request object.
+      # @yieldparam secret [String, nil] The secret associated with the route/agent.
+      # @yieldreturn [Boolean] True if the request is valid, false otherwise.
+      # @raise [ArgumentError] If the name is already registered or no block is given.
+      def register_validator(name, &block)
+        raise ArgumentError, "Validator name :#{name} is already registered." if @validators.key?(name)
+        raise ArgumentError, 'Validator requires a block.' unless block_given?
+
+        @validators[name] = block
+      end
+
+      # Finds a registered validator by name.
+      #
+      # @param name [Symbol] The name of the validator.
+      # @return [Proc, nil] The validator proc or nil if not found.
+      def find_validator(name)
+        @validators[name]
+      end
+
+      # Registers a static webhook route.
+      # Primarily intended for simple, non-agent-related endpoints like health checks.
+      # Agent-related webhooks should typically use the dynamic agent handler.
+      #
+      # @param path [String] The HTTP method and path pattern (e.g., "GET /system/health", "POST /simple").
+      # @yield [route_config] The block to configure the route.
+      # @yieldparam route_config [RouteConfig] The configuration object for this route.
+      # @raise [ArgumentError] If the path is already registered or no block is given.
+      def register_route(path)
+        raise ArgumentError, "Route path \"#{path}\" is already registered." if @static_routes.key?(path)
+        raise ArgumentError, 'Route registration requires a block.' unless block_given?
+
+        config = RouteConfig.new
+        yield config
+        @static_routes[path] = config
+      end
+
+      # Retrieves the configurations for all registered static routes.
+      # @return [Hash{String => RouteConfig}] A hash mapping path patterns to their configurations.
+      def static_routes
+        @static_routes.dup # Return a copy to prevent external modification
+      end
+
+      # Internal class to hold configuration for a single static route.
+      class RouteConfig
+        # @return [Proc, nil] The handler proc for the route. Should return a Rack response array.
+        attr_accessor :handler
+        # @return [Symbol, Proc, nil] A specific validator for this static route.
+        attr_accessor :validator
+        # @return [String, nil] The secret key for this static route's validator.
+        attr_accessor :secret
+
+        def initialize
+          @handler = nil
+          @validator = nil
+          @secret = nil
+        end
+      end
+    end
+  end
+end

data/lib/legate/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'legate/agent'
+require_relative 'session_service/in_memory'
+require 'legate/configuration/webhooks'
+
+module Legate
+  # Central configuration object for the Legate framework.
+  # Access via `Legate.config` after calling `Legate.configure`.
+  class Configuration
+    # @return [Legate::SessionService::Base] The service used to manage agent session state.
+    attr_accessor :session_service
+
+    # @return [Symbol] Default model name to use if not specified in agent definition.
+    attr_accessor :default_model_name
+
+    # @return [Float] Default temperature to use if not specified in agent definition.
+    attr_accessor :default_temperature
+
+    # @return [Legate::Configuration::Webhooks] Webhook configuration.
+    attr_reader :webhooks
+
+    # @return [Boolean] Whether the web UI may load AI-generated custom tools into
+    #   the running process (this executes LLM-generated Ruby — see
+    #   Legate::Generators::RuntimeToolLoader). Defaults to ON outside production
+    #   and OFF in production. Override explicitly via
+    #   `Legate.configure { |c| c.allow_runtime_tool_load = true/false }`.
+    attr_accessor :allow_runtime_tool_load
+
+    def initialize
+      # Always use in-memory session service (Redis dependency removed)
+      @session_service = Legate::SessionService::InMemory.new
+      @default_model_name = 'gemini-3.5-flash'
+      @default_temperature = 0.7
+      @webhooks = Legate::Configuration::Webhooks.new
+      @allow_runtime_tool_load = ENV['RACK_ENV'] != 'production'
+    end
+  end
+end

data/lib/legate/definition_store.rb

@@ -0,0 +1,23 @@
+# File: lib/legate/definition_store.rb
+# frozen_string_literal: true
+
+module Legate
+  # Module responsible for persisting and retrieving agent definitions.
+  # Implementations should provide methods for CRUD operations on definitions.
+  module DefinitionStore
+    # NOTE: Base error classes (Error, ConfigurationError, StoreError)
+    # are defined in lib/legate/errors.rb and inherit from Legate::Error.
+
+    # Error raised when a definition is not found
+    # Inherits from Legate::DefinitionStore::Error defined in errors.rb
+    class NotFoundError < Error; end # Use the base Error defined in errors.rb (Legate::DefinitionStore::Error)
+
+    # Removing redundant/conflicting definitions:
+    # class StoreError < StandardError; end
+    # class ConfigurationError < StoreError; end
+
+    # Potential future: Define abstract methods or rely on duck typing for implementations.
+
+    # Definitions are stored in-memory via GlobalDefinitionRegistry.
+  end
+end