tasker-rb 0.1.1

data/lib/tasker_core/types/task_template.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+require 'dry-struct'
+require 'time'
+
+module TaskerCore
+  module Types
+    # TaskTemplate Types - Self-Describing Workflow Configuration
+    #
+    # This module implements the self-describing TaskTemplate structure, featuring:
+    # - Callable-based handlers for maximum flexibility
+    # - Structured handler initialization configuration
+    # - Clear system dependency declarations
+    # - First-class domain event support
+    # - Enhanced environment-specific overrides
+    # - JSON Schema-based input validation
+
+    module Types
+      include Dry.Types()
+    end
+
+    # Template metadata for documentation and discovery
+    class TemplateMetadata < Dry::Struct
+      attribute :author, Types::String.optional.default(nil)
+      attribute :tags, Types::Array.of(Types::String).default([].freeze)
+      attribute :documentation_url, Types::String.optional.default(nil)
+      attribute :created_at, Types::String.optional.default(nil)  # ISO8601 format
+      attribute :updated_at, Types::String.optional.default(nil)  # ISO8601 format
+    end
+
+    # Handler definition with callable and initialization
+    #
+    # TAS-93: Extended with handler_method and resolver fields for the resolver chain pattern.
+    # - `handler_method`: Optional method name override (defaults to 'call')
+    # - `resolver`: Optional resolver hint to bypass inferential resolution
+    #
+    # NOTE: We use `handler_method` instead of `method` to avoid collision with
+    # Ruby's built-in `Object#method`.
+    class HandlerDefinition < Dry::Struct
+      attribute :callable, Types::Strict::String
+      attribute :initialization, Types::Hash.default({}.freeze)
+      # TAS-93: Method name to invoke on the handler (defaults to 'call')
+      # Named handler_method to avoid collision with Ruby's Object#method
+      attribute :handler_method, Types::String.optional.default(nil)
+      # TAS-93: Resolver hint to bypass the resolver chain (e.g., 'payment_resolver')
+      attribute :resolver, Types::String.optional.default(nil)
+
+      # TAS-93: Get the effective method name to invoke
+      # Returns the configured method name or defaults to 'call'
+      #
+      # @return [String] The method name to invoke on the handler
+      def effective_method
+        handler_method.presence || 'call'
+      end
+
+      # TAS-93: Check if this handler uses custom method dispatch
+      # Returns true if a non-default method is configured
+      #
+      # @return [Boolean] true if handler_method is something other than 'call'
+      def uses_method_dispatch?
+        handler_method.present? && handler_method != 'call'
+      end
+
+      # TAS-93: Check if a resolver hint is specified
+      # When true, the resolver chain should skip inferential resolution
+      # and directly use the named resolver
+      #
+      # @return [Boolean] true if resolver hint is present
+      def has_resolver_hint?
+        resolver.present?
+      end
+    end
+
+    # External system dependencies
+    class SystemDependencies < Dry::Struct
+      attribute :primary, Types::String.default('default')
+      attribute :secondary, Types::Array.of(Types::String).default([].freeze)
+    end
+
+    # Domain event definition with schema
+    class DomainEventDefinition < Dry::Struct
+      attribute :name, Types::Strict::String
+      attribute :description, Types::String.optional.default(nil)
+      attribute :schema, Types::Hash.optional.default(nil) # JSON Schema
+    end
+
+    # Retry configuration with backoff strategies
+    class RetryConfiguration < Dry::Struct
+      attribute :retryable, Types::Bool.default(true)
+      attribute :limit, Types::Integer.default(3)
+      attribute :backoff, Types::String.default('exponential').enum('none', 'linear', 'exponential', 'fibonacci')
+      attribute :backoff_base_ms, Types::Integer.optional.default(1000)
+      attribute :max_backoff_ms, Types::Integer.optional.default(30_000)
+    end
+
+    # Individual workflow step definition
+    class StepDefinition < Dry::Struct
+      attribute :name, Types::Strict::String
+      attribute :description, Types::String.optional.default(nil)
+      attribute :handler, HandlerDefinition
+      attribute :system_dependency, Types::String.optional.default(nil)
+      attribute :dependencies, Types::Array.of(Types::String).default([].freeze)
+      attribute(:retry, RetryConfiguration.default { RetryConfiguration.new })
+      attribute :timeout_seconds, Types::Integer.optional.default(nil)
+      attribute :publishes_events, Types::Array.of(Types::String).default([].freeze)
+      # TAS-53: Decision point step type classification
+      # Matches Rust field serialization name (Rust field: step_type, YAML: type)
+      attribute :type, Types::String.optional.default(nil).enum('standard', 'decision')
+
+      # Check if this step depends on another step
+      def depends_on?(other_step_name)
+        dependencies.include?(other_step_name.to_s)
+      end
+
+      # TAS-53: Check if this is a decision point step
+      def decision?
+        type == 'decision'
+      end
+
+      # TAS-53: Check if this is a standard step
+      def standard?
+        type.nil? || type == 'standard'
+      end
+    end
+
+    # Handler override for environments
+    class HandlerOverride < Dry::Struct
+      attribute :initialization, Types::Hash.optional.default(nil)
+    end
+
+    # Step override for environments
+    class StepOverride < Dry::Struct
+      attribute :name, Types::Strict::String # Step name or "ALL" for all steps
+      attribute :handler, HandlerOverride.optional.default(nil)
+      attribute :timeout_seconds, Types::Integer.optional.default(nil)
+      attribute :retry, RetryConfiguration.optional.default(nil)
+    end
+
+    # Environment-specific overrides
+    class EnvironmentOverride < Dry::Struct
+      attribute :task_handler, HandlerOverride.optional.default(nil)
+      attribute :steps, Types::Array.of(StepOverride).default([].freeze)
+    end
+
+    # Main TaskTemplate structure with self-describing configuration
+    class TaskTemplate < Dry::Struct
+      # Semantic version pattern validation
+      VERSION_PATTERN = /\A\d+\.\d+\.\d+\z/
+
+      # Core required attributes
+      attribute :name, Types::Strict::String
+      attribute :namespace_name, Types::Strict::String
+      attribute :version, Types::String.constrained(format: VERSION_PATTERN).default('1.0.0')
+
+      # Self-describing structure
+      attribute :description, Types::String.optional.default(nil)
+      attribute :metadata, TemplateMetadata.optional.default(nil)
+      attribute :task_handler, HandlerDefinition.optional.default(nil)
+      attribute(:system_dependencies, SystemDependencies.default { SystemDependencies.new })
+      attribute :domain_events, Types::Array.of(DomainEventDefinition).default([].freeze)
+      attribute :input_schema, Types::Hash.optional.default(nil) # JSON Schema
+      attribute :steps, Types::Array.of(StepDefinition).default([].freeze)
+      attribute :environments, Types::Hash.map(Types::String, EnvironmentOverride).default({}.freeze)
+
+      # Metadata (not persisted to database)
+      attribute :loaded_from, Types::String.optional.default(nil)
+
+      # Generate a unique key for this template
+      def template_key
+        "#{namespace_name}/#{name}:#{version}"
+      end
+
+      # Extract all callable references
+      def all_callables
+        callables = []
+        callables << task_handler.callable if task_handler
+        steps.each { |step| callables << step.handler.callable }
+        callables
+      end
+
+      # Check if template is valid for registration
+      def valid_for_registration?
+        return false if name.empty? || namespace_name.empty?
+        return false unless version.match?(VERSION_PATTERN)
+
+        # Ensure all steps have callables
+        return false if steps.any? { |step| step.handler.callable.empty? }
+
+        true
+      end
+
+      # Resolve template for specific environment
+      def resolve_for_environment(environment_name)
+        resolved_template = deep_dup
+
+        if environments[environment_name]
+          env_override = environments[environment_name]
+
+          # Apply task handler overrides
+          if env_override.task_handler && resolved_template.task_handler && env_override.task_handler.initialization
+            resolved_template.task_handler.initialization.merge!(env_override.task_handler.initialization)
+          end
+
+          # Apply step overrides
+          env_override.steps.each do |step_override|
+            if step_override.name == 'ALL'
+              # Apply to all steps
+              resolved_template.steps.each { |step| apply_step_override(step, step_override) }
+            else
+              # Apply to specific step
+              step = resolved_template.steps.find { |s| s.name == step_override.name }
+              apply_step_override(step, step_override) if step
+            end
+          end
+        end
+
+        resolved_template
+      end
+
+      private
+
+      # Deep duplicate for environment resolution
+      def deep_dup
+        # Simple deep dup implementation for dry-struct
+        TaskTemplate.new(to_h)
+      end
+
+      # Apply step override to a step
+      def apply_step_override(step, step_override)
+        if step_override.handler&.initialization
+          step.handler.initialization.merge!(step_override.handler.initialization)
+        end
+
+        step.timeout_seconds = step_override.timeout_seconds if step_override.timeout_seconds
+        step.retry = step_override.retry if step_override.retry
+      end
+    end
+  end
+end

