standard_procedure_operations 0.5.2 → 0.6.0

data/lib/operations/exporters/svg.rb

@@ -0,0 +1,399 @@
+module Operations
+  module Exporters
+    # A pure Ruby SVG exporter for task visualization with no external dependencies
+    class SVG
+      attr_reader :task_class
+
+      COLORS = {
+        decision: "#4e79a7",  # Blue
+        action: "#f28e2b",    # Orange
+        wait: "#76b7b2",      # Teal
+        result: "#59a14f",    # Green
+        start: "#59a14f",     # Green
+        block: "#bab0ab"      # Grey
+      }
+
+      def self.export(task_class)
+        new(task_class).to_svg
+      end
+
+      def initialize(task_class)
+        @task_class = task_class
+        @node_positions = {}
+        @next_id = 0
+      end
+
+      # Generate SVG representation of the task flow
+      def to_svg
+        task_hash = task_class.to_h
+
+        # Calculate node positions using simple layout algorithm
+        calculate_node_positions(task_hash)
+
+        # Generate SVG
+        generate_svg(task_hash)
+      end
+
+      # Save the SVG to a file
+      def save(filename, format: :svg)
+        if format != :svg && format != :png
+          raise ArgumentError, "Only SVG format is supported without GraphViz"
+        end
+
+        File.write(filename, to_svg)
+      end
+
+      private
+
+      def generate_id
+        id = "node_#{@next_id}"
+        @next_id += 1
+        id
+      end
+
+      def calculate_node_positions(task_hash)
+        # Simple layout algorithm that positions nodes in columns by state type
+        # This is a minimal implementation; a real layout algorithm would be more complex
+
+        # Group nodes by type for column-based layout
+        nodes_by_type = {decision: [], action: [], wait: [], result: []}
+
+        task_hash[:states].each do |state_name, state_info|
+          nodes_by_type[state_info[:type]] << state_name if nodes_by_type.key?(state_info[:type])
+        end
+
+        # Process destination states from the go_to transitions to ensure they're included
+        task_hash[:states].each do |state_name, state_info|
+          state_info[:transitions]&.each do |_, target|
+            next if target.nil? || target.is_a?(Proc)
+            target_sym = target.to_sym
+
+            # Ensure target state exists in task hash
+            unless task_hash[:states].key?(target_sym)
+              # This is a placeholder for a missing state (likely a result)
+              task_hash[:states][target_sym] = {type: :result}
+              nodes_by_type[:result] << target_sym if nodes_by_type.key?(:result)
+            end
+          end
+
+          # Also process next_state for actions
+          if state_info[:next_state] && !task_hash[:states].key?(state_info[:next_state])
+            task_hash[:states][state_info[:next_state]] = {type: :result}
+            nodes_by_type[:result] << state_info[:next_state] if nodes_by_type.key?(:result)
+          end
+        end
+
+        # Calculate positions (this is simplified - a real algorithm would handle edge crossings better)
+        x_offset = 200  # Increased from 100 to give more space
+        column_width = 200
+        row_height = 150
+
+        # Position initial state (usually a decision)
+        task_hash[:initial_state]
+        @node_positions["START"] = [100, 100]  # Moved START from 50 to 100
+
+        # Position nodes by type in columns
+        [:decision, :action, :wait, :result].each_with_index do |type, col_idx|
+          nodes_by_type[type].each_with_index do |node_name, row_idx|
+            # Position nodes in a grid layout
+            x = x_offset + (col_idx * column_width)
+            y = 100 + (row_idx * row_height)
+            @node_positions[node_name] = [x, y]
+          end
+        end
+      end
+
+      def generate_svg(task_hash)
+        # SVG dimensions based on node positions
+        max_x = @node_positions.values.map(&:first).max + 150
+        max_y = @node_positions.values.map(&:last).max + 150
+
+        # Start SVG document
+        svg = <<~SVG
+          <svg xmlns="http://www.w3.org/2000/svg" width="#{max_x}" height="#{max_y}" viewBox="0 0 #{max_x} #{max_y}">
+            <defs>
+              <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#333" />
+              </marker>
+            </defs>
+        SVG
+
+        # Draw edges (connections between nodes)
+        svg += draw_edges(task_hash)
+
+        # Draw all nodes
+        svg += draw_nodes(task_hash)
+
+        # Close SVG document
+        svg += "</svg>"
+
+        svg
+      end
+
+      def draw_nodes(task_hash)
+        svg = ""
+
+        # Add starting node
+        if task_hash[:initial_state] && @node_positions[task_hash[:initial_state]]
+          svg += draw_circle(
+            @node_positions["START"][0],
+            @node_positions["START"][1],
+            20,
+            COLORS[:start],
+            "START"
+          )
+        end
+
+        # Add nodes for each state
+        task_hash[:states].each do |state_name, state_info|
+          next unless @node_positions[state_name]
+
+          x, y = @node_positions[state_name]
+          node_label = create_node_label(state_name, state_info)
+
+          svg += case state_info[:type]
+          when :decision
+            draw_diamond(x, y, 120, 80, COLORS[:decision], node_label)
+          when :action
+            draw_rectangle(x, y, 160, 80, COLORS[:action], node_label)
+          when :wait
+            draw_rectangle(x, y, 160, 80, COLORS[:wait], node_label, dashed: true)
+          when :result
+            draw_rectangle(x, y, 160, 80, COLORS[:result], node_label)
+          else
+            draw_rectangle(x, y, 160, 80, "#cccccc", node_label)
+          end
+        end
+
+        svg
+      end
+
+      def draw_edges(task_hash)
+        svg = ""
+
+        # Add edge from START to initial state
+        if task_hash[:initial_state] && @node_positions[task_hash[:initial_state]]
+          start_x, start_y = @node_positions["START"]
+          end_x, end_y = @node_positions[task_hash[:initial_state]]
+          svg += draw_arrow(start_x + 20, start_y, end_x - 60, end_y, "")
+        end
+
+        # Add edges for transitions
+        task_hash[:states].each do |state_name, state_info|
+          case state_info[:type]
+          when :decision
+            state_info[:transitions]&.each do |condition, target|
+              # Skip Proc targets as they're custom actions or nil targets
+              next if target.nil? || target.is_a?(Proc)
+
+              if @node_positions[state_name] && @node_positions[target.to_sym]
+                start_x, start_y = @node_positions[state_name]
+                end_x, end_y = @node_positions[target.to_sym]
+
+                # Use condition as label, or target state name if no condition
+                label = condition.to_s
+                if label.empty? || label == "nil"
+                  label = "→ #{target}"
+                end
+
+                svg += draw_arrow(start_x + 60, start_y, end_x - 80, end_y, label)
+              end
+            end
+          when :action
+            if state_info[:next_state] && @node_positions[state_name] && @node_positions[state_info[:next_state]]
+              start_x, start_y = @node_positions[state_name]
+              end_x, end_y = @node_positions[state_info[:next_state]]
+              label = "→ #{state_info[:next_state]}"
+              svg += draw_arrow(start_x + 80, start_y, end_x - 80, end_y, label)
+            end
+          when :wait
+            # Add a self-loop for wait condition
+            if @node_positions[state_name]
+              x, y = @node_positions[state_name]
+              svg += draw_self_loop(x, y, 160, 80, "waiting")
+
+              # Add transitions
+              state_info[:transitions]&.each do |condition, target|
+                # Skip Proc targets or nil targets
+                next if target.nil? || target.is_a?(Proc)
+
+                if @node_positions[target.to_sym]
+                  start_x, start_y = @node_positions[state_name]
+                  end_x, end_y = @node_positions[target.to_sym]
+
+                  # Use condition as label, or target state name if no condition
+                  label = condition.to_s
+                  if label.empty? || label == "nil"
+                    label = "→ #{target}"
+                  end
+
+                  svg += draw_arrow(start_x + 80, start_y, end_x - 80, end_y, label)
+                end
+              end
+            end
+          end
+        end
+
+        svg
+      end
+
+      # Helper methods for drawing SVG elements
+
+      def draw_rectangle(x, y, width, height, color, text, dashed: false)
+        style = dashed ? "fill:#{color};stroke:#333;stroke-width:2;stroke-dasharray:5,5;" : "fill:#{color};stroke:#333;stroke-width:2;"
+
+        # Create a unique ID for a group to contain both the shape and text
+        id = "rect-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <rect x="#{x - width / 2}" y="#{y - height / 2}" width="#{width}" height="#{height}" rx="10" ry="10" style="#{style}" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_diamond(x, y, width, height, color, text)
+        points = [
+          [x, y - height / 2],
+          [x + width / 2, y],
+          [x, y + height / 2],
+          [x - width / 2, y]
+        ].map { |px, py| "#{px},#{py}" }.join(" ")
+
+        # Create a unique ID for a group to contain both the shape and text
+        id = "diamond-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <polygon points="#{points}" style="fill:#{color};stroke:#333;stroke-width:2;" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_circle(x, y, radius, color, text)
+        # Create a unique ID for a group to contain both the shape and text
+        id = "circle-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <circle cx="#{x}" cy="#{y}" r="#{radius}" style="fill:#{color};stroke:#333;stroke-width:2;" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_arrow(x1, y1, x2, y2, label, dashed: false)
+        # Calculate the line and add an offset to avoid overlap with nodes
+        dx = x2 - x1
+        dy = y2 - y1
+        length = Math.sqrt(dx * dx + dy * dy)
+
+        # Make sure we don't divide by zero
+        if length.zero?
+          return ""
+        end
+
+        # Calculate control points for a slight curve
+        # This helps when there are multiple edges between the same nodes
+        mx = (x1 + x2) / 2
+        my = (y1 + y2) / 2
+
+        # Add slight curve for better visualization
+        cx = mx + dy * 0.2
+        cy = my - dx * 0.2
+
+        style = dashed ? "stroke:#333;stroke-width:2;fill:none;stroke-dasharray:5,5;" : "stroke:#333;stroke-width:2;fill:none;"
+        marker = "marker-end=\"url(#arrowhead)\""
+
+        # Create a unique ID for a group to contain both the path and label
+        id = "arrow-#{generate_id}"
+
+        svg = <<~SVG
+          <g id="#{id}">
+            <path d="M#{x1},#{y1} Q#{cx},#{cy} #{x2},#{y2}" style="#{style}" #{marker} />
+        SVG
+
+        # Add label if provided
+        if label && !label.empty?
+          # Create a white background for the label to improve readability
+          svg += <<~SVG
+            <rect x="#{mx + dy * 0.1 - 40}" y="#{my - dx * 0.1 - 10}" width="80" height="20" rx="5" ry="5" fill="white" fill-opacity="0.8" />
+            <text x="#{mx + dy * 0.1}" y="#{my - dx * 0.1}" text-anchor="middle" fill="#333" font-family="Arial" font-size="10px">#{escape_text(label)}</text>
+          SVG
+        end
+
+        svg += "</g>"
+        svg
+      end
+
+      def draw_self_loop(x, y, width, height, label)
+        # Create a self-loop arrow (circle with an arrow)
+        style = "stroke:#333;stroke-width:2;fill:none;stroke-dasharray:5,5;"
+
+        # Create a unique ID for a group to contain both the loop and label
+        id = "loop-#{generate_id}"
+
+        svg = <<~SVG
+          <g id="#{id}">
+            <ellipse cx="#{x - width / 2}" cy="#{y}" rx="20" ry="30" style="#{style}" />
+            <path d="M#{x - width / 2 - 10},#{y - 10} L#{x - width / 2 - 20},#{y} L#{x - width / 2 - 10},#{y + 10}" style="stroke:#333;stroke-width:2;fill:none;" />
+        SVG
+
+        # Add label with background
+        label_x = x - width / 2 - 30
+        label_y = y - 25
+
+        svg += <<~SVG
+            <rect x="#{label_x - 30}" y="#{label_y - 10}" width="60" height="20" rx="5" ry="5" fill="white" fill-opacity="0.8" />
+            <text x="#{label_x}" y="#{label_y}" text-anchor="middle" fill="#333" font-family="Arial" font-size="10px">#{escape_text(label)}</text>
+          </g>
+        SVG
+
+        svg
+      end
+
+      def create_node_label(state_name, state_info)
+        label = state_name.to_s
+
+        # Add inputs if present
+        if state_info[:inputs].present?
+          inputs_list = state_info[:inputs].map(&:to_s).join(", ")
+          label += "\nInputs: #{inputs_list}"
+        end
+
+        # Add optional inputs if present
+        if state_info[:optional_inputs].present?
+          optional_list = state_info[:optional_inputs].map(&:to_s).join(", ")
+          label += "\nOptional: #{optional_list}"
+        end
+
+        label
+      end
+
+      def escape_text(text)
+        # Split the text into lines for multi-line support
+        lines = text.to_s.split("\n")
+
+        if lines.length <= 1
+          # Simple case: just escape the text for a single line
+          return text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+        end
+
+        # For multi-line text, create tspan elements with proper alignment
+        line_height = 1.2 # em units
+        total_height = (lines.length - 1) * line_height
+        y_offset = -total_height / 2 # Start at negative half height to center vertically
+
+        # Escape XML special characters and add tspan elements for multi-line text
+        lines.map do |line|
+          line_text = line.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+          tspan = "<tspan x=\"0\" y=\"#{y_offset}em\" text-anchor=\"middle\">#{line_text}</tspan>"
+          y_offset += line_height # Move down for next line
+          tspan
+        end.join("")
+      end
+    end
+  end
+end

