tasker-rb 0.1.3-arm64-darwin

data/lib/tasker_core/domain_events/subscriber_registry.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module TaskerCore
+  module DomainEvents
+    # TAS-65: Registry for domain event subscribers
+    #
+    # Manages the lifecycle of domain event subscribers. Subscribers are registered
+    # at bootstrap time and started/stopped together with the worker.
+    #
+    # @example Registering subscribers at bootstrap
+    #   registry = TaskerCore::DomainEvents::SubscriberRegistry.instance
+    #
+    #   # Register subscriber classes (instantiation deferred)
+    #   registry.register(PaymentEventSubscriber)
+    #   registry.register(MetricsSubscriber)
+    #
+    #   # Or register instances directly
+    #   registry.register_instance(CustomSubscriber.new(some_config))
+    #
+    #   # Start all subscribers
+    #   registry.start_all!
+    #
+    # @example Stopping all subscribers
+    #   registry.stop_all!
+    #
+    class SubscriberRegistry
+      include Singleton
+
+      attr_reader :logger, :subscribers
+
+      def initialize
+        @logger = TaskerCore::Logger.instance
+        @subscribers = []
+        @started = false
+      end
+
+      # Register a subscriber class
+      #
+      # The class will be instantiated when start_all! is called.
+      #
+      # @param subscriber_class [Class] A subclass of BaseSubscriber
+      # @return [void]
+      def register(subscriber_class)
+        unless subscriber_class < BaseSubscriber
+          raise ArgumentError, "#{subscriber_class} must be a subclass of BaseSubscriber"
+        end
+
+        logger.info "SubscriberRegistry: Registered #{subscriber_class.name}"
+        @subscriber_classes ||= []
+        @subscriber_classes << subscriber_class
+      end
+
+      # Register a subscriber instance directly
+      #
+      # Use this when your subscriber needs custom initialization.
+      #
+      # @param subscriber [BaseSubscriber] A subscriber instance
+      # @return [void]
+      def register_instance(subscriber)
+        raise ArgumentError, "Expected BaseSubscriber, got #{subscriber.class}" unless subscriber.is_a?(BaseSubscriber)
+
+        logger.info "SubscriberRegistry: Registered instance of #{subscriber.class.name}"
+        @subscribers << subscriber
+      end
+
+      # Start all registered subscribers
+      #
+      # Instantiates registered classes and starts all subscribers.
+      #
+      # @return [void]
+      def start_all!
+        return if @started
+
+        # Instantiate registered classes
+        (@subscriber_classes || []).each do |klass|
+          @subscribers << klass.new
+        end
+
+        # Start all subscribers
+        @subscribers.each do |subscriber|
+          subscriber.start!
+        rescue StandardError => e
+          logger.error "Failed to start #{subscriber.class.name}: #{e.message}"
+        end
+
+        @started = true
+        logger.info "SubscriberRegistry: Started #{@subscribers.size} subscribers"
+      end
+
+      # Stop all subscribers
+      #
+      # @return [void]
+      def stop_all!
+        return unless @started
+
+        @subscribers.each do |subscriber|
+          subscriber.stop!
+        rescue StandardError => e
+          logger.error "Failed to stop #{subscriber.class.name}: #{e.message}"
+        end
+
+        @started = false
+        logger.info 'SubscriberRegistry: Stopped all subscribers'
+      end
+
+      # Check if subscribers have been started
+      #
+      # @return [Boolean]
+      def started?
+        @started
+      end
+
+      # Get count of registered subscribers
+      #
+      # @return [Integer]
+      def count
+        @subscribers.size + (@subscriber_classes&.size || 0)
+      end
+
+      # Get subscriber statistics
+      #
+      # @return [Hash]
+      def stats
+        {
+          started: @started,
+          subscriber_count: @subscribers.size,
+          active_count: @subscribers.count(&:active?),
+          subscribers: @subscribers.map do |s|
+            {
+              class: s.class.name,
+              active: s.active?,
+              patterns: s.class.patterns
+            }
+          end
+        }
+      end
+
+      # Reset the registry (for testing)
+      #
+      # @note This stops all subscribers first
+      def reset!
+        stop_all! if @started
+        @subscribers.clear
+        @subscriber_classes&.clear
+        @started = false
+        logger.info 'SubscriberRegistry: Reset'
+      end
+    end
+  end
+end

