circuit_breaker-wf 0.1.0

data/lib/circuit_breaker/executors/llm/memory.rb

@@ -0,0 +1,82 @@
+module CircuitBreaker
+  module Executors
+    module LLM
+      class Memory
+        attr_reader :messages, :metadata
+
+        def initialize
+          @messages = []
+          @metadata = {}
+        end
+
+        def add_message(role:, content:, metadata: {})
+          message = {
+            role: role,
+            content: content,
+            timestamp: Time.now.utc,
+            metadata: metadata
+          }
+          @messages << message
+          message
+        end
+
+        def get_context(window_size: nil)
+          messages_to_return = window_size ? @messages.last(window_size) : @messages
+          messages_to_return.map { |m| "#{m[:role]}: #{m[:content]}" }.join("\n")
+        end
+
+        def clear
+          @messages.clear
+          @metadata.clear
+        end
+
+        def to_h
+          {
+            messages: @messages,
+            metadata: @metadata
+          }
+        end
+      end
+
+      class ConversationMemory < Memory
+        def initialize(system_prompt: nil)
+          super()
+          add_message(role: 'system', content: system_prompt) if system_prompt
+        end
+
+        def add_user_message(content, metadata: {})
+          add_message(role: 'user', content: content, metadata: metadata)
+        end
+
+        def add_assistant_message(content, metadata: {})
+          add_message(role: 'assistant', content: content, metadata: metadata)
+        end
+      end
+
+      class ChainMemory < Memory
+        def initialize
+          super
+          @intermediate_steps = []
+        end
+
+        def add_step_result(step_name:, input:, output:, metadata: {})
+          @intermediate_steps << {
+            step_name: step_name,
+            input: input,
+            output: output,
+            timestamp: Time.now.utc,
+            metadata: metadata
+          }
+        end
+
+        def get_step_history
+          @intermediate_steps
+        end
+
+        def to_h
+          super.merge(intermediate_steps: @intermediate_steps)
+        end
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/llm/tools.rb

@@ -0,0 +1,94 @@
+require 'json'
+
+module CircuitBreaker
+  module Executors
+    module LLM
+      class Tool
+        attr_reader :name, :description, :parameters
+
+        def initialize(name:, description:, parameters: {})
+          @name = name
+          @description = description
+          @parameters = parameters
+        end
+
+        def execute(**args)
+          raise NotImplementedError, "#{self.class} must implement #execute"
+        end
+
+        def to_h
+          {
+            name: @name,
+            description: @description,
+            parameters: @parameters
+          }
+        end
+      end
+
+      class ToolKit
+        def initialize
+          @tools = {}
+        end
+
+        def add_tool(tool)
+          @tools[tool.name] = tool
+        end
+
+        def get_tool(name)
+          @tools[name]
+        end
+
+        def available_tools
+          @tools.values
+        end
+
+        def tool_descriptions
+          @tools.values.map(&:to_h)
+        end
+
+        def execute_tool(name, **args)
+          tool = get_tool(name)
+          raise "Tool '#{name}' not found" unless tool
+          tool.execute(**args)
+        end
+      end
+
+      # Example built-in tools
+      class SearchTool < Tool
+        def initialize
+          super(
+            name: 'search',
+            description: 'Search for information on a given topic',
+            parameters: {
+              query: { type: 'string', description: 'The search query' }
+            }
+          )
+        end
+
+        def execute(query:)
+          # Implement actual search logic here
+          { results: "Search results for: #{query}" }
+        end
+      end
+
+      class CalculatorTool < Tool
+        def initialize
+          super(
+            name: 'calculator',
+            description: 'Perform mathematical calculations',
+            parameters: {
+              expression: { type: 'string', description: 'The mathematical expression to evaluate' }
+            }
+          )
+        end
+
+        def execute(expression:)
+          # Implement safe evaluation logic here
+          { result: eval(expression).to_s }
+        rescue => e
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/nats_executor.rb

