langgraphrb_rails 0.1.0

data/lib/langgraphrb_rails/helper.rb

@@ -0,0 +1,141 @@
+module LanggraphrbRails
+  module Helper
+    # Helper method to render a chat interface for a LangGraphRB graph
+    def langgraph_chat_interface(options = {})
+      graph_class = options[:graph_class]
+      container_id = options[:container_id] || 'langgraph-chat'
+      placeholder = options[:placeholder] || 'Type your message here...'
+      submit_text = options[:submit_text] || 'Send'
+      submit_path = options[:submit_path] || url_for(controller: controller_name, action: 'create')
+      css_class = ['langgraph-chat-container', options[:css_class]].compact.join(' ')
+      
+      content_tag :div, class: css_class, id: container_id do
+        messages_div = content_tag(:div, class: 'langgraph-messages', id: "#{container_id}-messages") do
+          # Render existing messages if provided
+          if options[:messages].present?
+            safe_join(options[:messages].map do |message|
+              content_tag(:div, class: "langgraph-message #{message[:role]}") do
+                content_tag(:p, message[:content])
+              end
+            end)
+          else
+            ""
+          end
+        end
+        
+        form = form_with(url: submit_path, class: 'langgraph-chat-form', id: "#{container_id}-form", data: { turbo: false }) do |f|
+          f.text_area(:message, class: 'langgraph-chat-input', placeholder: placeholder) +
+          f.submit(submit_text, class: 'langgraph-chat-submit')
+        end
+        
+        messages_div + form
+      end
+    end
+    
+    # Helper method to render a streaming chat interface
+    def langgraph_streaming_chat_interface(options = {})
+      container_id = options[:container_id] || 'langgraph-streaming-chat'
+      placeholder = options[:placeholder] || 'Type your message here...'
+      submit_text = options[:submit_text] || 'Send'
+      stream_path = options[:stream_path] || url_for(controller: controller_name, action: 'stream')
+      css_class = ['langgraph-chat-container', options[:css_class]].compact.join(' ')
+      
+      content_tag :div, class: css_class, id: container_id do
+        messages_div = content_tag(:div, class: 'langgraph-messages', id: "#{container_id}-messages") do
+          # Render existing messages if provided
+          if options[:messages].present?
+            safe_join(options[:messages].map do |message|
+              content_tag(:div, class: "langgraph-message #{message[:role]}") do
+                content_tag(:p, message[:content])
+              end
+            end)
+          else
+            ""
+          end
+        end
+        
+        form = form_with(url: stream_path, method: :post, class: 'langgraph-chat-form', id: "#{container_id}-form", data: { turbo: false }) do |f|
+          f.text_area(:message, class: 'langgraph-chat-input', placeholder: placeholder) +
+          f.submit(submit_text, class: 'langgraph-chat-submit') +
+          content_tag(:div, '', class: 'langgraph-typing-indicator', id: "#{container_id}-typing")
+        end
+        
+        # Add JavaScript for streaming
+        js_code = javascript_tag do
+          <<-JS.html_safe
+            document.addEventListener('DOMContentLoaded', function() {
+              const form = document.getElementById('#{container_id}-form');
+              const messagesContainer = document.getElementById('#{container_id}-messages');
+              const typingIndicator = document.getElementById('#{container_id}-typing');
+              
+              form.addEventListener('submit', function(e) {
+                e.preventDefault();
+                
+                const messageInput = form.querySelector('textarea[name="message"]');
+                const userMessage = messageInput.value.trim();
+                
+                if (!userMessage) return;
+                
+                // Add user message to the UI
+                const userDiv = document.createElement('div');
+                userDiv.className = 'langgraph-message user';
+                userDiv.innerHTML = '<p>' + userMessage.replace(/</g, '&lt;').replace(/>/g, '&gt;') + '</p>';
+                messagesContainer.appendChild(userDiv);
+                
+                // Show typing indicator
+                typingIndicator.style.display = 'block';
+                
+                // Clear the input
+                messageInput.value = '';
+                
+                // Scroll to bottom
+                messagesContainer.scrollTop = messagesContainer.scrollHeight;
+                
+                // Start the EventSource connection
+                const eventSource = new EventSource(`#{stream_path}?message=${encodeURIComponent(userMessage)}`);
+                
+                // Create a div for the assistant's response
+                const assistantDiv = document.createElement('div');
+                assistantDiv.className = 'langgraph-message assistant';
+                const assistantP = document.createElement('p');
+                assistantDiv.appendChild(assistantP);
+                messagesContainer.appendChild(assistantDiv);
+                
+                // Handle incoming messages
+                eventSource.onmessage = function(event) {
+                  try {
+                    const data = JSON.parse(event.data);
+                    
+                    // Hide typing indicator when complete
+                    if (data.completed) {
+                      typingIndicator.style.display = 'none';
+                      eventSource.close();
+                    }
+                    
+                    // Update the assistant's message if there's a response
+                    if (data.state && data.state.response) {
+                      assistantP.textContent = data.state.response;
+                      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+                    }
+                  } catch (e) {
+                    console.error('Error parsing event data:', e);
+                    typingIndicator.style.display = 'none';
+                    eventSource.close();
+                  }
+                };
+                
+                // Handle errors
+                eventSource.onerror = function() {
+                  typingIndicator.style.display = 'none';
+                  eventSource.close();
+                };
+              });
+            });
+          JS
+        end
+        
+        messages_div + form + js_code
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/middleware/streaming.rb

