tasker-rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bded962229b0c776f66831e441e237da58b844fe480ef89708c59e32afae2d9
-  data.tar.gz: 5d2ca6ccb24aa8f929ea48dc94bf4ddcb07269161729cde97888038fd64683a1
+  metadata.gz: 6c505f5e0ee2615e50e4bd56c0c6e3fd7900837dcaf8454f828e197f15f9328d
+  data.tar.gz: a4fbdabbf56b6798bc0b73d16fe894d3b10e92a554a9245a361c2724f16c5a43
 SHA512:
-  metadata.gz: a62d25a0019c424bf4a441ba4b97bb53331da6f0b83ddfe3e3057b08c1fff42ffba6c4c9b1f253ff98b372063eca39cc44bf210ccad666fa7f6d1442e8ee04c0
-  data.tar.gz: 89dc13bc48ade930463e5f15fb866efc96ee442ca2a8404277e66741854cbf9dc9a67e1755e81bbc9dfac4ab62c967edc66f14b5c27c534a817eb8e56e49bec8
+  metadata.gz: c847a219fe05381929501d8789c40e2be73436910461b92219c96d4510eb6ef51eb8bf371ad8555532e3fe4f6111af5706272600c603d90fb884f0c65fba02e1
+  data.tar.gz: 213e3946bef1bc91de6f9e69614509f48061079233e71697658e8eec556fa6f12a5e940e8d509671a10b77fbf4216ec22e2d529646147ba638735b25f861b31e

data/README.md

@@ -2,32 +2,9 @@
 
 Ruby FFI bindings for the high-performance Tasker Core Rust orchestration engine.
 
-## Status: Foundation Complete ✅
+## Status
 
-The foundational structure has been successfully implemented and tested:
-
-- ✅ **Monorepo Integration**: Successfully integrated into the main tasker-core repository
-- ✅ **Cargo Workspace**: Properly configured as a workspace member
-- ✅ **Magnus FFI Setup**: Basic Ruby module initialization working
-- ✅ **Rust Compilation**: All Rust code compiles successfully
-- ✅ **Build System**: CI/CD workflows configured for cross-platform testing
-
-## Current Implementation
-
-This is a **foundational version** that establishes the structure:
-
-```rust
-// Ruby module available:
-TaskerCore::RUST_VERSION    # "0.1.0"
-TaskerCore::STATUS          # "foundation"
-TaskerCore::FEATURES        # "module_init"
-
-// Error classes defined:
-TaskerCore::Error
-TaskerCore::OrchestrationError
-TaskerCore::DatabaseError
-TaskerCore::FFIError
-```
+Production ready. Ruby FFI bindings provide full step handler execution via Magnus.
 
 ## Development Commands
 
