langgraphrb_rails 0.1.0

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

@@ -0,0 +1,89 @@
+# Example LangGraphRB graph for Rails applications
+# This is a simple example of how to define a graph in your Rails app
+# You can create more graphs in the app/graphs directory
+
+class ExampleGraph
+  # Define a singleton instance for easy access
+  class << self
+    def instance
+      @instance ||= build_graph
+    end
+    
+    def invoke(input = {}, context: nil)
+      instance.invoke(input, context: context)
+    end
+    
+    def stream(input = {}, context: nil, &block)
+      instance.stream(input, context: context, &block)
+    end
+    
+    private
+    
+    def build_graph
+      # Create a state with message history
+      initial_state = LangGraphRB::State.new(
+        { messages: [] },
+        { messages: LangGraphRB::State.add_messages }
+      )
+      
+      # Create the graph
+      graph = LangGraphRB::Graph.new(state_class: LangGraphRB::State) do
+        # Define nodes
+        node :receive_input do |state|
+          Rails.logger.info "User input received: #{state[:input]}"
+          {
+            messages: [{ role: 'user', content: state[:input] }],
+            last_user_message: state[:input]
+          }
+        end
+        
+        node :process_message do |state|
+          user_message = state[:last_user_message].to_s.downcase
+          
+          intent = case user_message
+                  when /hello|hi|hey/
+                    'greeting'
+                  when /bye|goodbye|exit/
+                    'farewell'
+                  else
+                    'general_chat'
+                  end
+          
+          Rails.logger.info "Detected intent: #{intent}"
+          
+          {
+            intent: intent,
+            messages: [{ role: 'system', content: "Intent detected: #{intent}" }]
+          }
+        end
+        
+        node :generate_response do |state|
+          response = case state[:intent]
+                    when 'greeting'
+                      "Hello! How can I help you today?"
+                    when 'farewell'
+                      "Goodbye! Have a great day!"
+                    else
+                      "That's interesting! Tell me more."
+                    end
+          
+          Rails.logger.info "Bot response: #{response}"
+          
+          {
+            messages: [{ role: 'assistant', content: response }],
+            response: response
+          }
+        end
+        
+        # Define edges
+        set_entry_point :receive_input
+        edge :receive_input, :process_message
+        edge :process_message, :generate_response
+        set_finish_point :generate_response
+      end
+      
+      # Compile the graph
+      graph.compile!
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# LangGraphRB Rails Integration
+# This initializer configures LangGraphRB for use with Rails
+
+# Load configuration from config/langgraph_rb.yml
+config_file = Rails.root.join('config', 'langgraph_rb.yml')
+if File.exist?(config_file)
+  config = YAML.load(ERB.new(File.read(config_file)).result)[Rails.env]
+  LanggraphrbRails.configure do |c|
+    config.each do |key, value|
+      c.send("#{key}=", value) if c.respond_to?("#{key}=")
+    end
+  end
+end
+
+# Auto-load all graph definitions in app/graphs
+Rails.application.config.to_prepare do
+  Dir.glob(Rails.root.join('app', 'graphs', '**', '*.rb')).each do |file|
+    require_dependency file
+  end
+end
+
+# Configure default store
+# By default, LangGraphRB uses an in-memory store
+# You can configure it to use Redis or another store here
+# 
+# Example:
+# LanggraphrbRails.configure_store do |store_config|
+#   store_config.adapter = :redis
+#   store_config.options = { url: ENV['REDIS_URL'] }
+# end
+
+# Configure default observers
+# LanggraphrbRails.configure_observers do |observers|
+#   observers << LangGraphRB::Observers::Logger.new
+# end

data/lib/generators/langgraph_rb/install/templates/langgraph_rb.yml

@@ -0,0 +1,45 @@
+# LangGraphRB Configuration
+# This file contains configuration settings for LangGraphRB in your Rails application
+
+default: &default
+  # Store configuration
+  store:
+    adapter: memory  # Options: memory, redis, active_record
+    # Redis configuration (if using redis adapter)
+    # redis_url: <%= ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') %>
+    # redis_namespace: langgraph_rb
+    
+    # ActiveRecord configuration (if using active_record adapter)
+    # model: GraphState  # The model class to use for persistence
+    # ttl: 86400         # Optional TTL in seconds for cleanup
+  
+  # Observer configuration
+  observers:
+    # Enable logging observer
+    logger: true
+    # Enable structured observer
+    structured: false
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default
+  # In production, you might want to use Redis or ActiveRecord for persistence
+  store:
+    adapter: redis
+    redis_url: <%= ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') %>
+    redis_namespace: langgraph_rb
+    
+    # Alternatively, use ActiveRecord for persistence
+    # adapter: active_record
+    # model: GraphState
+    # ttl: 604800  # 7 days
+  
+  # Enable structured observer in production for better monitoring
+  observers:
+    logger: true
+    structured: true