@@ -0,0 +1,77 @@
+module LanggraphrbRails
+  module Middleware
+    class Streaming
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        # Check if this is a LangGraphRB streaming request
+        if env["PATH_INFO"].match?(/\/langgraph_rb\/stream/)
+          handle_streaming(env)
+        else
+          @app.call(env)
+        end
+      end
+      
+      private
+      
+      def handle_streaming(env)
+        request = Rack::Request.new(env)
+        
+        # Extract parameters
+        graph_class_name = request.params["graph_class"]
+        input = request.params["input"]
+        thread_id = request.params["thread_id"]
+        
+        # Validate parameters
+        unless graph_class_name && input
+          return [400, {"Content-Type" => "text/plain"}, ["Missing required parameters"]]
+        end
+        
+        # Find the graph class
+        begin
+          graph_class = graph_class_name.constantize
+        rescue NameError
+          return [404, {"Content-Type" => "text/plain"}, ["Graph class not found"]]
+        end
+        
+        # Set up streaming response
+        [200, {
+          "Content-Type" => "text/event-stream",
+          "Cache-Control" => "no-cache",
+          "Connection" => "keep-alive"
+        }, StreamingBody.new(graph_class, input, thread_id)]
+      end
+      
+      class StreamingBody
+        def initialize(graph_class, input, thread_id = nil)
+          @graph_class = graph_class
+          @input = input
+          @thread_id = thread_id || SecureRandom.hex(8)
+        end
+        
+        def each
+          # Create a store for persistence
+          store = LanggraphrbRails.create_store
+          
+          # Stream the graph execution
+          @graph_class.stream(
+            { input: @input },
+            store: store,
+            thread_id: @thread_id
+          ) do |step_result|
+            # Format as server-sent event
+            yield "data: #{step_result.to_json}\n\n"
+            
+            # Close the connection when completed
+            break if step_result[:completed]
+          end
+        rescue => e
+          # Send error as event
+          yield "data: #{{ error: e.message }.to_json}\n\n"
+        end
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/railtie.rb