data/lib/tasker_core/types/task_types.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+
+module TaskerCore
+  module Types
+    # Task-related type definitions for TaskerCore domain objects
+    module TaskTypes
+      module Types
+        include Dry.Types()
+      end
+
+      # Task request struct with full validation
+      class TaskRequest < Dry::Struct
+        # Core identification
+        attribute :namespace, Types::Coercible::String
+        attribute :name, Types::Coercible::String
+        attribute :version, Types::Coercible::String.default('1.0.0')
+
+        # Task state and metadata
+        attribute :status, Types::Coercible::String.default('pending').enum(
+          'pending',
+          'in_progress',
+          'completed',
+          'failed',
+          'cancelled',
+          'paused'
+        )
+        attribute :initiator, Types::Coercible::String
+        attribute :source_system, Types::Coercible::String
+        attribute :reason, Types::Coercible::String
+        attribute :complete, Types::Strict::Bool.default(false)
+        attribute :tags, Types::Array.of(Types::Coercible::String).default([].freeze)
+
+        # Task context (business data)
+        attribute :context, Types::Coercible::Hash
+
+        # Optional fields for advanced use cases
+        attribute? :priority, Types::Integer.default(0) # Higher values = higher priority, default 0
+        attribute? :claim_timeout_seconds, Types::Integer.default(60) # Timeout for distributed orchestration claims
+        attribute? :max_retries, Types::Integer.default(3)
+        attribute? :timeout_seconds, Types::Integer.default(300)
+        attribute? :parent_task_uuid, Types::String
+        attribute? :correlation_id, Types::Coercible::String
+
+        attribute?(:requested_at, Types::Constructor(Time) do |value|
+          value.is_a?(Time) ? value : Time.parse(value.to_s)
+        end.default { Time.now })
+
+        # Validation methods
+        def valid_for_creation?
+          !namespace.nil? && !namespace.empty? &&
+            !name.nil? && !name.empty? &&
+            !initiator.nil? && !initiator.empty? &&
+            !source_system.nil? && !source_system.empty? &&
+            !reason.nil? && !reason.empty? &&
+            context.is_a?(Hash)
+        end
+
+        # Convert to hash suitable for FFI serialization
+        def to_ffi_hash
+          # Build options hash for fields that go in the options field (legacy fields)
+          options_hash = {}
+          options_hash['max_retries'] = max_retries if max_retries
+          options_hash['timeout_seconds'] = timeout_seconds if timeout_seconds
+          options_hash['parent_task_uuid'] = parent_task_uuid if parent_task_uuid
+          options_hash['correlation_id'] = correlation_id if correlation_id
+
+          # Build the exact fields that Rust TaskRequest expects
+          rust_hash = {
+            namespace: namespace,
+            name: name,
+            version: version,
+            status: status,
+            initiator: initiator,
+            source_system: source_system,
+            reason: reason,
+            complete: complete,
+            tags: tags,
+            context: context,
+
+            requested_at: requested_at&.utc&.strftime('%Y-%m-%dT%H:%M:%S'),
+            # New direct fields for distributed orchestration
+            priority: priority,
+            claim_timeout_seconds: claim_timeout_seconds
+          }
+
+          # Add options field only if there are options to add
+          rust_hash[:options] = options_hash unless options_hash.empty?
+
+          rust_hash
+        end
+
+        # Create from hash with proper type coercion
+        def self.from_hash(hash)
+          new(hash.transform_keys(&:to_sym))
+        rescue Dry::Struct::Error => e
+          raise TaskerCore::ValidationError, "Invalid TaskRequest: #{e.message}"
+        end
+
+        # Quick factory method for tests
+        def self.build_test(namespace:, name:, context:, **options)
+          from_hash({
+                      namespace: namespace,
+                      name: name,
+                      context: context,
+                      initiator: options[:initiator] || 'test',
+                      source_system: options[:source_system] || 'rspec',
+                      reason: options[:reason] || 'testing',
+                      tags: options[:tags] || ['test'],
+                      **options
+                    })
+        end
+
+        # Pretty string representation
+        def to_s
+          "#<TaskRequest #{namespace}/#{name}:#{version} status=#{status} initiator=#{initiator}>"
+        end
+
+        def inspect
+          to_s
+        end
+      end
+
+      # Task response struct (for initialize_task results)
+      class TaskResponse < Dry::Struct
+        attribute :task_uuid, Types::String
+        attribute :status, Types::Coercible::String.enum(
+          'pending',
+          'in_progress',
+          'completed',
+          'failed',
+          'cancelled',
+          'paused'
+        )
+        attribute :workflow_steps, Types::Array.of(Types::Hash)
+        attribute? :created_at, Types::Constructor(Time)
+        attribute? :estimated_completion, Types::Constructor(Time)
+        attribute? :metadata, Types::Hash
+
+        def to_s
+          "#<TaskResponse task_uuid=#{task_uuid} status=#{status} steps=#{workflow_steps.size}>"
+        end
+      end
+    end
+  end
+end

