ruby_reactor 0.1.0 → 0.2.0

data/lib/ruby_reactor/step/map_step.rb

@@ -88,6 +88,25 @@ module RubyReactor
 
           link_contexts(child_context, context)
 
+          map_id = "#{context.context_id}:#{context.current_step}"
+          storage = RubyReactor.configuration.storage_adapter
+          storage.store_map_element_context_id(map_id, child_context.context_id, context.reactor_class.name)
+
+          # Set map metadata for failure handling
+          child_context.map_metadata = {
+            map_id: map_id,
+            parent_reactor_class_name: context.reactor_class.name,
+            index: nil # Inline map execution doesn't track index in metadata currently, but could
+          }
+
+          # Store reference in composed_contexts so the UI knows where to find elements
+          context.composed_contexts[context.current_step] = {
+            name: context.current_step,
+            type: :map_ref,
+            map_id: map_id,
+            element_reactor_class: arguments[:mapped_reactor_class].name
+          }
+
           executor = RubyReactor::Executor.new(arguments[:mapped_reactor_class], {}, child_context)
           executor.execute
           executor.result
@@ -134,7 +153,7 @@ module RubyReactor
         def run_async(arguments, context, step_name)
           map_id = "#{context.context_id}:#{step_name}"
           context.map_operations[step_name.to_s] = map_id
-          prepare_async_execution(context, map_id, arguments[:source].count)
+          prepare_async_execution(context, map_id, arguments[:source].size)
 
           reactor_class_info = build_reactor_class_info(arguments[:mapped_reactor_class], context, step_name)
 
@@ -151,6 +170,14 @@ module RubyReactor
                                          reactor_class_info: reactor_class_info, step_name: step_name)
                    end
 
+          # Store reference in composed_contexts so the UI knows where to find elements
+          context.composed_contexts[step_name.to_s] = {
+            name: step_name.to_s,
+            type: :map_ref,
+            map_id: map_id,
+            element_reactor_class: arguments[:mapped_reactor_class].name
+          }
+
           RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: context.intermediate_results)
         end
 
@@ -174,11 +201,11 @@ module RubyReactor
           # rubocop:enable Metrics/ParameterLists
           storage = RubyReactor.configuration.storage_adapter
           storage.initialize_map_operation(
-            map_id, arguments[:source].count, context.reactor_class.name,
+            map_id, arguments[:source].size, context.reactor_class.name,
             strict_ordering: arguments[:strict_ordering], reactor_class_info: reactor_class_info
           )
 
-          limit ||= arguments[:source].count
+          limit ||= arguments[:source].size
           first_job_id = nil
           arguments[:source].each_with_index do |element, index|
             break if index >= limit

data/lib/ruby_reactor/storage/adapter.rb

@@ -46,6 +46,38 @@ module RubyReactor
       def expire(key, seconds)
         raise NotImplementedError
       end