data/lib/operations/has_data_attributes.rb

@@ -0,0 +1,50 @@
+# TODO: Move this into its own gem as I'm already using elsewhere
+module Operations::HasDataAttributes
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def data_attribute_in field_name, name, cast_type = :string, **options
+      name = name.to_sym
+      typecaster = cast_type.nil? ? nil : ActiveRecord::Type.lookup(cast_type)
+      typecast_value = ->(value) { typecaster.nil? ? value : typecaster.cast(value) }
+      define_attribute_method name
+      if cast_type != :boolean
+        define_method(name) { typecast_value.call(send(field_name.to_sym)[name]) || options[:default] }
+      else
+        define_method(name) do
+          value = typecast_value.call(send(field_name.to_sym)[name])
+          [true, false].include?(value) ? value : options[:default]
+        end
+        alias_method :"#{name}?", name
+      end
+      define_method(:"#{name}=") do |value|
+        attribute_will_change! name
+        send(field_name.to_sym)[name] = typecast_value.call(value)
+      end
+    end
+
+    def model_attribute_in field_name, name, class_name = nil, **options
+      id_attribute_name = :"#{name}_global_id"
+      data_attribute_in field_name, id_attribute_name, :string, **options
+
+      define_method(name.to_sym) do
+        id = send id_attribute_name.to_sym
+        id.nil? ? nil : GlobalID::Locator.locate(id)
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end
+
+      define_method(:"#{name}=") do |model|
+        raise ArgumentError.new("#{model} is not #{class_name} - #{name}") if class_name.present? && model.present? && !model.is_a?(class_name.constantize)
+        id = model.nil? ? nil : model.to_global_id.to_s
+        send :"#{id_attribute_name}=", id
+      end
+    end
+
+    def data_attributes(*attributes) = attributes.each { |attribute| data_attribute(attribute) }
+
+    def data_attribute(name, cast_type = nil, **options) = data_attribute_in :data, name, cast_type, **options
+
+    def data_model(name, class_name = nil, **options) = model_attribute_in :data, name, class_name, **options
+  end
+end