data/lib/tasker_core/types.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+
+# Load all type modules
+require_relative 'types/task_types'
+require_relative 'types/step_types'
+require_relative 'types/step_message'
+require_relative 'types/simple_message' # NEW: simplified UUID-based messages
+require_relative 'types/task_template' # TaskTemplate and StepTemplate types
+require_relative 'types/step_handler_call_result' # NEW: standardized handler results
+require_relative 'types/decision_point_outcome' # TAS-53: decision point outcomes
+require_relative 'types/batch_processing_outcome' # TAS-59: batch processing outcomes
+require_relative 'types/step_context' # TAS-96: cross-language standard step context
+require_relative 'types/error_types' # TAS-96: cross-language standard error types
+require_relative 'types/client_types' # TAS-231: client API response types
+
+module TaskerCore
+  # Centralized type definitions for TaskerCore domain objects
+  #
+  # This module serves as the main entry point for all TaskerCore types,
+  # organizing them into logical groupings for better maintainability.
+  # All types are powered by dry-types for automatic validation, coercion,
+  # and schema enforcement.
+  #
+  # Type Categories:
+  # - **Task Types**: TaskRequest, TaskResponse for task creation and responses
+  # - **Step Types**: StepCompletion for step execution results
+  # - **Message Types**: SimpleStepMessage, SimpleTaskMessage for lightweight messaging
+  # - **Template Types**: TaskTemplate, StepTemplate for workflow definitions
+  # - **Result Types**: StepHandlerCallResult for standardized handler responses
+  #
+  # @example Using task types with validation
+  #   # Build a task request with automatic validation
+  #   request = TaskerCore::Types::TaskRequest.new(
+  #     namespace: "fulfillment",
+  #     name: "process_order",
+  #     context: { order_id: "123", items: [...] }
+  #   )
+  #   # => Automatically validates required fields and types
+  #
+  # @example Type coercion and defaults
+  #   # dry-types automatically coerces compatible types
+  #   completion = TaskerCore::Types::StepCompletion.new(
+  #     task_uuid: "123",
+  #     step_uuid: "456",
+  #     success: "true"  # Automatically coerced to boolean true
+  #   )
+  #
+  # @example Building test fixtures
+  #   # Use build_test for quick test data generation
+  #   request = TaskerCore::Types::TaskRequest.build_test(
+  #     namespace: "fulfillment",
+  #     name: "process_order",
+  #     context: { order_id: "123" }
+  #   )
+  #   # => Creates valid request with sensible test defaults
+  #
+  # @example Using simple message types for UUID-based communication
+  #   # Lightweight message for step execution
+  #   simple_message = TaskerCore::Types::SimpleStepMessage.new(
+  #     task_uuid: "550e8400-e29b-41d4-a716-446655440000",
+  #     step_uuid: "7c9e6679-7425-40de-944b-e07fc1f90ae7",
+  #     ready_dependency_step_uuids: [
+  #       "123e4567-e89b-12d3-a456-426614174000",
+  #       "456e7890-e12b-34d5-a678-426614174001"
+  #     ]
+  #   )
+  #
+  # @example Using template types for workflow definitions
+  #   # Define a task template
+  #   template = TaskerCore::Types::TaskTemplate.new(
+  #     namespace: "payments",
+  #     name: "process_payment",
+  #     steps: [
+  #       { name: "validate", handler_class: "ValidatePaymentHandler" },
+  #       { name: "charge", handler_class: "ChargePaymentHandler" }
+  #     ]
+  #   )
+  #
+  # @example Standardized handler results
+  #   # Return structured results from handlers
+  #   result = TaskerCore::Types::StepHandlerCallResult.success(
+  #     result: { payment_id: "pay_123", amount: 100.00 },
+  #     metadata: {
+  #       processing_time_ms: 125,
+  #       gateway: "stripe"
+  #     }
+  #   )
+  #
+  # Validation Benefits:
+  # - **Type Safety**: Automatic type checking and coercion
+  # - **Required Fields**: Ensures all required data is present
+  # - **Schema Enforcement**: Validates structure matches expectations
+  # - **Early Error Detection**: Catches data issues before processing
+  # - **Documentation**: Types serve as living documentation
+  #
+  # @see TaskerCore::Types::TaskRequest For task creation
+  # @see TaskerCore::Types::TaskResponse For task responses
+  # @see TaskerCore::Types::StepCompletion For step execution results
+  # @see TaskerCore::Types::SimpleStepMessage For UUID-based step messaging
+  # @see TaskerCore::Types::SimpleTaskMessage For UUID-based task messaging
+  # @see TaskerCore::Types::TaskTemplate For workflow definitions
+  # @see TaskerCore::Types::StepHandlerCallResult For standardized handler responses
+  # @see https://dry-rb.org/gems/dry-types For dry-types documentation
+  module Types
+    include Dry.Types()
+
+    # Make base types available in class scope
+
+    # Re-export all type classes for backward compatibility and convenience
+
+    # Task-related types
+    TaskRequest = TaskTypes::TaskRequest
+    TaskResponse = TaskTypes::TaskResponse
+
+    # Step-related types
+    StepCompletion = StepTypes::StepCompletion
+
+    # Simple message types (UUID-based) - already defined in the namespace
+
+    # Client API types (TAS-231)
+    ClientTaskResponse = ClientTypes::TaskResponse
+    ClientTaskListResponse = ClientTypes::TaskListResponse
+    ClientStepResponse = ClientTypes::StepResponse
+    ClientStepAuditResponse = ClientTypes::StepAuditResponse
+    ClientHealthResponse = ClientTypes::HealthResponse
+    ClientPaginationInfo = ClientTypes::PaginationInfo
+    ClientStepReadiness = ClientTypes::StepReadiness
+  end
+end

data/lib/tasker_core/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TaskerCore
+  # Version synchronization with the core Rust crate
+  # This should be kept in sync with the Cargo.toml version
+  VERSION = '0.1.1'
+
+  def self.version_info
+    {
+      version: VERSION
+    }
+  end
+end

data/lib/tasker_core/worker/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>