standard_procedure_operations 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9a47b950a0831c0bf0a1be69de7b7f75c80237ec73a75673397a0b8112aa846
-  data.tar.gz: 62e9741fcd4053d0f4139aa956f5d51025d644188b2da460d6b7550873257030
+  metadata.gz: 05e2b09556bdcf1a1be75461eb956d4be95e0a736c49cf7cf40d83feb16e7ee3
+  data.tar.gz: 5fadaecabdc294707fc6a82f57c8163390494c7bb57afddb2701a9bd35ee3cc6
 SHA512:
-  metadata.gz: 611b50e5912231a593187ea4dc59c5e270674f65413b1c3bbd34d3e1f40849f817954282750d729bdadf23a1bacb35b202c9fb71b2edaccfa59dddd209746234
-  data.tar.gz: 5b4fbf04648dfe9347330385f1dfdfc32eeadfe4adbb89a015a562c79b0a7b7f6e6b0e91b8d65f3d934e7f3af19bbaf8856ea39555cdd1b649f2ae9f2937ab81
+  metadata.gz: 5db051c5929ba86f92a0eff0417fd84bc5e0aa5f368d5ef66855b5ad94df5b205da996b96235ae8802b07fa954a09464fda892bc670fa30df65f59a7c20e67a5
+  data.tar.gz: d155b7c72d0f452f792e75cae431e196f8dd22d844e9953959ec95fa1582a963644777317ba33c7b1c74a43c28b38c4489ae166a1ebce64f83d1c58ad0d6c55d

data/README.md

@@ -295,7 +295,7 @@ For example, you create your task as:
 @alice = User.find 123
 @task = DoSomethingImportant.call user: @alice 
 ```
-There will not be a `TaskParticipant` record with a `context` of "data", `role` of "user" and `participant` of `@alice`.  
+There will be a `TaskParticipant` record with a `context` of "data", `role` of "user" and `participant` of `@alice`.  
 
 Likewise, you can see all the tasks that Alice was involved with using: 
 ```ruby
@@ -470,6 +470,16 @@ class WaitForSomething < Operations::Task
 end
 ```
 
+#### Zombie tasks
+
+There's a chance that the `Operations::TaskRunnerJob` might get lost - maybe there's a crash in some process and the job does not restart correctly.  As the process for handling background tasks relies on the task "waking up", performing the next action, then queuing up the next task-runner, if the background job does not queue as expected, the task will sit there, waiting forever.  
+
+To monitor for this, every task can be checked to see if it is a `zombie?`.  This means that the current time is more than 3 times the expected delay, compared to the `updated_at` field.  So if the `delay` is set to 1 minute and the task last woke up more than 3 minutes ago, it is classed as a zombie.  
+
+There are two ways to handle zombies.  
+- Manually; add a user interface listing your tasks with a "Restart" button.  The "Restart" button calls `restart` on the task (which internally schedules a new task runner job).
+- Automatically; set up a cron job which calls the `operations:restart_zombie_tasks` rake task.  This rake task searches for zombie jobs and calls `restart` on them.  Note that cron jobs have a minimum resolution of 1 minute so this will cause pauses in tasks with a delay measured in seconds.   Also be aware that a cron job that calls a rake task will load the entire Rails stack as a new process, so be sure that your server has sufficient memory to cope.  If you're using [SolidQueue](https://github.com/rails/solid_queue/), the job runner already sets up a separate "supervisor" process and allows you to define [recurring jobs](https://github.com/rails/solid_queue/#recurring-tasks) with a resolution of 1 second.  This may be a suitable solution, but I've not tried it yet.  
+
 ## Testing
 Because operations are intended to model long, complex, flowcharts of decisions and actions, it can be a pain coming up with the combinations of inputs to test every path through the sequence.  
 
@@ -550,20 +560,17 @@ If you are using RSpec, you must `require "operations/matchers"` to make the mat
 
 ## Visualization
 
-Operations tasks can be visualized as flowcharts using the built-in GraphViz exporter. This helps you understand the flow of your operations and can be useful for documentation.
+Operations tasks can be visualized as flowcharts using the built-in SVG exporter. This helps you understand the flow of your operations and can be useful for documentation.
 
 ```ruby