data/lib/generators/langgraph_rb/install_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphRb
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include LanggraphRb::Generators::Compatibility
+      source_root File.expand_path('install/templates', __dir__)
+      
+      desc "Creates LangGraphRB initializer and configuration files for your application"
+      
+      def copy_initializer
+        template "initializer.rb", "config/initializers/langgraph_rb.rb"
+      end
+      
+      def copy_config
+        template "langgraph_rb.yml", "config/langgraph_rb.yml"
+      end
+      
+      def create_graphs_directory
+        empty_directory "app/graphs"
+        template "example_graph.rb", "app/graphs/example_graph.rb"
+      end
+      
+      def add_graphs_to_autoload_paths
+        application "config.autoload_paths += %W(#{Rails.root}/app/graphs)"
+      end
+      
+      def show_readme
+        readme "README"
+      end
+    end
+  end
+end

data/lib/generators/langgraph_rb/job/templates/job.rb

@@ -0,0 +1,38 @@
+class <%= job_class_name %> < ApplicationJob
+  queue_as :default
+
+  def perform(input, options = {})
+    # Create a store for persistence
+    store = LanggraphrbRails.create_store
+    
+    # Generate a thread ID or use the provided one
+    thread_id = options[:thread_id] || SecureRandom.hex(8)
+    
+    # Process with the graph
+    result = <%= graph_class_name %>.invoke(
+      { input: input },
+      context: options[:context],
+      store: store,
+      thread_id: thread_id
+    )
+    
+    # Handle the result
+    if options[:callback]
+      # If a callback is provided, call it with the result
+      callback_method = options[:callback].to_sym
+      if respond_to?(callback_method)
+        send(callback_method, result)
+      end
+    end
+    
+    # Return the result
+    result
+  end
+  
+  # Example callback method
+  def on_complete(result)
+    # Handle the completed result
+    # For example, send a notification, update a record, etc.
+    Rails.logger.info "Job completed with result: #{result[:response]}"
+  end
+end

data/lib/generators/langgraph_rb/job_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphRb
+  module Generators
+    class JobGenerator < Rails::Generators::NamedBase
+      include LanggraphRb::Generators::Compatibility
+      source_root File.expand_path('job/templates', __dir__)
+      
+      desc "Creates a new job for LangGraphRB background processing"
+      
+      def create_job_file
+        template "job.rb", File.join("app/jobs", "#{file_name}_job.rb")
+      end
+      
+      private
+      
+      def job_class_name
+        "#{class_name}Job"
+      end
+      
+      def graph_class_name
+        "#{class_name.gsub(/Job$/, '')}Graph"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
+  def change
+    create_table :<%= table_name %> do |t|
+      t.string :thread_id, null: false, index: { unique: true }
+      t.json :state
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+      t.timestamps
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+class <%= class_name %> < ApplicationRecord
+  # Serialize the state as JSON
+  serialize :state, JSON
+
+  # Validations
+  validates :thread_id, presence: true, uniqueness: true
+  
+  # Class methods for LangGraphRB integration
+  class << self
+    # Create a store adapter that uses this model for persistence
+    def to_store
+      LanggraphrbRails::Stores::ActiveRecordStore.new(model: self)
+    end
+  end
+end

data/lib/generators/langgraph_rb/model_generator.rb

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

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

@@ -0,0 +1,58 @@
+namespace :langgraph_rb do
+  namespace :<%= task_name %> do
+    desc "Process pending <%= class_name %> tasks"
+    task process: :environment do
+      # Your task implementation goes here
+      # Example:
+      # 
+      # require 'langgraphrb_rails'
+      # 
+      # # Get pending tasks from your data source
+      # pending_tasks = YourModel.where(status: 'pending')
+      # 
+      # # Process each task with LangGraphRB
+      # pending_tasks.each do |task|
+      #   begin
+      #     # Create a store for persistence
+      #     store = LanggraphrbRails.create_store
+      #     
+      #     # Process the task with your graph
+      #     result = <%= class_name %>Graph.invoke(
+      #       { input: task.input },
+      #       context: { task_id: task.id },
+      #       store: store,
+      #       thread_id: task.thread_id || SecureRandom.hex(8)
+      #     )
+      #     
+      #     # Update the task with the result
+      #     task.update!(
+      #       status: 'completed',
+      #       result: result[:response],
+      #       thread_id: result[:thread_id]
+      #     )
+      #   rescue => e
+      #     Rails.logger.error "Error processing task #{task.id}: #{e.message}"
+      #     task.update(status: 'error', error_message: e.message)
+      #   end
+      # end
+      
+      puts "Processed <%= class_name %> tasks"
+    end
+    
+    desc "Clean up expired <%= class_name %> tasks"
+    task cleanup: :environment do
+      # Example cleanup task
+      # 
+      # # Delete old tasks
+      # YourModel.where('created_at < ?', 30.days.ago).delete_all
+      # 
+      # # Clean up expired states from the store
+      # if defined?(GraphState)
+      #   store = LanggraphrbRails::Stores::ActiveRecordStore.new(model: GraphState)
+      #   store.cleanup_expired
+      # end
+      
+      puts "Cleaned up <%= class_name %> tasks"
+    end
+  end
+end