@@ -0,0 +1,230 @@
+require 'nats/client'
+require 'securerandom'
+require 'json'
+require_relative 'base_executor'
+
+module CircuitBreaker
+  module Executors
+    # Executor class that uses NATS for workflow event distribution
+    # Handles workflow state management and event processing
+    class NatsExecutor < BaseExecutor
+      # Reader for workflow ID
+      attr_reader :workflow_id
+      # Reader for NATS client
+      attr_reader :nats
+
+      # Initialize a new NATS executor
+      # @param context [Hash] Initialization context
+      # @option context [String] :nats_url URL of the NATS server (default: 'nats://localhost:4222')
+      def initialize(context = {})
+        super
+        @nats_url = context[:nats_url] || 'nats://localhost:4222'
+        @nats = NATS.connect(@nats_url)
+        setup_jetstream
+      end
+
+      def execute
+        return unless @context[:petri_net]
+
+        workflow_id = create_workflow(
+          @context[:petri_net],
+          workflow_id: @context[:workflow_id]
+        )
+
+        @result = {
+          workflow_id: workflow_id,
+          status: 'completed'
+        }
+      end
+
+      private
+
+      # Set up JetStream streams for workflow data
+      # Creates streams for workflow state, events, and current states
+      def setup_jetstream
+        @js = @nats.jetstream
+        
+        # Create streams for workflow state and events
+        @js.add_stream(name: 'WORKFLOWS', subjects: ['workflow.*'])
+        @js.add_stream(name: 'WORKFLOW_EVENTS', subjects: ['event.*'])
+        @js.add_stream(name: 'WORKFLOW_STATES', subjects: ['state.*'])
+      end
+
+      # Create a new workflow instance
+      # @param petri_net [Workflow] Workflow definition
+      # @param workflow_id [String, nil] Optional workflow ID
+      # @return [String] Workflow ID
+      def create_workflow(petri_net, workflow_id: nil)
+        @workflow_id = workflow_id || SecureRandom.uuid
+        puts "\n[Workflow] Creating new workflow with ID: #{@workflow_id}"
+        
+        # Store initial workflow state
+        @js.publish("workflow.#{@workflow_id}", 
+          petri_net.to_json,
+          headers: { 'Nats-Msg-Type' => 'workflow.create' }
+        )
+        
+        # Subscribe to workflow events
+        @nats.subscribe("event.#{@workflow_id}") do |msg, reply, subject|
+          handle_event(msg)
+        end
+        
+        @workflow_id
+      end
+
+      # Handle incoming workflow events
+      # @param msg [String] JSON-encoded event message
+      def handle_event(msg)
+        event = JSON.parse(msg)
+        puts "\n[Event] Received event: #{event['type']}"
+        
+        case event['type']
+        when 'token_added'
+          handle_token_added(event)
+        when 'transition_fired'
+          handle_transition_fired(event)
+        when 'workflow_completed'
+          handle_workflow_completed(event)
+        end
+      end
+
+      # Handle token added event
+      # @param event [Hash] Event data
+      def handle_token_added(event)
+        puts "\n[Handler] Token added to place: #{event['place']} with data: #{event['data'].inspect}"
+        # Publish state change
+        @js.publish("state.#{@workflow_id}",
+          event.to_json,
+          headers: { 'Nats-Msg-Type' => 'state.token_added' }
+        )
+        
+        # Check if any serverless functions need to be triggered
+        check_and_trigger_functions(event['place'])
+      end
+
+      # Handle transition fired event
+      # @param event [Hash] Event data
+      def handle_transition_fired(event)
+        puts "\n[Handler] Transition fired: #{event['transition']}"
+        @js.publish("state.#{@workflow_id}",
+          event.to_json,
+          headers: { 'Nats-Msg-Type' => 'state.transition_fired' }
+        )
+      end
+
+      # Handle workflow completed event
+      # @param event [Hash] Event data
+      def handle_workflow_completed(event)
+        puts "\n[Handler] Workflow completed#{event['next_workflow'] ? ' with next workflow configured' : ''}"
+        @js.publish("state.#{@workflow_id}",
+          event.to_json,
+          headers: { 'Nats-Msg-Type' => 'state.completed' }
+        )
+        
+        # If there's a next workflow to trigger
+        if event['next_workflow']
+          trigger_next_workflow(event['next_workflow'])
+        end
+      end
+
+      # Check if any serverless functions need to be triggered
+      # @param place [String] Place in the workflow
+      def check_and_trigger_functions(place)
+        # Get function configuration for this place
+        function_config = get_function_config(place)
+        return unless function_config
+        
+        # Publish event to trigger serverless function
+        @js.publish("function.#{function_config['name']}",
+          {
+            workflow_id: @workflow_id,
+            place: place,
+            config: function_config
+          }.to_json,
+          headers: { 'Nats-Msg-Type' => 'function.trigger' }
+        )
+      end
+
+      # Get function configuration for a given place
+      # @param place [String] Place in the workflow
+      # @return [Hash] Function configuration
+      def get_function_config(place)
+        # This would be loaded from a configuration store
+        # For now, returning a mock config
+        {
+          'name' => "function_#{place}",
+          'runtime' => 'ruby',
+          'handler' => 'handle',
+          'environment' => {}
+        }
+      end
+
+      # Trigger a new workflow instance
+      # @param next_workflow_config [Hash] Configuration for the next workflow
+      def trigger_next_workflow(next_workflow_config)
+        new_workflow_id = SecureRandom.uuid
+        
+        # Create the new workflow
+        create_workflow(
+          next_workflow_config['petri_net'],
+          workflow_id: new_workflow_id
+        )
+        
+        # Link the workflows
+        @js.publish("workflow.#{@workflow_id}.next",
+          {
+            previous_workflow_id: @workflow_id,
+            next_workflow_id: new_workflow_id
+          }.to_json,
+          headers: { 'Nats-Msg-Type' => 'workflow.link' }
+        )
+      end
+
+      # Add a token to a place in the workflow
+      # @param place [String] Place in the workflow
+      # @param data [Hash, nil] Optional data for the token
+      def add_token(place, data = nil)
+        puts "\n[Token] Adding token to place: #{place} with data: #{data.inspect}"
+        @js.publish("event.#{@workflow_id}",
+          {
+            type: 'token_added',
+            place: place,
+            data: data,
+            timestamp: Time.now.utc.iso8601
+          }.to_json,
+          headers: { 'Nats-Msg-Type' => 'event.token_added' }
+        )
+      end
+
+      # Fire a transition in the workflow
+      # @param transition_name [String] Name of the transition
+      def fire_transition(transition_name)
+        puts "\n[Transition] Firing transition: #{transition_name}"
+        @js.publish("event.#{@workflow_id}",
+          {
+            type: 'transition_fired',
+            transition: transition_name,
+            timestamp: Time.now.utc.iso8601
+          }.to_json,
+          headers: { 'Nats-Msg-Type' => 'event.transition_fired' }
+        )
+      end
+
+      # Complete the workflow
+      # @param next_workflow [Hash, nil] Optional configuration for the next workflow
+      def complete_workflow(next_workflow = nil)
+        puts "\n[Workflow] Completing workflow#{next_workflow ? ' and triggering next workflow' : ''}"
+        event_data = {
+          type: 'workflow_completed',
+          next_workflow: next_workflow,
+          timestamp: Time.now.utc.iso8601
+        }
+        
+        @js.publish("event.#{@workflow_id}",
+          event_data.to_json,
+          headers: { 'Nats-Msg-Type' => 'event.workflow_completed' }
+        )
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/serverless_executor.rb