data/lib/operations/invalid_state.rb

@@ -0,0 +1,2 @@
+class Operations::InvalidState < Operations::Error
+end

data/lib/operations/version.rb

@@ -1,3 +1,3 @@
 module Operations
-  VERSION = "0.5.2"
+  VERSION = "0.6.0"
 end

data/lib/operations.rb

@@ -9,11 +9,12 @@ module Operations
     end
     attr_reader :task
   end
+  require "operations/has_data_attributes"
   require "operations/version"
   require "operations/engine"
   require "operations/failure"
-  require "operations/cannot_wait_in_foreground"
   require "operations/timeout"
   require "operations/no_decision"
-  require "operations/exporters/graphviz"
+  require "operations/invalid_state"
+  require "operations/exporters/svg"
 end

data/lib/tasks/operations_tasks.rake

@@ -1,4 +1,4 @@
-desc "Restart any zombie tasks"
-task :restart_zombie_tasks do
-  Operations::Task.restart_zombie_tasks
+desc "Start the Agent Runner process"
+task :agent_runner do
+  Operations::Agent::Runner.start
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: standard_procedure_operations
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -47,31 +47,40 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/jobs/operations/agent/find_timeouts_job.rb
+- app/jobs/operations/agent/runner_job.rb
+- app/jobs/operations/agent/timeout_job.rb
+- app/jobs/operations/agent/wake_agents_job.rb
 - app/jobs/operations/application_job.rb