@@ -0,0 +1,55 @@
+require 'rails'
+require 'langgraphrb_rails/helper'
+require 'yaml'
+
+module LanggraphrbRails
+  class Railtie < Rails::Railtie
+    initializer "langgraphrb_rails.configure_rails_initialization" do
+      # Load configuration from config/langgraph_rb.yml if it exists
+      config_file = Rails.root.join('config', 'langgraph_rb.yml')
+      if File.exist?(config_file)
+        # Use safe_load for better security and compatibility with newer Ruby/Rails
+        config = YAML.safe_load(ERB.new(File.read(config_file)).result, aliases: true)[Rails.env]
+        LanggraphrbRails.configure do |c|
+          config&.each do |key, value|
+            c.send("#{key}=", value) if c.respond_to?("#{key}=")
+          end
+        end
+      end
+    end
+    
+    # Include helpers in views - compatible with all Rails versions
+    initializer "langgraphrb_rails.view_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include LanggraphrbRails::Helper
+      end
+    end
+    
+    # Add asset paths with compatibility for Rails 7.1+ and 8.x
+    initializer "langgraphrb_rails.assets" do |app|
+      if app.config.respond_to?(:assets)
+        stylesheets_path = File.expand_path("../../app/assets/stylesheets", __dir__)
+        javascripts_path = File.expand_path("../../app/assets/javascripts", __dir__)
+        
+        # Add paths to assets if the assets configuration exists
+        if app.config.assets.respond_to?(:paths)
+          app.config.assets.paths << stylesheets_path
+          app.config.assets.paths << javascripts_path
+        end
+        
+        # Handle precompilation for different Rails versions
+        if app.config.assets.respond_to?(:precompile)
+          app.config.assets.precompile += %w(langgraphrb_rails.css langgraphrb_rails.js)
+        end
+      end
+    end
+    
+    # Add rake tasks with better error handling
+    rake_tasks do
+      rake_file = File.expand_path("../../tasks/langgraphrb_rails_tasks.rake", __dir__)
+      if File.exist?(rake_file)
+        load rake_file
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/stores/active_record.rb

@@ -0,0 +1,51 @@
+module LanggraphrbRails
+  module Stores
+    class ActiveRecordStore
+      def initialize(options = {})
+        @model = options[:model] || raise(ArgumentError, "Model class is required")
+        @ttl = options[:ttl] # Optional TTL for cleanup
+      end
+
+      def get(thread_id)
+        record = @model.find_by(thread_id: thread_id)
+        return nil unless record
+        
+        record.state
+      end
+
+      def put(thread_id, data)
+        record = @model.find_or_initialize_by(thread_id: thread_id)
+        record.state = data
+        record.save!
+        
+        # Set expiration if TTL is provided
+        if @ttl && defined?(Rails.cache)
+          Rails.cache.write("#{@model.name.underscore}:#{thread_id}:expiry", true, expires_in: @ttl)
+        end
+        
+        data
+      end
+
+      def delete(thread_id)
+        record = @model.find_by(thread_id: thread_id)
+        record&.destroy
+      end
+
+      def exists?(thread_id)
+        @model.exists?(thread_id: thread_id)
+      end
+      
+      # Cleanup expired records (can be called from a background job)
+      def cleanup_expired
+        return unless @ttl && defined?(Rails.cache)
+        
+        @model.find_each do |record|
+          # Handle both String and Class names
+          model_name = @model.name.is_a?(String) ? @model.name.downcase : @model.name.underscore
+          cache_key = "#{model_name}:#{record.thread_id}:expiry"
+          record.destroy unless Rails.cache.exist?(cache_key)
+        end
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/stores/redis.rb

@@ -0,0 +1,57 @@
+require 'redis'
+require 'json'
+
+module LanggraphrbRails
+  module Stores
+    class RedisStore
+      # Add namespace accessor
+      attr_reader :namespace
+      
+      # Class method to create a new store
+      def self.create(options = {})
+        new(options)
+      end
+      
+      def initialize(options = {})
+        @redis = options[:client] || Redis.new(url: options[:url] || ENV['REDIS_URL'] || 'redis://localhost:6379/0')
+        @namespace = options[:namespace] || 'langgraph_rb'
+        @ttl = options[:ttl] || 86400 # 24 hours default TTL
+      end
+
+      def get(thread_id)
+        key = namespaced_key(thread_id)
+        data = @redis.get(key)
+        return nil unless data
+        
+        JSON.parse(data)
+      end
+
+      def put(thread_id, data, ttl = nil)
+        key = namespaced_key(thread_id)
+        if ttl
+          @redis.set(key, JSON.generate(data), ex: ttl)
+        else
+          @redis.set(key, JSON.generate(data))
+          @redis.expire(key, @ttl) if @ttl
+        end
+        data
+      end
+
+      def delete(thread_id)
+        key = namespaced_key(thread_id)
+        @redis.del(key)
+      end
+
+      def exists?(thread_id)
+        key = namespaced_key(thread_id)
+        @redis.exists?(key)
+      end
+
+      private
+
+      def namespaced_key(thread_id)
+        "#{@namespace}:#{thread_id}"
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/test_helper.rb