-# Export a task to GraphViz
-exporter = Operations::Exporters::Graphviz.new(MyTask)
-
-# Save as PNG
-exporter.save("my_task_flow.png")
+# Export a task to SVG
+exporter = Operations::Exporters::SVG.new(MyTask)
 
 # Save as SVG
-exporter.save("my_task_flow.svg", format: :svg)
+exporter.save("my_task_flow.svg")
 
-# Get DOT format
-dot_string = exporter.to_dot
+# Get SVG content directly
+svg_string = exporter.to_svg
 ```
 
 ### Custom Condition Labels
@@ -588,8 +595,6 @@ The visualization includes:
 - Transition conditions between states with custom labels when provided
 - Special handling for custom transition blocks
 
-Note: To use the GraphViz exporter, you need to have the GraphViz tool installed on your system. On macOS, you can install it with `brew install graphviz`, on Ubuntu with `apt-get install graphviz`, and on Windows with the installer from the [GraphViz website](https://graphviz.org/download/).
-
 ## Installation
 Step 1: Add the gem to your Rails application's Gemfile:
 ```ruby
@@ -632,5 +637,5 @@ The gem is available as open source under the terms of the [LGPL License](/LICEN
 - [x] Make Operations::Task work in the background using ActiveJob
 - [x] Add pause/resume capabilities (for example, when a task needs to wait for user input)
 - [x] Add wait for sub-tasks capabilities
-- [x] Add GraphViz visualization export for task flows
-- [ ] Option to change background job queue and priority settings
+- [x] Add visualization export for task flows
+- [ ] Option to change background job queue and priority settings

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

@@ -1,6 +1,11 @@
 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
 
@@ -15,9 +20,15 @@ module Operations::Task::Background
     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!

data/app/models/operations/task.rb

@@ -35,9 +35,10 @@ module Operations
     end
 
     def perform_later
-      waiting!
+      update! status: "waiting", becomes_zombie_at: Time.now + zombie_delay
       TaskRunnerJob.set(wait_until: background_delay.from_now).perform_later self
     end
+    alias_method :restart!, :perform_later
 
     def self.call(**)
       build(background: false, **).tap do |task|

data/db/migrate/20250403075414_add_becomes_zombie_at_field.rb

@@ -0,0 +1,6 @@
+class AddBecomesZombieAtField < ActiveRecord::Migration[8.0]
+  def change
+    add_column :operations_tasks, :becomes_zombie_at, :datetime, null: true
+    add_index :operations_tasks, :becomes_zombie_at
+  end
+end

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/version.rb

@@ -1,3 +1,3 @@
 module Operations
-  VERSION = "0.5.1"
+  VERSION = "0.5.3"
 end

data/lib/operations.rb

@@ -15,5 +15,5 @@ module Operations
   require "operations/cannot_wait_in_foreground"
   require "operations/timeout"
   require "operations/no_decision"
-  require "operations/exporters/graphviz"
+  require "operations/exporters/svg"
 end

data/lib/tasks/operations_tasks.rake

@@ -1,4 +1,4 @@
-# desc "Explaining what the task does"
-# task :operations do
-#   # Task goes here
-# end
+desc "Restart any zombie tasks"
+task :restart_zombie_tasks do
+  Operations::Task.restart_zombie_tasks
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: standard_procedure_operations
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -65,11 +65,12 @@ files:
 - app/models/operations/task_participant.rb
 - config/routes.rb
 - db/migrate/20250127160616_create_operations_tasks.rb
-- db/migrate/20250309_create_operations_task_participants.rb
+- db/migrate/20250309160616_create_operations_task_participants.rb
+- db/migrate/20250403075414_add_becomes_zombie_at_field.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/matchers.rb
 - lib/operations/no_decision.rb

data/lib/operations/exporters/graphviz.rb

@@ -1,164 +0,0 @@
-require "graphviz"
-
-module Operations
-  module Exporters
-    class Graphviz
-      attr_reader :task_class
-
-      def self.export(task_class)
-        new(task_class).to_dot
-      end
-
-      def initialize(task_class)
-        @task_class = task_class
-      end
-
-      # Generate a DOT representation of the task flow
-      def to_dot
-        graph.output(dot: String)
-      end
-
-      # Generate and save the graph to a file
-      # Supported formats: dot, png, svg, pdf, etc.
-      def save(filename, format: :png)
-        graph.output(format => filename)
-      end
-
-      # Generate GraphViz object representing the task flow
-      def graph
-        @graph ||= build_graph
-      end
-
-      private
-
-      def build_graph
-        task_hash = task_class.to_h
-        g = GraphViz.new(:G, type: :digraph, rankdir: "LR")
-
-        # Set up node styles
-        g.node[:shape] = "box"
-        g.node[:style] = "rounded"
-        g.node[:fontname] = "Arial"
-        g.node[:fontsize] = "12"
-        g.edge[:fontname] = "Arial"
-        g.edge[:fontsize] = "10"
-
-        # Create nodes for each state
-        nodes = {}
-        task_hash[:states].each do |state_name, state_info|
-          node_style = node_style_for(state_info[:type])
-          node_label = create_node_label(state_name, state_info)
-          nodes[state_name] = g.add_nodes(state_name.to_s, label: node_label, **node_style)
-        end
-
-        # Add edges for transitions
-        task_hash[:states].each do |state_name, state_info|
-          case state_info[:type]
-          when :decision
-            add_decision_edges(g, nodes, state_name, state_info[:transitions])
-          when :action
-            if state_info[:next_state]
-              g.add_edges(nodes[state_name], nodes[state_info[:next_state]])
-            end
-          when :wait
-            add_wait_edges(g, nodes, state_name, state_info[:transitions])
-          end
-        end
-
-        # Mark initial state
-        if nodes[task_hash[:initial_state]]
-          initial_node = g.add_nodes("START", shape: "circle", style: "filled", fillcolor: "#59a14f", fontcolor: "white")
-          g.add_edges(initial_node, nodes[task_hash[:initial_state]])
-        end
-
-        g
-      end
-
-      def node_style_for(type)
-        case type
-        when :decision
-          {shape: "diamond", style: "filled", fillcolor: "#4e79a7", fontcolor: "white"}
-        when :action
-          {shape: "box", style: "filled", fillcolor: "#f28e2b", fontcolor: "white"}
-        when :wait
-          {shape: "box", style: "filled,dashed", fillcolor: "#76b7b2", fontcolor: "white"}
-        when :result
-          {shape: "box", style: "filled", fillcolor: "#59a14f", fontcolor: "white"}
-        else
-          {shape: "box"}
-        end
-      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 add_decision_edges(graph, nodes, state_name, transitions)
-        # Get the handler for this state to access condition labels
-        task_state = task_class.respond_to?(:states) ? task_class.states[state_name.to_sym] : nil
-        handler = task_state[:handler] if task_state
-
-        transitions.each_with_index do |(condition, target), index|
-          # Get custom label if available
-          label = (handler&.respond_to?(:condition_labels) && handler.condition_labels[index]) ? handler.condition_labels[index] : target.to_s
-
-          if (target.is_a?(Symbol) || target.is_a?(String)) && nodes[target.to_sym]
-            graph.add_edges(nodes[state_name], nodes[target.to_sym], label: label)
-          elsif target.respond_to?(:call)
-            # Create a special node to represent the custom action
-            block_node_name = "#{state_name}_#{condition}_block"
-            block_node = graph.add_nodes(block_node_name,
-              label: "#{condition} Custom Action",
-              shape: "note",
-              style: "filled",
-              fillcolor: "#bab0ab",
-              fontcolor: "black")
-
-            graph.add_edges(nodes[state_name], block_node,
-              label: label,
-              style: "dashed")
-          end
-        end
-      end
-
-      def add_wait_edges(graph, nodes, state_name, transitions)
-        # Get the handler for this state to access condition labels
-        task_state = task_class.respond_to?(:states) ? task_class.states[state_name.to_sym] : nil
-        handler = task_state[:handler] if task_state
-
-        # Add a self-loop for wait condition
-        graph.add_edges(nodes[state_name], nodes[state_name],
-          label: "waiting",
-          style: "dashed",
-          constraint: "false",
-          dir: "back")
-
-        # Add edges for each transition
-        transitions.each_with_index do |(condition, target), index|
-          # Get custom label if available
-          label = (handler&.respond_to?(:condition_labels) && handler.condition_labels[index]) ? handler.condition_labels[index] : target.to_s
-
-          if (target.is_a?(Symbol) || target.is_a?(String)) && nodes[target.to_sym]
-            graph.add_edges(nodes[state_name], nodes[target.to_sym],
-              label: label,
-              style: "solid")
-          end
-        end
-      end
-    end
-  end
-end