langgraphrb_rails 0.1.0

data/lib/generators/langgraphrb_rails/graph/templates/node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Nodes::<%= node_class_name(@node_name) %> < LangGraphRB::Node
+  # Include LangSmith tracing if available
+  include LangsmithTraced if defined?(LangsmithTraced)
+  
+  def call(context:, state:)
+    # TODO: Implement <%= @node_name %> logic
+    
+    # Example:
+    # result = "Processed by <%= @node_name %>"
+    
+    # Return the updated state
+    ok state: state.merge("<%= @node_name %>_result" => "Processed")
+  end
+end

data/lib/generators/langgraphrb_rails/graph_generator.rb

@@ -0,0 +1,48 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class GraphGenerator < Rails::Generators::NamedBase
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      class_option :nodes, type: :string, desc: "Comma-separated list of node names to create"
+      
+      desc "Creates a new LanggraphRB graph and associated nodes"
+      
+      def create_graph_file
+        template "graph.rb", "app/langgraphs/#{file_name}_graph.rb"
+      end
+      
+      def create_node_files
+        return unless options[:nodes].present?
+        
+        nodes = options[:nodes].split(',').map(&:strip)
+        nodes.each do |node_name|
+          @node_name = node_name
+          template "node.rb", "app/langgraphs/nodes/#{node_name}.rb"
+        end
+      end
+      
+      private
+      
+      def node_class_name(node_name)
+        node_name.camelize
+      end
+      
+      def node_connections
+        return [] unless options[:nodes].present?
+        
+        nodes = options[:nodes].split(',').map(&:strip)
+        nodes.map.with_index do |node, index|
+          if index == nodes.length - 1
+            "node :#{node}, terminal: true"
+          else
+            "node :#{node}, to: :#{nodes[index + 1]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/install/templates/config.yml

@@ -0,0 +1,30 @@
+default: &default
+  store:
+    adapter: memory
+    options:
+      ttl: 3600
+  job:
+    queue: langgraphrb
+    max_retries: 3
+  error:
+    policy: retry
+    max_retries: 3
+
+development:
+  <<: *default
+  store:
+    adapter: memory
+
+test:
+  <<: *default
+  store:
+    adapter: memory
+
+production:
+  <<: *default
+  store:
+    adapter: redis
+    options:
+      url: <%= ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') %>
+      namespace: langgraphrb
+      ttl: 86400 # 24 hours

data/lib/generators/langgraphrb_rails/install/templates/example_graph.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Example graph demonstrating LanggraphRB integration with Rails
+class ExampleGraph
+  include LangGraphRB::Graph
+  
+  # Define nodes and edges
+  node :start, to: :process
+  node :process, to: :finish
+  node :finish, terminal: true
+  
+  # You can also define conditional edges:
+  # node :process do |state|
+  #   if state["needs_review"]
+  #     :review
+  #   else
+  #     :finish
+  #   end
+  # end
+end
+
+# Define your nodes in app/langgraphs/nodes/
+# Example:
+#
+# class Nodes::Start < LangGraphRB::Node
+#   def call(context:, state:)
+#     # Initialize state with input
+#     ok state: state.merge("message" => "Processing started")
+#   end
+# end
+#
+# class Nodes::Process < LangGraphRB::Node
+#   def call(context:, state:)
+#     # Process the input
+#     ok state: state.merge("processed" => true)
+#   end
+# end
+#
+# class Nodes::Finish < LangGraphRB::Node
+#   def call(context:, state:)
+#     # Finalize and return result
+#     ok state: state.merge("completed" => true), terminal: true
+#   end
+# end

data/lib/generators/langgraphrb_rails/install/templates/initializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# LanggraphrbRails configuration
+LanggraphrbRails.configure do |config|
+  # Configure the store adapter (memory, redis, active_record)
+  # config.store_adapter = Rails.env.production? ? :redis : :memory
+  
+  # Configure the store options
+  # config.store_options = {
+  #   ttl: 3600, # TTL in seconds (for Redis and ActiveRecord stores)
+  #   namespace: 'langgraphrb' # Namespace for Redis keys
+  # }
+  
+  # Configure error handling
+  # config.on_error = :retry # Options: :retry, :fail
+  # config.max_retries = 3
+  
+  # Configure job queue
+  # config.job_queue = :langgraphrb
+end
+
+# Load environment-specific configuration
+config_file = Rails.root.join('config', 'langgraphrb_rails.yml')
+if File.exist?(config_file)
+  config = YAML.load(ERB.new(File.read(config_file)).result)[Rails.env]
+  LanggraphrbRails.configure_from_hash(config) if config
+end