@@ -45,15 +22,6 @@ rake spec
 rake setup
 ```
 
-## Next Phase: Full Implementation
-
-The next development phase will implement:
-
-1. **Complete WorkflowCoordinator API**
-2. **Ruby ↔ Rust type conversions**
-3. **Framework adapter for Rails integration**
-4. **Performance benchmarks and validation**
-
 ## Architecture
 
 This gem follows the **delegation-based architecture**:

data/ext/tasker_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tasker-rb"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 description = "Ruby bindings for tasker-core: High-performance workflow orchestration"
 readme = "../../../../README.md"

data/lib/tasker_core/client.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module TaskerCore
+  # High-level client wrapper around the TaskerCore FFI client methods.
+  #
+  # The raw FFI exposes `TaskerCore::FFI.client_create_task(hash)` and similar
+  # methods that require callers to construct complete request hashes with all
+  # required fields (initiator, source_system, reason, etc.) and return plain
+  # hashes. This module provides keyword-argument methods with sensible defaults
+  # and wraps responses into typed `ClientTypes::*` Dry::Struct objects.
+  #
+  # @example Creating a task with defaults
+  #   response = TaskerCore::Client.create_task(
+  #     name: 'process_order',
+  #     namespace: 'ecommerce',
+  #     context: { order_id: 123 }
+  #   )
+  #   response.task_uuid  # => "550e8400-..."
+  #   response.status     # => "pending"
+  #
+  # @example Getting a task
+  #   task = TaskerCore::Client.get_task("550e8400-...")
+  #   task.name       # => "process_order"
+  #   task.namespace  # => "ecommerce"
+  #
+  # @example Listing tasks with filters
+  #   list = TaskerCore::Client.list_tasks(namespace: 'ecommerce', limit: 10)
+  #   list.tasks.size  # => 3
+  #   list.pagination  # => { "total_count" => 42, ... }
+  module Client
+    module_function
+
+    # Create a task via the orchestration API.
+    #
+    # @param name [String] Named task template name
+    # @param namespace [String] Task namespace (default: "default")
+    # @param context [Hash] Workflow context passed to step handlers
+    # @param version [String] Template version (default: "1.0.0")
+    # @param initiator [String] Who initiated the request
+    # @param source_system [String] Originating system
+    # @param reason [String] Reason for creating the task
+    # @param options [Hash] Additional TaskRequest fields
+    # @return [ClientTypes::TaskResponse, Hash] Typed response or raw hash on schema mismatch
+    def create_task(name:, namespace: 'default', context: {}, version: '1.0.0',
+                    initiator: 'tasker-core-ruby', source_system: 'tasker-core',
+                    reason: 'Task requested', **options)
+      request = {
+        'name' => name,
+        'namespace' => namespace,
+        'version' => version,
+        'context' => deep_to_hash(context),
+        'initiator' => initiator,
+        'source_system' => source_system,
+        'reason' => reason
+      }
+      options.each { |k, v| request[k.to_s] = v }
+
+      response = TaskerCore::FFI.client_create_task(request)
+      wrap_response(response, Types::ClientTaskResponse)
+    end
+
+    # Get a task by UUID.
+    #
+    # @param task_uuid [String] The task UUID
+    # @return [ClientTypes::TaskResponse, Hash] Typed response or raw hash
+    def get_task(task_uuid)
+      response = TaskerCore::FFI.client_get_task(task_uuid.to_s)
+      wrap_response(response, Types::ClientTaskResponse)
+    end
+
+    # List tasks with optional filtering and pagination.
+    #
+    # @param limit [Integer] Maximum number of results (default: 50)
+    # @param offset [Integer] Pagination offset (default: 0)
+    # @param namespace [String, nil] Filter by namespace
+    # @param status [String, nil] Filter by status
+    # @return [ClientTypes::TaskListResponse, Hash] Typed response or raw hash
+    def list_tasks(limit: 50, offset: 0, namespace: nil, status: nil)
+      response = TaskerCore::FFI.client_list_tasks(limit, offset, namespace, status)
+      wrap_response(response, Types::ClientTaskListResponse)
+    end
+
+    # Cancel a task by UUID.
+    #
+    # @param task_uuid [String] The task UUID
+    # @return [Hash] Cancellation result
+    def cancel_task(task_uuid)
+      TaskerCore::FFI.client_cancel_task(task_uuid.to_s)
+    end
+
+    # List workflow steps for a task.
+    #
+    # @param task_uuid [String] The task UUID
+    # @return [Array<ClientTypes::StepResponse>, Array<Hash>] Typed steps or raw hashes
+    def list_task_steps(task_uuid)
+      response = TaskerCore::FFI.client_list_task_steps(task_uuid.to_s)
+      return response unless response.is_a?(Array)
+
+      response.map { |step| wrap_response(step, Types::ClientStepResponse) }
+    end
+
+    # Get a specific workflow step.
+    #
+    # @param task_uuid [String] The task UUID
+    # @param step_uuid [String] The step UUID
+    # @return [ClientTypes::StepResponse, Hash] Typed response or raw hash
+    def get_step(task_uuid, step_uuid)
+      response = TaskerCore::FFI.client_get_step(task_uuid.to_s, step_uuid.to_s)
+      wrap_response(response, Types::ClientStepResponse)
+    end
+
+    # Get audit history for a workflow step.
+    #
+    # @param task_uuid [String] The task UUID
+    # @param step_uuid [String] The step UUID
+    # @return [Array<ClientTypes::StepAuditResponse>, Array<Hash>] Typed audit entries or raw hashes
+    def get_step_audit_history(task_uuid, step_uuid)
+      response = TaskerCore::FFI.client_get_step_audit_history(task_uuid.to_s, step_uuid.to_s)
+      return response unless response.is_a?(Array)
+
+      response.map { |entry| wrap_response(entry, Types::ClientStepAuditResponse) }
+    end
+
+    # Check orchestration API health.
+    #
+    # @return [ClientTypes::HealthResponse, Hash] Typed response or raw hash
+    def health_check
+      response = TaskerCore::FFI.client_health_check
+      wrap_response(response, Types::ClientHealthResponse)
+    end
+
+    # @api private
+    # Wrap a raw FFI hash response into a Dry::Struct type.
+    # Falls back to the raw hash if the schema doesn't match,
+    # providing forward-compatibility when the API adds new fields.
+    def wrap_response(raw, type_class)
+      return raw unless raw.is_a?(Hash)
+
+      # Dry::Struct requires symbolized keys; raw FFI returns string keys
+      type_class.new(raw.transform_keys(&:to_sym))
+    rescue Dry::Struct::Error, KeyError, Dry::Types::ConstraintError
+      raw
+    end
+
+    # @api private
+    # Recursively convert ActionController::Parameters (and similar) to plain hashes/arrays.
+    def deep_to_hash(obj)
+      case obj
+      when Hash
+        obj.transform_values { |v| deep_to_hash(v) }
+      when Array
+        obj.map { |v| deep_to_hash(v) }
+      else
+        # Handle ActionController::Parameters if available (Rails contexts)
+        if obj.respond_to?(:to_unsafe_h)
+          obj.to_unsafe_h.transform_values { |v| deep_to_hash(v) }
+        else
+          obj
+        end
+      end
+    end
+
+    private_class_method :wrap_response, :deep_to_hash
+  end
+end

data/lib/tasker_core/registry/resolvers/class_constant_resolver.rb

@@ -125,7 +125,7 @@ module TaskerCore
         # @return [Boolean] true if responds to method
         def responds_to_method?(klass, method_name)
           # Check instance methods (most common case)
-          klass.instance_methods.include?(method_name) ||
+          klass.method_defined?(method_name) ||
             # Check if the class itself responds (for class methods)
             klass.respond_to?(method_name)
         end

data/lib/tasker_core/version.rb

@@ -3,7 +3,7 @@
 module TaskerCore
   # Version synchronization with the core Rust crate
   # This should be kept in sync with the Cargo.toml version
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 
   def self.version_info
     {

data/lib/tasker_core.rb

@@ -138,6 +138,7 @@ require_relative 'tasker_core/internal'
 require_relative 'tasker_core/template_discovery'
 require_relative 'tasker_core/test_environment'
 require_relative 'tasker_core/types'
+require_relative 'tasker_core/client'
 require_relative 'tasker_core/models'
 require_relative 'tasker_core/handlers'
 require_relative 'tasker_core/batch_processing/batch_worker_context'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tasker-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Pete Taylor
@@ -233,6 +233,7 @@ files:
 - lib/tasker_core/batch_processing/batch_aggregation_scenario.rb
 - lib/tasker_core/batch_processing/batch_worker_context.rb
 - lib/tasker_core/bootstrap.rb
+- lib/tasker_core/client.rb
 - lib/tasker_core/domain_events.rb
 - lib/tasker_core/domain_events/base_publisher.rb
 - lib/tasker_core/domain_events/base_subscriber.rb
@@ -268,7 +269,6 @@ files:
 - lib/tasker_core/step_handler/mixins/decision.rb
 - lib/tasker_core/subscriber.rb
 - lib/tasker_core/task_handler/base.rb
-- lib/tasker_core/tasker_rb.so
 - lib/tasker_core/template_discovery.rb
 - lib/tasker_core/tracing.rb
 - lib/tasker_core/types.rb