@@ -0,0 +1,126 @@
+require 'langgraph_rb'
+
+module LanggraphrbRails
+  # Test helper module for LanggraphRB Rails integration
+  module TestHelper
+    # Create a memory store for testing
+    def with_memory_store
+      original_store = LanggraphrbRails.configuration.store_adapter
+      original_options = LanggraphrbRails.configuration.store_options
+      
+      begin
+        # Set memory store for testing
+        LanggraphrbRails.configure_store do |config|
+          config.adapter = :memory
+          config.options = {}
+        end
+        
+        # Execute the block with memory store
+        yield
+      ensure
+        # Restore original store configuration
+        LanggraphrbRails.configure_store do |config|
+          config.adapter = original_store
+          config.options = original_options
+        end
+      end
+    end
+    
+    # Create a test store with the specified adapter
+    def with_store(adapter, options = {})
+      original_store = LanggraphrbRails.configuration.store_adapter
+      original_options = LanggraphrbRails.configuration.store_options
+      
+      begin
+        # Set specified store for testing
+        LanggraphrbRails.configure_store do |config|
+          config.adapter = adapter
+          config.options = options
+        end
+        
+        # Execute the block with the specified store
+        yield
+      ensure
+        # Restore original store configuration
+        LanggraphrbRails.configure_store do |config|
+          config.adapter = original_store
+          config.options = original_options
+        end
+      end
+    end
+    
+    # Mock a graph for testing
+    def mock_graph(nodes = {}, edges = {}, entry_point = nil)
+      Class.new do
+        include LangGraphRB::Graph
+        
+        define_singleton_method(:define_nodes) do
+          nodes
+        end
+        
+        define_singleton_method(:define_edges) do
+          edges
+        end
+        
+        define_singleton_method(:build) do
+          LangGraphRB::Graph.build(
+            nodes: define_nodes,
+            edges: define_edges,
+            entry_point: entry_point || nodes.keys.first
+          )
+        end
+        
+        define_singleton_method(:instance) do
+          @instance ||= build
+        end
+        
+        define_singleton_method(:invoke) do |input, options = {}|
+          state = { input: input }
+          context = options[:context] || {}
+          store = options[:store] || LanggraphrbRails.create_store
+          thread_id = options[:thread_id] || SecureRandom.hex(8)
+          
+          result = instance.invoke(
+            state,
+            context: context,
+            store: store,
+            thread_id: thread_id
+          )
+          
+          result.merge(thread_id: thread_id)
+        end
+        
+        define_singleton_method(:stream) do |input, options = {}, &block|
+          state = { input: input }
+          context = options[:context] || {}
+          store = options[:store] || LanggraphrbRails.create_store
+          thread_id = options[:thread_id] || SecureRandom.hex(8)
+          
+          instance.stream(
+            state,
+            context: context,
+            store: store,
+            thread_id: thread_id
+          ) do |step|
+            block.call(step.merge(thread_id: thread_id))
+          end
+        end
+      end
+    end
+    
+    # Create a test graph with a simple echo node
+    def create_echo_graph
+      mock_graph(
+        {
+          echo: ->(state, _context) {
+            state.merge(response: "Echo: #{state[:input]}")
+          }
+        },
+        {
+          echo: :END
+        },
+        :echo
+      )
+    end
+  end
+end

data/lib/langgraphrb_rails/version.rb