data/lib/generators/langgraphrb_rails/install_generator.rb

@@ -0,0 +1,35 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Creates a LanggraphRB initializer and configuration file for your application"
+      
+      def create_initializer_file
+        template "initializer.rb", "config/initializers/langgraphrb_rails.rb"
+      end
+      
+      def create_config_file
+        template "config.yml", "config/langgraphrb_rails.yml"
+      end
+      
+      def create_graphs_directory
+        empty_directory "app/langgraphs"
+        empty_directory "app/langgraphs/nodes"
+      end
+      
+      def add_graphs_to_autoload_paths
+        application "config.autoload_paths += %W(#{Rails.root}/app/langgraphs)"
+        application "config.autoload_paths += %W(#{Rails.root}/app/langgraphs/nodes)"
+      end
+      
+      def create_example_graph
+        template "example_graph.rb", "app/langgraphs/example_graph.rb"
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/jobs/templates/run_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Langgraph
+  class RunJob < ApplicationJob
+    queue_as { LanggraphrbRails.configuration.job_queue || :default }
+    
+    # Include LangSmith tracing if available
+    include LangsmithTracedJob if defined?(LangsmithTracedJob)
+    
+    # Retry options
+    retry_on StandardError, wait: :exponentially_longer, attempts: 3
+    
+    def perform(run_id)
+      # Find the run record
+      run = LanggraphRun.find_by(id: run_id)
+      return unless run
+      
+      # Mark as running
+      run.running!
+      
+      begin
+        # Resume the graph execution
+        result = LangGraphRB.resume!(run_id)
+        
+        # Update the run record with the result
+        if result[:terminal]
+          run.succeeded!(result[:state])
+        else
+          # If not terminal, update state and re-queue
+          run.update(
+            state: result[:state],
+            current_node: result[:current_node]
+          )
+          
+          # Re-queue the job to continue processing
+          self.class.perform_later(run_id)
+        end
+      rescue => e
+        # Handle errors
+        run.failed!(e.message)
+        raise # Re-raise to trigger retry mechanism
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/jobs_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class JobsGenerator < Rails::Generators::NamedBase
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Creates background jobs for LanggraphRB graph processing"
+      
+      def create_run_job_file
+        template "run_job.rb", "app/jobs/langgraph/run_job.rb"
+      end
+      
+      def create_jobs_directory
+        empty_directory "app/jobs/langgraph"
+      end
+      
+      def add_job_configuration
+        initializer_path = "config/initializers/langgraphrb_rails.rb"
+        
+        if File.exist?(Rails.root.join(initializer_path))
+          inject_into_file initializer_path, after: "LanggraphrbRails.configure do |config|\n" do
+            <<-RUBY
+  # Configure job queue for LanggraphRB jobs
+  config.job_queue = :langgraphrb
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/model/templates/migration.rb

@@ -0,0 +1,20 @@
+class Create<%= table_name.camelize %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :<%= table_name %> do |t|
+<% attributes.each do |attribute| -%>
+<% if attribute.type == :references -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% elsif attribute.type == :json || attribute.type == :jsonb -%>
+      t.<%= attribute.type %> :<%= attribute.name %>, default: {}<%= attribute.inject_options %>
+<% else -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% end -%>
+      t.timestamps
+    end
+<% attributes_with_index = attributes.select { |a| a.has_index? || a.reference? } -%>
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end

data/lib/generators/langgraphrb_rails/model/templates/model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < ApplicationRecord
+  # Add validations, associations, and methods as needed
+<% if attributes.map(&:name).include?('thread_id') -%>
+  validates :thread_id, presence: true, uniqueness: true
+<% end -%>
+<% if attributes.map(&:name).include?('state') -%>
+  # Ensure state is always a hash
+  def state
+    super || {}
+  end
+<% end -%>
+end

data/lib/generators/langgraphrb_rails/model_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators/active_record'
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class ModelGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+      include LanggraphrbRails::Generators::Compatibility
+      
+      source_root File.expand_path('templates', __dir__)
+      
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+      
+      desc "Creates a model for LanggraphRB state persistence"
+      
+      def create_model_file
+        template "model.rb", "app/models/#{file_name}.rb"
+      end
+      
+      def create_migration_file
+        migration_template "migration.rb", "db/migrate/create_#{table_name}.rb"
+      end
+      
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/persistence/templates/create_langgraph_runs.rb