data/lib/tasker_core/domain_events.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# TAS-65: Domain Events Module
+#
+# Provides infrastructure for custom domain event publishers.
+# Domain events are business events (e.g., "order.processed", "payment.completed")
+# published after step execution based on YAML declarations.
+#
+# @example Using the domain events infrastructure
+#   # Register custom publishers at bootstrap
+#   require 'tasker_core/domain_events'
+#
+#   class PaymentEventPublisher < TaskerCore::DomainEvents::BasePublisher
+#     def name
+#       'PaymentEventPublisher'
+#     end
+#
+#     def transform_payload(step_result, event_declaration, step_context)
+#       {
+#         payment_id: step_result[:result][:payment_id],
+#         amount: step_result[:result][:amount],
+#         status: step_result[:success] ? 'succeeded' : 'failed'
+#       }
+#     end
+#   end
+#
+#   TaskerCore::DomainEvents::PublisherRegistry.instance.register(
+#     PaymentEventPublisher.new
+#   )
+#
+module TaskerCore
+  module DomainEvents
+    # Load domain events components
+  end
+end
+
+# Publishers
+require_relative 'domain_events/base_publisher'
+require_relative 'domain_events/publisher_registry'
+
+# Subscribers
+require_relative 'domain_events/base_subscriber'
+require_relative 'domain_events/subscriber_registry'

data/lib/tasker_core/errors/CLAUDE.md

@@ -0,0 +1,7 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+*No recent activity*
+</claude-mem-context>