@@ -0,0 +1,28 @@
+module LanggraphrbRails
+  # Current version of the gem
+  VERSION = "0.1.0"
+  
+  # Minimum required version of langgraph_rb
+  LANGGRAPH_RB_MIN_VERSION = "0.1.2"
+  
+  # Minimum required version of Rails
+  RAILS_MIN_VERSION = "6.0.0"
+  
+  # Maximum supported version of Rails
+  RAILS_MAX_VERSION = "8.0.2"
+  
+  # Version history
+  VERSION_HISTORY = {
+    "0.1.0" => "Initial release with generators, helpers, stores, and middleware. Improved compatibility with Rails 7.1.x and 8.x."
+  }
+  
+  # Returns the version information as a hash
+  def self.version_info
+    {
+      version: VERSION,
+      langgraph_rb_min_version: LANGGRAPH_RB_MIN_VERSION,
+      rails_min_version: RAILS_MIN_VERSION,
+      rails_max_version: RAILS_MAX_VERSION
+    }
+  end
+end

data/lib/langgraphrb_rails.rb

@@ -0,0 +1,111 @@
+require "langgraphrb_rails/version"
+require "langgraphrb_rails/configuration"
+require "langgraphrb_rails/helper"
+require "langgraphrb_rails/engine"
+require "langgraphrb_rails/railtie" if defined?(Rails)
+require "langgraph_rb"
+
+module LanggraphrbRails
+  class << self
+    attr_writer :configuration
+    
+    # Get the current configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    
+    # Configure the gem
+    def configure
+      yield(configuration)
+    end
+    
+    # Configure from a hash (e.g., from YAML)
+    def configure_from_hash(config_hash)
+      return unless config_hash.is_a?(Hash)
+      
+      if config_hash['store'].is_a?(Hash)
+        configuration.store_adapter = config_hash['store']['adapter'] if config_hash['store']['adapter']
+        configuration.store_options = config_hash['store']['options'] if config_hash['store']['options']
+      end
+      
+      if config_hash['job'].is_a?(Hash)
+        configuration.job_queue = config_hash['job']['queue'] if config_hash['job']['queue']
+        configuration.max_retries = config_hash['job']['max_retries'] if config_hash['job']['max_retries']
+      end
+      
+      if config_hash['error'].is_a?(Hash)
+        configuration.on_error = config_hash['error']['policy'] if config_hash['error']['policy']
+        configuration.max_retries = config_hash['error']['max_retries'] if config_hash['error']['max_retries']
+      end
+    end
+    
+    # Start a new graph run
+    def start!(graph:, context: {}, state: {})
+      # Generate a unique thread ID
+      thread_id = SecureRandom.uuid
+      
+      # Create the run record if we have persistence
+      if defined?(LanggraphRun)
+        graph_name = graph.is_a?(String) ? graph : graph.name
+        run = LanggraphRun.create!(
+          thread_id: thread_id,
+          graph: graph_name,
+          context: context,
+          state: state,
+          status: :queued
+        )
+        
+        return run
+      else
+        # If no persistence is available, delegate to LangGraphRB
+        store = create_store
+        LangGraphRB::Runner.start!(graph: graph, context: context, state: state, store: store)
+        return { thread_id: thread_id }
+      end
+    end
+    
+    # Resume a graph run
+    def resume!(run_id)
+      # Find the run record
+      run = LanggraphRun.find(run_id)
+      
+      # Create a store with the run's thread_id
+      store = create_store
+      
+      # Get the graph class
+      graph_class = run.graph.constantize
+      
+      # Resume execution
+      result = LangGraphRB::Runner.resume!(
+        thread_id: run.thread_id,
+        store: store
+      )
+      
+      # Update the run record
+      run.update(
+        state: result[:state],
+        current_node: result[:current_node],
+        status: result[:terminal] ? :succeeded : :running
+      )
+      
+      result
+    end
+    
+    # Create a store for LangGraphRB state persistence
+    def create_store(adapter = nil, options = {})
+      adapter ||= configuration.store_adapter
+      options ||= configuration.store_options
+      
+      case adapter.to_sym
+      when :redis
+        require_relative "langgraphrb_rails/stores/redis"
+        LanggraphrbRails::Stores::RedisStore.new(options)
+      when :active_record
+        require_relative "langgraphrb_rails/stores/active_record"
+        LanggraphrbRails::Stores::ActiveRecordStore.new(options)
+      else
+        LangGraphRB::Stores::InMemoryStore.new
+      end
+    end
+  end
+end