@@ -0,0 +1,18 @@
+class CreateLanggraphRuns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :langgraph_runs do |t|
+      t.string :thread_id, null: false, index: true
+      t.string :graph, null: false
+      t.string :current_node
+      t.integer :status, default: 0, null: false
+      t.jsonb :state, default: {}
+      t.jsonb :context, default: {}
+      t.text :error
+      t.datetime :expires_at
+      t.timestamps
+    end
+    
+    add_index :langgraph_runs, :status
+    add_index :langgraph_runs, :expires_at
+  end
+end

data/lib/generators/langgraphrb_rails/persistence/templates/langgraph_run.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class LanggraphRun < ApplicationRecord
+  # Status enum
+  enum status: {
+    queued: 0,
+    running: 1,
+    succeeded: 2,
+    failed: 3,
+    canceled: 4
+  }
+  
+  # Validations
+  validates :thread_id, presence: true
+  validates :graph, presence: true
+  validates :status, presence: true
+  
+  # Scopes
+  scope :active, -> { where(status: [:queued, :running]) }
+  scope :completed, -> { where(status: [:succeeded, :failed, :canceled]) }
+  scope :recent, -> { order(created_at: :desc) }
+  
+  # Callbacks
+  before_create :set_default_status
+  
+  # Methods
+  def running!
+    update(status: :running)
+  end
+  
+  def succeeded!(final_state = nil)
+    update(status: :succeeded, state: final_state || state)
+  end
+  
+  def failed!(error_message = nil)
+    update(status: :failed, error: error_message)
+  end
+  
+  def canceled!
+    update(status: :canceled)
+  end
+  
+  def active?
+    queued? || running?
+  end
+  
+  def completed?
+    succeeded? || failed? || canceled?
+  end
+  
+  private
+  
+  def set_default_status
+    self.status ||= :queued
+  end
+end

data/lib/generators/langgraphrb_rails/persistence_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/base'
+require 'rails/generators/active_record'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class PersistenceGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      include LanggraphrbRails::Generators::Compatibility
+      
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Creates a LanggraphRun model and migration for persistence"
+      
+      def create_model_file
+        template "langgraph_run.rb", "app/models/langgraph_run.rb"
+      end
+      
+      def create_migration_file
+        migration_template "create_langgraph_runs.rb", "db/migrate/create_langgraph_runs.rb"
+      end
+      
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/task/templates/task.rake

@@ -0,0 +1,30 @@
+namespace :langgraph_<%= file_name %> do
+  desc "Process pending <%= class_name %> graph runs"
+  task process: :environment do
+    # Find queued runs for this graph
+    runs = LanggraphRun.where(graph: "<%= class_name %>Graph", status: :queued)
+    
+    puts "Processing #{runs.count} pending <%= class_name %> graph runs..."
+    
+    runs.each do |run|
+      puts "Queueing run ##{run.id}..."
+      Langgraph::RunJob.perform_later(run.id)
+    end
+    
+    puts "Done."
+  end
+  
+  desc "Clean up expired <%= class_name %> graph runs"
+  task cleanup: :environment do
+    # Find expired runs
+    expired = LanggraphRun.where(graph: "<%= class_name %>Graph")
+                          .where("expires_at < ?", Time.current)
+    
+    count = expired.count
+    puts "Cleaning up #{count} expired <%= class_name %> graph runs..."
+    
+    expired.destroy_all
+    
+    puts "Removed #{count} expired runs."
+  end
+end

data/lib/generators/langgraphrb_rails/task_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class TaskGenerator < Rails::Generators::NamedBase
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Creates rake tasks for LanggraphRB graph processing"
+      
+      def create_task_file
+        template "task.rake", "lib/tasks/langgraph_#{file_name}.rake"
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/tracing/templates/traced.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Include this concern in your LangGraphRB nodes to enable LangSmith tracing
+module LangsmithTraced
+  extend ActiveSupport::Concern
+
+  # Trace a block of code with LangSmith
+  def trace(name:, type: "chain", meta: {})
+    return yield unless defined?(LangsmithrbRails) && LangsmithrbRails.configured?
+    
+    tracer = LangsmithrbRails.tracer
+    
+    # Create a new trace
+    tracer.trace(name: name, type: type, meta: meta) do |run|
+      # Execute the block and capture the result
+      result = yield
+      
+      # Add the output to the trace
+      run.add_output(result)
+      
+      # Return the result
+      result
+    end
+  end
+  
+  # Override the call method to automatically trace node execution
+  def call_with_tracing(context:, state:)
+    return call_without_tracing(context: context, state: state) unless defined?(LangsmithrbRails) && LangsmithrbRails.configured?
+    
+    # Get the node name from the class
+    node_name = self.class.name.demodulize.underscore
+    
+    # Create a trace for this node
+    trace(name: node_name, type: "node", meta: { context: context, input_state: state }) do
+      # Call the original method
+      call_without_tracing(context: context, state: state)
+    end
+  end
+  
+  included do
+    # Alias the original call method
+    alias_method :call_without_tracing, :call
+    alias_method :call, :call_with_tracing
+  end
+end