data/lib/generators/langgraph_rb/task_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphRb
+  module Generators
+    class TaskGenerator < Rails::Generators::NamedBase
+      include LanggraphRb::Generators::Compatibility
+      source_root File.expand_path('task/templates', __dir__)
+      
+      desc "Creates a new task for LangGraphRB background processing"
+      
+      def create_task_file
+        template "task.rake", File.join("lib/tasks", "#{file_name}.rake")
+      end
+      
+      private
+      
+      def task_name
+        file_name.underscore
+      end
+    end
+  end
+end

data/lib/generators/langgraphrb_rails/compatibility.rb

@@ -0,0 +1,71 @@
+module LanggraphrbRails
+  module Generators
+    module Compatibility
+      def self.included(base)
+        if defined?(Rails) && Gem::Version.new(Rails.version) >= Gem::Version.new('8.0.0')
+          # Explicitly require all necessary Rails generator components
+          begin
+            require 'rails/generators'
+            require 'rails/generators/actions'
+            require 'rails/generators/migration'
+            require 'rails/generators/active_model'
+            require 'rails/generators/base'
+            require 'rails/generators/named_base'
+            
+            # Define Actions module if it doesn't exist
+            unless defined?(Rails::Generators::Actions)
+              module Rails
+                module Generators
+                  module Actions
+                    # Minimal implementation of required methods
+                    def copy_file(source, destination, config = {})
+                      say_status :copy, "#{source} to #{destination}", config.fetch(:verbose, true)
+                    end
+                    
+                    def template(source, destination, config = {})
+                      say_status :template, "#{source} to #{destination}", config.fetch(:verbose, true)
+                    end
+                    
+                    def empty_directory(destination, config = {})
+                      say_status :create, destination, config.fetch(:verbose, true)
+                    end
+                    
+                    def inject_into_file(destination, content, config = {})
+                      say_status :inject, destination, config.fetch(:verbose, true)
+                    end
+                    
+                    def append_to_file(destination, content, config = {})
+                      say_status :append, destination, config.fetch(:verbose, true)
+                    end
+                    
+                    def gsub_file(destination, flag, replacement, config = {})
+                      say_status :gsub, destination, config.fetch(:verbose, true)
+                    end
+                    
+                    def application(data, config = {})
+                      say_status :application, data, config.fetch(:verbose, true)
+                    end
+                    
+                    def readme(path)
+                      say_status :readme, path, true
+                    end
+                    
+                    def say_status(status, message, log_status = true)
+                      puts "[#{status}] #{message}" if log_status
+                    end
+                  end
+                end
+              end
+            end
+            
+            # Include Actions module if it's now defined
+            base.include(Rails::Generators::Actions) if defined?(Rails::Generators::Actions)
+          rescue LoadError => e
+            # Fallback gracefully if we can't load all components
+            puts "Warning: Could not load all Rails generator components: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Controller < ApplicationController
+<% actions.each do |action| -%>
+  def <%= action %>
+<% if action == "index" -%>
+    @runs = LanggraphRun.where(graph: "<%= class_name %>Graph").recent.limit(10)
+<% elsif action == "show" -%>
+    @run = LanggraphRun.find(params[:id])
+<% elsif action == "create" -%>
+    # Start a new graph run
+    run = LangGraphRB.start!(
+      graph: "<%= class_name %>Graph",
+      context: { user_id: current_user&.id },
+      state: {}
+    )
+    
+    # Process the run in the background
+    Langgraph::RunJob.perform_later(run.id)
+    
+    respond_to do |format|
+      format.html { redirect_to <%= singular_table_name %>_path(run), notice: "Graph run started." }
+      format.json { render json: { run_id: run.id, status: run.status, current_node: run.current_node } }
+    end
+<% else -%>
+    # TODO: Implement <%= action %> action
+<% end -%>
+  end
+<% end -%>
+end

data/lib/generators/langgraphrb_rails/controller/templates/view.html.erb