-- app/jobs/operations/task_runner_job.rb
 - app/models/concerns/operations/participant.rb
+- app/models/operations/agent.rb
+- app/models/operations/agent/interaction_handler.rb
+- app/models/operations/agent/plan.rb
+- app/models/operations/agent/runner.rb
+- app/models/operations/agent/wait_handler.rb
 - app/models/operations/task.rb
-- app/models/operations/task/background.rb
 - app/models/operations/task/data_carrier.rb
 - app/models/operations/task/deletion.rb
 - app/models/operations/task/exports.rb
 - app/models/operations/task/input_validation.rb
-- app/models/operations/task/state_management.rb
-- app/models/operations/task/state_management/action_handler.rb
-- app/models/operations/task/state_management/completion_handler.rb
-- app/models/operations/task/state_management/decision_handler.rb
-- app/models/operations/task/state_management/wait_handler.rb
+- app/models/operations/task/plan.rb
+- app/models/operations/task/plan/action_handler.rb
+- app/models/operations/task/plan/decision_handler.rb
+- app/models/operations/task/plan/result_handler.rb
 - app/models/operations/task/testing.rb
 - app/models/operations/task_participant.rb
 - config/routes.rb
 - db/migrate/20250127160616_create_operations_tasks.rb
 - db/migrate/20250309160616_create_operations_task_participants.rb