data/lib/tasker_core/errors/common.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module TaskerCore
+  module Errors
+    # Base error class for all TaskerCore-related errors
+    class Error < StandardError; end
+
+    # Raised when there are configuration-related issues in TaskerCore
+    class ConfigurationError < Error; end
+
+    # Base class for all TaskerCore-specific errors that occur during workflow execution
+    # Maps to the comprehensive error system in Rust orchestration/errors.rs
+    class ProceduralError < Error; end
+
+    # Raised when there are orchestration-related issues in TaskerCore
+    class OrchestrationError < Error; end
+
+    # Raised when there are database-related issues in TaskerCore
+    class DatabaseError < Error; end
+
+    # Error indicating a step failed but should be retried with backoff
+    # Maps to Rust StepExecutionError::Retryable
+    #
+    # Use this error when an operation fails due to temporary conditions like:
+    # - Network timeouts
+    # - Rate limiting (429 status)
+    # - Server errors (5xx status)
+    # - Temporary service unavailability
+    # - Resource exhaustion that may resolve
+    #
+    # @example Basic retryable error
+    #   raise TaskerCore::Errors::RetryableError, "Payment service timeout"
+    #
+    # @example With retry delay
+    #   raise TaskerCore::Errors::RetryableError.new("Rate limited", retry_after: 60)
+    #
+    # @example With context for monitoring
+    #   raise TaskerCore::Errors::RetryableError.new(
+    #     "External API unavailable",
+    #     retry_after: 30,
+    #     context: { service: 'billing_api', error_code: 503 }
+    #   )
+    class RetryableError < ProceduralError
+      # @return [Integer, nil] Suggested retry delay in seconds
+      attr_reader :retry_after
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param retry_after [Integer, nil] Suggested retry delay in seconds
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, retry_after: nil, context: {})
+        super(message)
+        @retry_after = retry_after
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'RetryableError'
+      end
+    end
+
+    # Error indicating a step failed permanently and should not be retried
+    # Maps to Rust StepExecutionError::Permanent
+    #
+    # Use this error when an operation fails due to permanent conditions like:
+    # - Invalid request data (400 status)
+    # - Authentication/authorization failures (401/403 status)
+    # - Validation errors (422 status)
+    # - Resource not found when it should exist (404 status in some contexts)
+    # - Business logic violations
+    # - Configuration errors
+    #
+    # @example Basic permanent error
+    #   raise TaskerCore::Errors::PermanentError, "Invalid user ID format"
+    #
+    # @example With error code for categorization
+    #   raise TaskerCore::Errors::PermanentError.new(
+    #     "Insufficient funds for transaction",
+    #     error_code: 'INSUFFICIENT_FUNDS'
+    #   )
+    #
+    # @example With context for monitoring
+    #   raise TaskerCore::Errors::PermanentError.new(
+    #     "User not authorized for this operation",
+    #     error_code: 'AUTHORIZATION_FAILED',
+    #     context: { user_id: 123, operation: 'admin_access' }
+    #   )
+    class PermanentError < ProceduralError
+      # @return [String, nil] Machine-readable error code for categorization
+      attr_reader :error_code
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param error_code [String, nil] Machine-readable error code
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, error_code: nil, context: {})
+        super(message)
+        @error_code = error_code
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'PermanentError'
+      end
+    end
+
+    # Error indicating a timeout occurred during step execution
+    # Maps to Rust StepExecutionError::Timeout
+    #
+    # Use this error when an operation fails due to timeout conditions:
+    # - Step execution timeout
+    # - Network request timeout
+    # - Database operation timeout
+    # - External service timeout
+    #
+    # @example Basic timeout error
+    #   raise TaskerCore::Errors::TimeoutError, "Payment processing timed out"
+    #
+    # @example With timeout duration
+    #   raise TaskerCore::Errors::TimeoutError.new(
+    #     "Database query timed out",
+    #     timeout_duration: 30
+    #   )
+    class TimeoutError < ProceduralError
+      # @return [Integer, nil] Timeout duration in seconds
+      attr_reader :timeout_duration
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param timeout_duration [Integer, nil] Timeout duration in seconds
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, timeout_duration: nil, context: {})
+        super(message)
+        @timeout_duration = timeout_duration
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'TimeoutError'
+      end
+    end
+
+    # Error indicating a network-related failure
+    # Maps to Rust StepExecutionError::NetworkError
+    #
+    # Use this error when an operation fails due to network conditions:
+    # - Connection failures
+    # - DNS resolution errors
+    # - HTTP errors (4xx/5xx when network-related)
+    # - TLS/SSL errors
+    # - Network timeouts
+    #
+    # @example Basic network error
+    #   raise TaskerCore::Errors::NetworkError, "Connection refused"
+    #
+    # @example With HTTP status code
+    #   raise TaskerCore::Errors::NetworkError.new(
+    #     "Service unavailable",
+    #     status_code: 503
+    #   )
+    class NetworkError < ProceduralError
+      # @return [Integer, nil] HTTP status code if applicable
+      attr_reader :status_code
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param status_code [Integer, nil] HTTP status code if applicable
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, status_code: nil, context: {})
+        super(message)
+        @status_code = status_code
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'NetworkError'
+      end
+    end
+
+    # Error indicating validation failed
+    # Maps to Rust OrchestrationError::ValidationError
+    #
+    # Use this error when data validation fails:
+    # - Schema validation errors
+    # - Business rule validation
+    # - Input format validation
+    # - Required field validation
+    class ValidationError < PermanentError
+      # @return [String, nil] Field that failed validation
+      attr_reader :field
+
+      # @param message [String] Error message
+      # @param field [String, nil] Field that failed validation
+      # @param error_code [String, nil] Machine-readable error code
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, field: nil, error_code: nil, context: {})
+        super(message, error_code: error_code, context: context)
+        @field = field
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'ValidationError'
+      end
+    end
+
+    # Error indicating a handler or step was not found
+    # Maps to Rust OrchestrationError::HandlerNotFound and StepHandlerNotFound
+    class NotFoundError < PermanentError
+      # @return [String, nil] Type of resource not found (handler, step, etc.)
+      attr_reader :resource_type
+
+      # @param message [String] Error message
+      # @param resource_type [String, nil] Type of resource not found
+      # @param error_code [String, nil] Machine-readable error code
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, resource_type: nil, error_code: nil, context: {})
+        super(message, error_code: error_code, context: context)
+        @resource_type = resource_type
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'NotFoundError'
+      end
+    end
+
+    # Error indicating an FFI operation failed
+    # Maps to Rust OrchestrationError::FfiBridgeError
+    class FFIError < Error
+      # @return [String, nil] FFI operation that failed
+      attr_reader :operation
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param operation [String, nil] FFI operation that failed
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, operation: nil, context: {})
+        super(message)
+        @operation = operation
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'FFIError'
+      end
+    end
+
+    # Error indicating embedded server operation failed
+    # Maps to Rust ServerError types
+    #
+    # Use this error when embedded server operations fail:
+    # - Server startup failures
+    # - Server shutdown failures
+    # - Configuration errors
+    # - Runtime errors
+    # - Server already running/not running
+    #
+    # @example Basic server error
+    #   raise TaskerCore::Errors::ServerError, "Failed to start embedded server"
+    #
+    # @example With server operation context
+    #   raise TaskerCore::Errors::ServerError.new(
+    #     "Server startup failed",
+    #     operation: 'start',
+    #     context: { bind_address: '127.0.0.1:8080', error_code: 'ADDRESS_IN_USE' }
+    #   )
+    class ServerError < Error
+      # @return [String, nil] Server operation that failed
+      attr_reader :operation
+
+      # @return [Hash] Additional context for error monitoring and debugging
+      attr_reader :context
+
+      # @param message [String] Error message
+      # @param operation [String, nil] Server operation that failed (start, stop, config, etc.)
+      # @param context [Hash] Additional context for monitoring
+      def initialize(message, operation: nil, context: {})
+        super(message)
+        @operation = operation
+        @context = context
+      end
+
+      # Get the error class name for Rust FFI compatibility
+      def error_class
+        'ServerError'
+      end
+    end
+  end
+end