data/lib/generators/langgraphrb_rails/tracing_generator.rb

@@ -0,0 +1,63 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class TracingGenerator < Rails::Generators::Base
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      desc "Creates LangSmith tracing integration for LanggraphRB"
+      
+      def check_langsmithrb_rails
+        unless gem_available?('langsmithrb_rails')
+          say "The langsmithrb_rails gem is required for tracing. Please add it to your Gemfile.", :red
+          exit 1
+        end
+      end
+      
+      def create_concern_file
+        template "tracing/traced.rb", "app/models/concerns/langsmith_traced.rb"
+      end
+      
+      def update_initializer
+        if File.exist?('config/initializers/langgraphrb_rails.rb')
+          inject_into_file 'config/initializers/langgraphrb_rails.rb', after: "LanggraphrbRails.configure do |config|\n" do
+            <<-RUBY
+  # Configure LangSmith tracing
+  if defined?(LangsmithrbRails) && ENV['LANGSMITH_API_KEY'].present?
+    config.observers << LangsmithrbRails::Observer.new(
+      api_key: ENV['LANGSMITH_API_KEY'],
+      project_name: ENV.fetch('LANGSMITH_PROJECT', 'langgraph-rails')
+    )
+  end
+            RUBY
+          end
+        else
+          say "Initializer not found. Please run the install generator first.", :red
+        end
+      end
+      
+      def add_environment_variables
+        append_to_file '.env.sample' do
+          <<-ENV
+
+# LangSmith Tracing (optional)
+# LANGSMITH_API_KEY=your_api_key_here
+# LANGSMITH_PROJECT=your_project_name
+          ENV
+        end unless File.exist?('.env.sample')
+      end
+      
+      private
+      
+      def gem_available?(name)
+        Gem::Specification.find_by_name(name)
+      rescue Gem::LoadError
+        false
+      rescue
+        Gem.available?(name)
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/configuration.rb

@@ -0,0 +1,47 @@
+module LanggraphrbRails
+  class Configuration
+    attr_accessor :store_adapter, :store_options
+    attr_accessor :observers
+    attr_accessor :job_queue, :on_error, :max_retries
+
+    def initialize
+      @store_adapter = :memory
+      @store_options = {}
+      @observers = []
+      @job_queue = :default
+      @on_error = :retry
+      @max_retries = 3
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def configure_store
+      yield(store_config = {}) if block_given?
+      
+      configuration.store_adapter = store_config[:adapter] if store_config[:adapter]
+      configuration.store_options = store_config[:options] if store_config[:options]
+    end
+
+    def configure_observers
+      yield(configuration.observers) if block_given?
+    end
+
+    def store
+      case configuration.store_adapter.to_sym
+      when :redis
+        require_relative 'stores/redis'
+        LanggraphrbRails::Stores::RedisStore.new(configuration.store_options)
+      else
+        LangGraphRB::Stores::InMemoryStore.new
+      end
+    end
+  end
+end

data/lib/langgraphrb_rails/engine.rb

@@ -0,0 +1,20 @@
+module LanggraphrbRails
+  class Engine < ::Rails::Engine
+    isolate_namespace LanggraphrbRails
+    
+    # Add generators
+    config.app_generators do |g|
+      g.templates.unshift File.expand_path('../../generators/langgraph_rb/templates', __dir__)
+    end
+    
+    initializer "langgraphrb_rails.setup" do |app|
+      # Load any initializers or configuration
+    end
+    
+    initializer "langgraphrb_rails.helpers" do |app|
+      ActiveSupport.on_load(:action_view) do
+        include LanggraphrbRails::Helper
+      end
+    end
+  end
+end