-- db/migrate/20250403075414_add_becomes_zombie_at_field.rb
+- db/migrate/20250404085321_add_becomes_zombie_at_field.operations.rb
+- db/migrate/20250407143513_agent_fields.rb
+- db/migrate/20250408124423_add_task_participant_indexes.rb
 - lib/operations.rb
-- lib/operations/cannot_wait_in_foreground.rb
 - lib/operations/engine.rb
-- lib/operations/exporters/graphviz.rb
+- lib/operations/exporters/svg.rb
 - lib/operations/failure.rb
+- lib/operations/has_data_attributes.rb
+- lib/operations/invalid_state.rb
 - lib/operations/matchers.rb
 - lib/operations/no_decision.rb
 - lib/operations/timeout.rb

data/app/jobs/operations/task_runner_job.rb

@@ -1,11 +0,0 @@
-module Operations
-  class TaskRunnerJob < ApplicationJob
-    queue_as :default
-
-    def perform task
-      task.perform if task.waiting?
-    rescue => ex
-      Rails.logger.error "TaskRunnerJob failed: #{ex.message} for #{task.inspect}"
-    end
-  end
-end

data/app/models/operations/task/background.rb

@@ -1,39 +0,0 @@
-module Operations::Task::Background
-  extend ActiveSupport::Concern
-
-  included do
-    scope :zombies, -> { zombies_at(Time.now) }
-    scope :zombies_at, ->(time) { where(becomes_zombie_at: ..time) }
-  end
-
-  class_methods do
-    def delay(value) = @background_delay = value
-
-    def timeout(value) = @execution_timeout = value
-
-    def on_timeout(&handler) = @on_timeout = handler
-
-    def background_delay = @background_delay ||= 1.second
-
-    def execution_timeout = @execution_timeout ||= 5.minutes
-
-    def timeout_handler = @on_timeout
-
-    def with_timeout(data) = data.merge(_execution_timeout: execution_timeout.from_now.utc)
-
-    def restart_zombie_tasks = zombies.find_each { |t| t.restart! }
-  end
-
-  def zombie? = Time.now > (updated_at + zombie_delay)
-
-  private def background_delay = self.class.background_delay
-  private def zombie_delay = background_delay * 3
-  private def zombie_time = becomes_zombie_at || Time.now
-  private def execution_timeout = self.class.execution_timeout
-  private def timeout_handler = self.class.timeout_handler
-  private def timeout!
-    return unless timeout_expired?
-    timeout_handler.nil? ? raise(Operations::Timeout.new("Timeout expired", self)) : timeout_handler.call
-  end
-  private def timeout_expired? = data[:_execution_timeout].present? && data[:_execution_timeout] < Time.now.utc
-end

data/lib/operations/cannot_wait_in_foreground.rb

@@ -1,2 +0,0 @@
-class Operations::CannotWaitInForeground < Operations::Error
-end