@@ -0,0 +1,25 @@
+require_relative 'base_executor'
+
+module CircuitBreaker
+  module Executors
+    class ServerlessExecutor < BaseExecutor
+      def initialize(context = {})
+        super
+        @function_name = context[:function_name]
+        @runtime = context[:runtime]
+        @payload = context[:payload]
+      end
+
+      def execute
+        # Implementation for serverless function execution would go here
+        # This would typically involve invoking a serverless function
+        @result = {
+          function_name: @function_name,
+          runtime: @runtime,
+          payload: @payload,
+          status: 'completed'
+        }
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/step_executor.rb

@@ -0,0 +1,47 @@
+require_relative 'base_executor'
+
+module CircuitBreaker
+  module Executors
+    class StepExecutor < BaseExecutor
+      def initialize(context = {})
+        super
+        @steps = context[:steps] || []
+        @parallel = context[:parallel] || false
+      end
+
+      def execute
+        results = if @parallel
+          execute_parallel
+        else
+          execute_sequential
+        end
+
+        @result = {
+          steps: results,
+          status: 'completed'
+        }
+      end
+
+      private
+
+      def execute_sequential
+        @steps.map do |step|
+          executor = step[:executor].new(step[:context])
+          executor.execute
+          executor.to_h
+        end
+      end
+
+      def execute_parallel
+        threads = @steps.map do |step|
+          Thread.new do
+            executor = step[:executor].new(step[:context])
+            executor.execute
+            executor.to_h
+          end
+        end
+        threads.map(&:value)
+      end
+    end
+  end
+end

data/lib/circuit_breaker/history.rb

@@ -0,0 +1,81 @@
+module CircuitBreaker
+  module History
+    class Entry
+      attr_reader :timestamp, :type, :details, :actor_id
+
+      def initialize(type:, details:, actor_id: nil)
+        @timestamp = Time.now
+        @type = type
+        @details = details
+        @actor_id = actor_id
+      end
+
+      def to_h
+        {
+          timestamp: timestamp,
+          type: type,
+          details: details,
+          actor_id: actor_id
+        }
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        attr_reader :history
+
+        # Add history initialization to existing initialize method
+        original_initialize = instance_method(:initialize)
+        define_method(:initialize) do |*args, **kwargs|
+          original_initialize.bind(self).call(*args, **kwargs)
+          @history = []
+          record_event(:created, "Object created")
+        end
+      end
+    end
+
+    def record_event(type, details, actor_id: nil)
+      entry = Entry.new(type: type, details: details, actor_id: actor_id)
+      @history << entry
+      trigger(:history_updated, entry: entry)
+      entry
+    end
+
+    def history_since(timestamp)
+      history.select { |entry| entry.timestamp >= timestamp }
+    end
+
+    def history_by_type(type)
+      history.select { |entry| entry.type == type }
+    end
+
+    def history_by_actor(actor_id)
+      history.select { |entry| entry.actor_id == actor_id }
+    end
+
+    def export_history(format = :json)
+      history_data = history.map(&:to_h)
+      case format
+      when :json
+        JSON.pretty_generate(history_data)
+      when :yaml
+        history_data.to_yaml
+      when :csv
+        require 'csv'
+        CSV.generate do |csv|
+          csv << ['Timestamp', 'Type', 'Details', 'Actor']
+          history_data.each do |entry|
+            csv << [
+              entry[:timestamp].iso8601,
+              entry[:type],
+              entry[:details],
+              entry[:actor_id]
+            ]
+          end
+        end
+      else
+        raise ArgumentError, "Unsupported format: #{format}"
+      end
+    end
+  end
+end