data/lib/tasker_core/errors/error_classifier.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module TaskerCore
+  module Errors
+    # ErrorClassifier provides systematic classification of errors for retry logic
+    #
+    # This classifier determines whether errors should be retried based on their type.
+    # It maintains explicit lists of permanent (non-retryable) and retryable error classes.
+    #
+    # @example Classify a configuration error
+    #   ErrorClassifier.retryable?(ConfigurationError.new("Missing handler"))
+    #   # => false
+    #
+    # @example Classify a network error
+    #   ErrorClassifier.retryable?(NetworkError.new("Connection timeout"))
+    #   # => true
+    class ErrorClassifier
+      # System-level errors that should NEVER be retried
+      # These represent fundamental configuration or setup issues that won't resolve on retry
+      PERMANENT_ERROR_CLASSES = [
+        ConfigurationError,      # Configuration issues (missing config, invalid settings)
+        PermanentError,          # Explicitly marked permanent errors
+        ValidationError,         # Data validation failures
+        NotFoundError,           # Resource not found (handler, step, etc.)
+        DatabaseError,           # Database schema/constraint errors
+        FFIError                 # FFI bridge failures
+      ].freeze
+
+      # Application errors that are retryable by default
+      # These represent transient failures that may resolve on subsequent attempts
+      RETRYABLE_ERROR_CLASSES = [
+        RetryableError,          # Explicitly marked retryable errors
+        NetworkError,            # Network/connection failures
+        TimeoutError             # Timeout errors
+      ].freeze
+
+      # Determine if an error should be retried
+      #
+      # @param error [StandardError] The error to classify
+      # @return [Boolean] true if the error should be retried, false otherwise
+      #
+      # @note The default behavior is to mark errors as retryable unless they are
+      #   explicitly in the PERMANENT_ERROR_CLASSES list. This follows the principle
+      #   that it's safer to retry an error that shouldn't be retried (will eventually
+      #   hit retry limit) than to not retry an error that should be (will fail immediately).
+      def self.retryable?(error)
+        # Explicit permanent errors - never retry
+        return false if PERMANENT_ERROR_CLASSES.any? { |klass| error.is_a?(klass) }
+
+        # Explicit retryable errors - always retry
+        return true if RETRYABLE_ERROR_CLASSES.any? { |klass| error.is_a?(klass) }
+
+        # Default: StandardError and subclasses are retryable unless explicitly marked permanent
+        # This is a safe default - worst case, we retry until max_attempts is hit
+        true
+      end
+    end
+  end
+end

data/lib/tasker_core/errors.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'errors/common'
+require_relative 'errors/error_classifier'