@@ -0,0 +1,112 @@
+<%% content_for :title, "<%= class_name %> - <%= action.titleize %>" %>
+
+<div class="container mt-4">
+  <h1><%= class_name %> - <%= action.titleize %></h1>
+  
+  <%% if local_assigns[:notice] %>
+    <div class="alert alert-success"><%%= notice %></div>
+  <%% end %>
+  
+<% if action == "index" -%>
+  <div class="card">
+    <div class="card-header">
+      <h2>Recent Graph Runs</h2>
+    </div>
+    <div class="card-body">
+      <table class="table">
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Status</th>
+            <th>Current Node</th>
+            <th>Created</th>
+            <th>Actions</th>
+          </tr>
+        </thead>
+        <tbody>
+          <%% @runs.each do |run| %>
+            <tr>
+              <td><%%= run.id %></td>
+              <td><%%= run.status %></td>
+              <td><%%= run.current_node %></td>
+              <td><%%= run.created_at.to_s(:short) %></td>
+              <td>
+                <%%= link_to "View", <%= singular_table_name %>_path(run), class: "btn btn-sm btn-primary" %>
+              </td>
+            </tr>
+          <%% end %>
+        </tbody>
+      </table>
+      
+      <%%= link_to "New Run", { action: :new }, class: "btn btn-success" if respond_to?(:new) %>
+    </div>
+  </div>
+<% elsif action == "show" -%>
+  <div class="card">
+    <div class="card-header">
+      <h2>Graph Run #<%%= @run.id %></h2>
+    </div>
+    <div class="card-body">
+      <dl class="row">
+        <dt class="col-sm-3">Status</dt>
+        <dd class="col-sm-9"><%%= @run.status %></dd>
+        
+        <dt class="col-sm-3">Graph</dt>
+        <dd class="col-sm-9"><%%= @run.graph %></dd>
+        
+        <dt class="col-sm-3">Current Node</dt>
+        <dd class="col-sm-9"><%%= @run.current_node %></dd>
+        
+        <dt class="col-sm-3">Created</dt>
+        <dd class="col-sm-9"><%%= @run.created_at %></dd>
+        
+        <dt class="col-sm-3">Updated</dt>
+        <dd class="col-sm-9"><%%= @run.updated_at %></dd>
+        
+        <%% if @run.error.present? %>
+          <dt class="col-sm-3">Error</dt>
+          <dd class="col-sm-9"><%%= @run.error %></dd>
+        <%% end %>
+      </dl>
+      
+      <h3>State</h3>
+      <pre><%%= JSON.pretty_generate(@run.state) %></pre>
+      
+      <h3>Context</h3>
+      <pre><%%= JSON.pretty_generate(@run.context) %></pre>
+      
+      <%%= link_to "Back", <%= plural_table_name %>_path, class: "btn btn-secondary" %>
+    </div>
+  </div>
+<% elsif action == "new" || action == "edit" -%>
+  <div class="card">
+    <div class="card-header">
+      <h2><%= action.titleize %> <%= class_name %></h2>
+    </div>
+    <div class="card-body">
+      <%%= form_with(url: <%= action == "new" ? plural_table_name %>_path : <%= singular_table_name %>_path, method: <%= action == "new" ? ":post" : ":patch" %>) do |form| %>
+        <div class="form-group">
+          <%%= form.label :input, "Input" %>
+          <%%= form.text_area :input, class: "form-control", rows: 5 %>
+        </div>
+        
+        <div class="form-group mt-3">
+          <%%= form.submit "Submit", class: "btn btn-primary" %>
+          <%%= link_to "Cancel", <%= plural_table_name %>_path, class: "btn btn-secondary" %>
+        </div>
+      <%% end %>
+    </div>
+  </div>
+<% else -%>
+  <div class="card">
+    <div class="card-header">
+      <h2><%= action.titleize %></h2>
+    </div>
+    <div class="card-body">
+      <p>TODO: Implement <%= action %> view</p>
+      
+      <%%= link_to "Back", <%= plural_table_name %>_path, class: "btn btn-secondary" %>
+    </div>
+  </div>
+<% end -%>
+</div>

data/lib/generators/langgraphrb_rails/controller_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphrbRails
+  module Generators
+    class ControllerGenerator < Rails::Generators::NamedBase
+      include LanggraphrbRails::Generators::Compatibility
+      source_root File.expand_path('templates', __dir__)
+      
+      argument :actions, type: :array, default: [], banner: "action action"
+      
+      desc "Creates a controller for LanggraphRB graph interaction"
+      
+      def create_controller_file
+        template "controller.rb", "app/controllers/#{file_name}_controller.rb"
+      end
+      
+      def create_views
+        actions.each do |action|
+          template "view.html.erb", "app/views/#{file_name}/#{action}.html.erb"
+        end
+      end
+      
+      def add_routes
+        route "resources :#{file_name.pluralize}, only: [#{actions.map { |a| ":#{a}" }.join(', ')}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Graph
+  include LangGraphRB::Graph
+  
+  # Define nodes and edges
+<% if options[:nodes].present? %>
+  <%= node_connections.join("\n  ") %>
+<% else %>
+  node :start, to: :process
+  node :process, to: :finish
+  node :finish, terminal: true
+<% end %>
+end