+
+      def store_correlation_id(correlation_id, context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def retrieve_context_id_by_correlation_id(correlation_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def delete_correlation_id(correlation_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def delete_context(context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def scan_reactors(pattern: "*", count: 50)
+        raise NotImplementedError
+      end
+
+      def find_context_by_id(context_id)
+        raise NotImplementedError
+      end
+
+      def store_map_element_context_id(map_id, context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def retrieve_map_element_context_ids(map_id, reactor_class_name)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/ruby_reactor/storage/redis_adapter.rb

@@ -13,14 +13,13 @@ module RubyReactor
 
       def store_context(context_id, serialized_context, reactor_class_name)
         key = context_key(context_id, reactor_class_name)
-        # Use JSON.SET for efficient storage and retrieval
-        @redis.call("JSON.SET", key, ".", serialized_context)
-        @redis.expire(key, 86_400) # 24h TTL
+        # Use standard SET for compatibility (ReJSON not strictly required for full docs)
+        @redis.set(key, serialized_context, ex: 86_400) # 24h TTL
       end
 
       def retrieve_context(context_id, reactor_class_name)
         key = context_key(context_id, reactor_class_name)
-        json = @redis.call("JSON.GET", key)
+        json = @redis.get(key)
         return nil unless json
 
         JSON.parse(json)
@@ -56,8 +55,7 @@ module RubyReactor
 
       def set_map_counter(map_id, count, reactor_class_name)
         key = map_counter_key(map_id, reactor_class_name)
-        @redis.set(key, count)
-        @redis.expire(key, 86_400)
+        @redis.set(key, count, ex: 86_400)
       end
 
       def initialize_map_operation(map_id, count, parent_reactor_class_name, reactor_class_info:, strict_ordering: true)
@@ -72,13 +70,12 @@ module RubyReactor
           reactor_class_info: reactor_class_info,
           created_at: Time.now.to_i
         }
-        @redis.call("JSON.SET", key, ".", metadata.to_json)
-        @redis.expire(key, 86_400)
+        @redis.set(key, metadata.to_json, ex: 86_400)
       end
 
       def retrieve_map_metadata(map_id, reactor_class_name)
         key = "reactor:#{reactor_class_name}:map:#{map_id}:metadata"
-        json = @redis.call("JSON.GET", key)
+        json = @redis.get(key)
         return nil unless json
 
         JSON.parse(json)
@@ -97,8 +94,7 @@ module RubyReactor
 
       def set_last_queued_index(map_id, index, reactor_class_name)
         key = map_last_queued_index_key(map_id, reactor_class_name)
-        @redis.set(key, index)
-        @redis.expire(key, 86_400)
+        @redis.set(key, index, ex: 86_400)
       end
 
       def increment_last_queued_index(map_id, reactor_class_name)
@@ -106,6 +102,41 @@ module RubyReactor
         @redis.incr(key)
       end
 
+      def store_correlation_id(correlation_id, context_id, reactor_class_name)
+        key = correlation_id_key(correlation_id, reactor_class_name)
+        # Store mapping correlation_id -> context_id
+        # Try to set if not exists
+        success = @redis.set(key, context_id, nx: true, ex: 86_400) # 24h TTL
+
+        return if success
+
+        # If it exists, check if it's the same context_id
+        existing_context_id = @redis.get(key)
+
+        if existing_context_id == context_id
+          # Refresh TTL
+          @redis.expire(key, 86_400)
+          return
+        end
+
+        raise Error::ValidationError, "Correlation ID '#{correlation_id}' already exists"
+      end
+
+      def retrieve_context_id_by_correlation_id(correlation_id, reactor_class_name)
+        key = correlation_id_key(correlation_id, reactor_class_name)
+        @redis.get(key)
+      end
+
+      def delete_correlation_id(correlation_id, reactor_class_name)
+        key = correlation_id_key(correlation_id, reactor_class_name)
+        @redis.del(key)
+      end
+
+      def delete_context(context_id, reactor_class_name)
+        key = context_key(context_id, reactor_class_name)
+        @redis.del(key)
+      end
+
       def subscribe(channel, &block)
         @redis.subscribe(channel, &block)
       end
@@ -118,8 +149,108 @@ module RubyReactor
         @redis.expire(key, seconds)
       end
 
+      # New methods for API
+      def scan_reactors(pattern: "reactor:*:context:*", count: 50)
+        # Use SCAN to find keys matching the pattern
+        results = []
+        batch_keys = []
+
+        # scan_each yields keys. We buffer them to use MGET efficiently.
+        # We request a batch size from Redis (count: 100) to reduce roundtrips.
+        @redis.scan_each(match: pattern, count: 100) do |key|
+          batch_keys << key
+
+          # specific batch size for MGET processing
+          if batch_keys.size >= 50
+            results.concat(fetch_and_filter_reactors(batch_keys))
+            batch_keys = []
+
+            # Stop if we have enough results
+            return results.take(count) if results.size >= count
+          end
+        end
+
+        # Process remaining keys
+        results.concat(fetch_and_filter_reactors(batch_keys)) if batch_keys.any?
+
+        results.take(count)
+      end
+
+      def find_context_by_id(context_id)
+        # We don't know the reactor class, so we search for the ID
+        pattern = "reactor:*:context:#{context_id}"
+        keys = []
+        @redis.scan_each(match: pattern, count: 1) do |key|
+          keys << key
+          break
+        end
+        return nil if keys.empty?
+
+        key = keys.first
+        json = @redis.get(key)
+        return nil unless json
+
+        JSON.parse(json)
+      end
+
+      def determine_status(data)
+        return data["status"] if data["status"] && %w[failed paused completed running].include?(data["status"])
+        return "cancelled" if data["cancelled"]
+        # Heuristic
+        return "failed" if data["retry_count"]&.positive? && !data["current_step"].nil?
+        return "completed" unless data["current_step"]
+
+        "running"
+      end
+
+      def store_map_element_context_id(map_id, context_id, reactor_class_name)
+        key = map_element_contexts_key(map_id, reactor_class_name)
+        @redis.rpush(key, context_id)
+        @redis.expire(key, 86_400)
+      end
+
+      def retrieve_map_element_context_ids(map_id, reactor_class_name)
+        key = map_element_contexts_key(map_id, reactor_class_name)
+        @redis.lrange(key, 0, -1)
+      end
+
+      def retrieve_map_element_context_id(map_id, reactor_class_name, index: -1)
+        key = map_element_contexts_key(map_id, reactor_class_name)
+        @redis.lindex(key, index)
+      end
+
+      def store_map_failed_context_id(map_id, context_id, reactor_class_name)
+        key = map_failed_context_key(map_id, reactor_class_name)
+        # Only store the first failure (nx: true)
+        @redis.set(key, context_id, nx: true, ex: 86_400)
+      end
+
+      def retrieve_map_failed_context_id(map_id, reactor_class_name)
+        key = map_failed_context_key(map_id, reactor_class_name)
+        @redis.get(key)
+      end
+
       private
 
+      def fetch_and_filter_reactors(keys)
+        return [] if keys.empty?
+
+        json_results = @redis.mget(*keys)
+
+        json_results.compact.map do |json|
+          data = JSON.parse(json)
+          next if data["parent_context_id"] # Skip nested reactors
+
+          {
+            id: data["context_id"],
+            class: data["reactor_class"],
+            status: determine_status(data),
+            created_at: data["started_at"],
+            failure: data["failure_reason"]
+          }
+        end.compact
+      end
+
       def context_key(context_id, reactor_class_name)
         "reactor:#{reactor_class_name}:context:#{context_id}"
       end
@@ -135,6 +266,18 @@ module RubyReactor
       def map_last_queued_index_key(map_id, reactor_class_name)
         "reactor:#{reactor_class_name}:map:#{map_id}:last_queued_index"
       end
+
+      def correlation_id_key(correlation_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:correlation:#{correlation_id}"
+      end
+
+      def map_element_contexts_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:element_contexts"
+      end
+
+      def map_failed_context_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:failed_context_id"
+      end
     end
   end
 end

data/lib/ruby_reactor/utils/code_extractor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Utils
+    class CodeExtractor
+      def self.extract(file_path, line_number, radius: 2)
+        return nil unless file_path && line_number && File.exist?(file_path)
+
+        lines = File.readlines(file_path)
+        total_lines = lines.size
+        target_index = line_number - 1
+
+        return nil if target_index.negative? || target_index >= total_lines
+
+        start_index = [0, target_index - radius].max
+        end_index = [total_lines - 1, target_index + radius].min
+
+        (start_index..end_index).map do |i|
+          {
+            line_number: i + 1,
+            content: lines[i].chomp,
+            target: i == target_index
+          }
+        end
+      rescue StandardError
+        # Fail gracefully if file reading fails
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_reactor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyReactor
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ruby_reactor/web/api.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "roda"
+
+module RubyReactor
+  module Web
+    # rubocop:disable Metrics/BlockLength
+    class API < Roda
+      plugin :json
+      plugin :all_verbs
+
+      route do |r|
+        r.on "reactors" do
+          r.is do
+            # GET /api/reactors
+            r.get do
+              RubyReactor::Configuration.instance.storage_adapter.scan_reactors
+            rescue StandardError => e
+              response.status = 500
+              { error: e.message, backtrace: e.backtrace.first(5) }
+            end
+          end
+
+          r.on String do |reactor_id|
+            # GET /api/reactors/:id
+            r.get do
+              data = RubyReactor::Configuration.instance.storage_adapter.find_context_by_id(reactor_id)
+              return { error: "Reactor not found" } unless data
+
+              reactor_class = data["reactor_class"] ? Object.const_get(data["reactor_class"]) : nil
+              structure = {}
+
+              structure = self.class.build_structure(reactor_class) if reactor_class.respond_to?(:steps)
+
+              {
+                id: data["context_id"],
+                class: data["reactor_class"],
+                status: if %w[failed paused completed running].include?(data["status"])
+                          data["status"]
+                        elsif data["cancelled"]
+                          "cancelled"
+                        else
+                          (data["current_step"] ? "running" : "completed")
+                        end,
+                current_step: data["current_step"],
+                retry_count: data["retry_count"] || 0,
+                undo_stack: data["undo_stack"] || [],
+                step_attempts: data.dig("retry_context", "step_attempts") || {},
+                created_at: data["started_at"],
+                inputs: data["inputs"],
+                intermediate_results: data["intermediate_results"],
+                structure: structure,
+                steps: data["execution_trace"] || [],
+                composed_contexts: self.class.hydrate_composed_contexts(
+                  data["composed_contexts"] || {},
+                  data["reactor_class"]
+                ),
+                error: data["failure_reason"]
+              }
+            end
+
+            # POST /api/reactors/:id/retry
+            r.post "retry" do
+              { success: true, message: "Retry scheduled" }
+            end
+
+            # POST /api/reactors/:id/cancel
+            r.post "cancel" do
+              { success: true, message: "Cancelled" }
+            end
+
+            # POST /api/reactors/:id/continue
+            r.post "continue" do
+              data = RubyReactor::Configuration.instance.storage_adapter.find_context_by_id(reactor_id)
+              return { error: "Reactor not found" } unless data
+
+              reactor_class = Object.const_get(data["reactor_class"])
+
+              params = JSON.parse(r.body.read)
+              payload = params["payload"]
+              step_name = params["step_name"]
+
+              begin
+                result = reactor_class.continue(
+                  id: reactor_id,
+                  payload: payload,
+                  step_name: step_name
+                )
+
+                if result.is_a?(RubyReactor::Failure)
+                  response.status = 422
+                  { error: result.error }
+                else
+                  { success: true, message: "Reactor resumed" }
+                end
+              rescue StandardError => e
+                response.status = 422
+                { error: e.message }
+              end
+            end
+          end
+        end
+      end
+
+      def self.build_structure(reactor_class)
+        return {} unless reactor_class.respond_to?(:steps)
+
+        steps_config = reactor_class.steps
+        return {} unless steps_config.is_a?(Hash)
+
+        # Use DependencyGraph to calculate dependencies effectively
+        graph = RubyReactor::DependencyGraph.new
+        steps_config.each_value { |config| graph.add_step(config) }
+
+        steps_config.to_h do |name, config|
+          type = determine_step_type(config)
+
+          step_data = {
+            name: name,
+            type: type,
+            depends_on: graph.dependencies[name],
+            async: config.async?
+          }
+
+          if type == "compose"
+            inner_class = extract_inner_class(config, :composed_reactor_class)
+            step_data[:nested_structure] = build_structure(inner_class) if inner_class
+          elsif type == "map"
+            inner_class = extract_inner_class(config, :mapped_reactor_class)
+            step_data[:nested_structure] = build_structure(inner_class) if inner_class
+          end
+
+          [name, step_data]
+        end
+      end
+
+      def self.determine_step_type(config)
+        if config.respond_to?(:interrupt?) && config.interrupt?
+          "interrupt"
+        elsif config.arguments&.key?(:composed_reactor_class)
+          "compose"
+        elsif config.arguments&.key?(:mapped_reactor_class)
+          "map"
+        elsif config.async?
+          "async"
+        else
+          "step"
+        end
+      end
+
+      def self.extract_inner_class(config, param_name)
+        val = config.arguments.dig(param_name, :source)
+        val.is_a?(RubyReactor::Template::Value) ? val.value : nil
+      rescue StandardError
+        nil
+      end
+
+      def self.hydrate_composed_contexts(composed_contexts, reactor_class_name)
+        return {} unless composed_contexts.is_a?(Hash)
+
+        composed_contexts.transform_values do |value|
+          if ["map_ref", :map_ref].include?(value["type"])
+            hydrate_map_ref(value, reactor_class_name)
+          else
+            value
+          end
+        end
+      end
+
+      def self.hydrate_map_ref(ref_data, reactor_class_name)
+        storage = RubyReactor.configuration.storage_adapter
+        map_id = ref_data["map_id"]
+
+        # Use the specific element reactor class if available, otherwise fallback to parent
+        target_reactor_class = ref_data["element_reactor_class"] || reactor_class_name
+
+        # 1. Check for specific failure (O(1))
+        # Stored by ResultHandler when a map element fails
+        failed_context_id = storage.retrieve_map_failed_context_id(map_id, reactor_class_name)
+
+        target_context_id = if failed_context_id
+                              failed_context_id
+                            else
+                              # 2. Fallback to representative sample (last element) (O(1))
+                              # If no failure, the last element gives a good idea of progress/completion
+                              target_id = storage.retrieve_map_element_context_id(map_id, reactor_class_name, index: -1)
+                              target_id
+                            end
+
+        return ref_data unless target_context_id
+
+        # Retrieve the actual context data for the target ID
+        representative_data = storage.retrieve_context(target_context_id, target_reactor_class)
+
+        return ref_data unless representative_data
+
+        {
+          "name" => ref_data["name"],
+          "type" => "map_element",
+          "context" => representative_data
+        }
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/ruby_reactor/web/application.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "roda"
+require "ruby_reactor"
+require "json"
+require_relative "api"
+
+module RubyReactor
+  module Web
+    class Application < Roda
+      plugin :static, ["/assets"], root: File.expand_path("public", __dir__)
+      # rubocop:disable Naming/MethodParameterName
+      def serve_index(r)
+        # rubocop:enable Naming/MethodParameterName
+        content = File.read(File.expand_path("public/index.html", __dir__))
+        # Inject the base path for React Router
+        # request.script_name contains the mount path (e.g. "/ruby_reactor")
+        base_path = r.script_name.empty? ? "/" : r.script_name
+
+        # Ensure trailing slash for base href to support relative assets (base: './')
+        href = base_path.end_with?("/") ? base_path : "#{base_path}/"
+
+        # Inject config and base tag
+        content.sub!("<head>", "<head><base href='#{href}'><script>window.RUBY_REACTOR_BASE = '#{base_path}';</script>")
+        content
+      rescue Errno::ENOENT
+        "UI not built. Please run `rake build:ui`"
+      end
+      plugin :json
+      plugin :public, root: File.expand_path("public", __dir__)
+
+      route do |r|
+        # 1. Handle Root (Inject config) - MUST be before r.public
+        r.root do
+          serve_index(r)
+        end
+
+        # 2. Serve Static Assets (e.g. /assets/...) from public folder
+        r.public
+
+        # 3. API
+        r.on "api" do
+          r.run API
+        end
+
+        # 4. Fallback (Inject config for deep links)
+        r.get do
+          serve_index(r)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/web/config.ru

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "application"
+
+run RubyReactor::Web::Application