langgraphrb_rails 0.1.0

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:minitest) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+
+  # Run both test suites
+  task :test => [:minitest, :spec]
+rescue LoadError
+  # RSpec not available, just use Minitest
+  task :test => :minitest
+end
+
+task default: :test

data/app/assets/javascripts/langgraphrb_rails.js

@@ -0,0 +1,153 @@
+// LangGraphRB Rails JavaScript
+// This file provides enhanced functionality for LangGraphRB Rails integration
+
+document.addEventListener('DOMContentLoaded', function() {
+  // Initialize all LangGraphRB chat interfaces
+  initLangGraphChats();
+});
+
+// Initialize all chat interfaces
+function initLangGraphChats() {
+  const chatForms = document.querySelectorAll('.langgraph-chat-form');
+  
+  chatForms.forEach(function(form) {
+    initChatForm(form);
+  });
+}
+
+// Initialize a single chat form
+function initChatForm(form) {
+  const container = form.closest('.langgraph-chat-container');
+  const messagesContainer = container.querySelector('.langgraph-messages');
+  
+  form.addEventListener('submit', function(event) {
+    // Check if this is a streaming form with an EventSource
+    if (form.dataset.streaming !== 'true') {
+      // Handle regular AJAX form submission
+      handleRegularFormSubmit(event, form, messagesContainer);
+    }
+  });
+  
+  // Auto-resize textarea
+  const textarea = form.querySelector('textarea');
+  if (textarea) {
+    textarea.addEventListener('input', function() {
+      this.style.height = 'auto';
+      this.style.height = (this.scrollHeight) + 'px';
+    });
+  }
+  
+  // Scroll to bottom initially
+  if (messagesContainer) {
+    messagesContainer.scrollTop = messagesContainer.scrollHeight;
+  }
+}
+
+// Handle regular form submission via AJAX
+function handleRegularFormSubmit(event, form, messagesContainer) {
+  event.preventDefault();
+  
+  const messageInput = form.querySelector('textarea, input[name="message"]');
+  const userMessage = messageInput.value.trim();
+  
+  if (!userMessage) return;
+  
+  // Add user message to the UI
+  addMessageToUI(messagesContainer, userMessage, 'user');
+  
+  // Clear the input
+  messageInput.value = '';
+  messageInput.style.height = 'auto';
+  
+  // Prepare form data
+  const formData = new FormData(form);
+  
+  // Show typing indicator if it exists
+  const typingIndicator = form.closest('.langgraph-chat-container').querySelector('.langgraph-typing-indicator');
+  if (typingIndicator) {
+    typingIndicator.style.display = 'block';
+  }
+  
+  // Send the AJAX request
+  fetch(form.action, {
+    method: form.method || 'POST',
+    body: formData,
+    headers: {
+      'Accept': 'application/json'
+    }
+  })
+  .then(response => response.json())
+  .then(data => {
+    // Hide typing indicator
+    if (typingIndicator) {
+      typingIndicator.style.display = 'none';
+    }
+    
+    // Add assistant response to the UI
+    if (data.response) {
+      addMessageToUI(messagesContainer, data.response, 'assistant');
+    }
+  })
+  .catch(error => {
+    console.error('Error:', error);
+    // Hide typing indicator
+    if (typingIndicator) {
+      typingIndicator.style.display = 'none';
+    }
+    
+    // Add error message
+    addMessageToUI(messagesContainer, 'Sorry, an error occurred. Please try again.', 'system');
+  });
+}
+
+// Add a message to the UI
+function addMessageToUI(container, message, role) {
+  const messageDiv = document.createElement('div');
+  messageDiv.className = `langgraph-message ${role}`;
+  
+  const messageP = document.createElement('p');
+  messageP.textContent = message;
+  
+  messageDiv.appendChild(messageP);
+  container.appendChild(messageDiv);
+  
+  // Scroll to bottom
+  container.scrollTop = container.scrollHeight;
+}
+
+// Setup streaming connection
+function setupEventSource(url, messagesContainer, typingIndicator) {
+  const eventSource = new EventSource(url);
+  
+  // 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) {
+    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;
+    }
+  };
+  
+  // Handle errors
+  eventSource.onerror = function() {
+    typingIndicator.style.display = 'none';
+    eventSource.close();
+  };
+  
+  return eventSource;
+}

data/app/assets/stylesheets/langgraphrb_rails.css

@@ -0,0 +1,95 @@
+/* LangGraphRB Rails Chat Interface Styles */
+
+.langgraph-chat-container {
+  max-width: 800px;
+  margin: 0 auto;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  overflow: hidden;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+  background-color: #fff;
+}
+
+.langgraph-messages {
+  height: 400px;
+  overflow-y: auto;
+  padding: 16px;
+  background-color: #f9f9f9;
+}
+
+.langgraph-message {
+  margin-bottom: 16px;
+  padding: 12px;
+  border-radius: 8px;
+  max-width: 80%;
+  word-wrap: break-word;
+}
+
+.langgraph-message.user {
+  background-color: #e3f2fd;
+  margin-left: auto;
+  text-align: right;
+}
+
+.langgraph-message.assistant {
+  background-color: #f5f5f5;
+}
+
+.langgraph-message.system {
+  background-color: #fff3e0;
+  font-style: italic;
+  max-width: 100%;
+  margin-bottom: 24px;
+  border-left: 3px solid #ffb74d;
+}
+
+.langgraph-chat-form {
+  display: flex;
+  flex-direction: column;
+  padding: 16px;
+  border-top: 1px solid #e0e0e0;
+}
+
+.langgraph-chat-input {
+  width: 100%;
+  padding: 12px;
+  border: 1px solid #e0e0e0;
+  border-radius: 4px;
+  margin-bottom: 8px;
+  resize: none;
+  min-height: 80px;
+}
+
+.langgraph-chat-submit {
+  align-self: flex-end;
+  padding: 8px 16px;
+  background-color: #2196f3;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-weight: bold;
+}
+
+.langgraph-chat-submit:hover {
+  background-color: #1976d2;
+}
+
+.langgraph-typing-indicator {
+  display: none;
+  padding: 8px;
+  text-align: center;
+  font-style: italic;
+  color: #757575;
+}
+
+.langgraph-typing-indicator::after {
+  content: "...";
+  animation: typing-dots 1.5s infinite;
+}
+
+@keyframes typing-dots {
+  0%, 20% { content: "."; }
+  40% { content: ".."; }
+  60%, 100% { content: "..."; }
+}

data/lib/generators/langgraph_rb/compatibility.rb

@@ -0,0 +1,71 @@
+module LanggraphRb
+  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/langgraph_rb/controller/templates/controller.rb

@@ -0,0 +1,54 @@
+class <%= class_name %>Controller < ApplicationController
+  # GET /<%= file_name %>
+  def index
+    # You can render a view with a form to interact with the graph
+  end
+
+  # POST /<%= file_name %>
+  def create
+    # Process the input with the graph
+    result = <%= graph_class_name %>.invoke(input: params[:message])
+    
+    respond_to do |format|
+      format.html { redirect_to <%= singular_table_name %>_path(id: result[:thread_id]), notice: "Processing complete" }
+      format.json { render json: { response: result[:response], thread_id: result[:thread_id] } }
+    end
+  end
+
+  # GET /<%= file_name %>/stream
+  def stream
+    response.headers['Content-Type'] = 'text/event-stream'
+    response.headers['Last-Modified'] = Time.now.httpdate
+    
+    <%= graph_class_name %>.stream(input: params[:message]) do |step_result|
+      response.stream.write("data: #{step_result.to_json}\n\n")
+      
+      if step_result[:completed]
+        response.stream.close
+      end
+    end
+  rescue ActionController::Live::ClientDisconnected
+    response.stream.close
+  end
+
+  # GET /<%= file_name %>/:id
+  def show
+    # Retrieve the thread state if needed
+    thread_id = params[:id]
+    store = LanggraphrbRails.create_store
+    
+    if store.exists?(thread_id)
+      @state = store.get(thread_id)
+      
+      respond_to do |format|
+        format.html
+        format.json { render json: @state }
+      end
+    else
+      respond_to do |format|
+        format.html { redirect_to <%= plural_table_name %>_path, alert: "Thread not found" }
+        format.json { render json: { error: "Thread not found" }, status: :not_found }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+<%% content_for :title, "<%= class_name %>" %>
+
+<div class="container mt-4">
+  <div class="row">
+    <div class="col-md-8 offset-md-2">
+      <div class="card">
+        <div class="card-header">
+          <h2><%= class_name %></h2>
+        </div>
+        <div class="card-body">
+          <div id="messages-container" class="mb-4">
+            <div class="system-message">
+              <p>Welcome to <%= class_name %>. How can I help you today?</p>
+            </div>
+            
+            <div id="message-history">
+              <%% if @state && @state[:messages] %>
+                <%% @state[:messages].each do |message| %>
+                  <div class="message <%%= message[:role] %>">
+                    <p><%%= message[:content] %></p>
+                  </div>
+                <%% end %>
+              <%% end %>
+            </div>
+          </div>
+          
+          <%%= form_with url: <%= plural_table_name %>_path, method: :post, id: "message-form", data: { remote: true } do |f| %>
+            <div class="form-group">
+              <%%= f.text_area :message, class: "form-control", placeholder: "Type your message here...", rows: 3 %>
+            </div>
+            <div class="form-group">
+              <%%= f.submit "Send", class: "btn btn-primary" %>
+            </div>
+          <%% end %>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<style>
+  #messages-container {
+    max-height: 400px;
+    overflow-y: auto;
+    border: 1px solid #e0e0e0;
+    border-radius: 5px;
+    padding: 10px;
+  }
+  
+  .message {
+    margin-bottom: 10px;
+    padding: 10px;
+    border-radius: 5px;
+  }
+  
+  .user {
+    background-color: #f0f0f0;
+    text-align: right;
+  }
+  
+  .assistant {
+    background-color: #e3f2fd;
+  }
+  
+  .system-message {
+    background-color: #f5f5f5;
+    padding: 10px;
+    border-radius: 5px;
+    margin-bottom: 10px;
+    font-style: italic;
+  }
+</style>
+
+<script>
+  document.addEventListener('DOMContentLoaded', function() {
+    const form = document.getElementById('message-form');
+    const messagesContainer = document.getElementById('message-history');
+    
+    form.addEventListener('ajax:success', function(event) {
+      const [data, status, xhr] = event.detail;
+      
+      // Add user message to the UI
+      const userMessage = document.createElement('div');
+      userMessage.className = 'message user';
+      userMessage.innerHTML = '<p>' + form.elements['message'].value + '</p>';
+      messagesContainer.appendChild(userMessage);
+      
+      // Add assistant response to the UI
+      const assistantMessage = document.createElement('div');
+      assistantMessage.className = 'message assistant';
+      assistantMessage.innerHTML = '<p>' + data.response + '</p>';
+      messagesContainer.appendChild(assistantMessage);
+      
+      // Clear the form
+      form.elements['message'].value = '';
+      
+      // Scroll to bottom
+      messagesContainer.scrollTop = messagesContainer.scrollHeight;
+    });
+  });
+</script>

data/lib/generators/langgraph_rb/controller_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphRb
+  module Generators
+    class ControllerGenerator < Rails::Generators::NamedBase
+      include LanggraphRb::Generators::Compatibility
+      source_root File.expand_path('controller/templates', __dir__)
+      
+      desc "Creates a new controller for LangGraphRB interactions"
+      
+      argument :actions, type: :array, default: [], banner: "action action"
+      
+      def create_controller_file
+        template "controller.rb", File.join("app/controllers", "#{file_name}_controller.rb")
+      end
+      
+      def create_views
+        actions.each do |action|
+          template "view.html.erb", File.join("app/views", file_name, "#{action}.html.erb")
+        end
+      end
+      
+      def add_routes
+        route "resources :#{file_name}, only: [:index, :create, :show] do\n" +
+              "    collection do\n" +
+              "      get :stream\n" +
+              "    end\n" +
+              "  end"
+      end
+      
+      private
+      
+      def graph_class_name
+        "#{class_name.singularize}Graph"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# <%= graph_class_name %> - LangGraphRB graph
+# Generated with langgraphrb_rails
+
+class <%= graph_class_name %>
+  # 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
+      # Define your state schema and reducers here
+      initial_state = LangGraphRB::State.new(
+        { messages: [] },
+        { messages: LangGraphRB::State.add_messages }
+      )
+      
+      # Create the graph
+      graph = LangGraphRB::Graph.new(state_class: LangGraphRB::State) do
+        # Define your nodes here
+        node :receive_input do |state|
+          Rails.logger.info "Processing input in <%= graph_class_name %>"
+          {
+            messages: [{ role: 'user', content: state[:input] }],
+            input_processed: true
+          }
+        end
+        
+        node :process do |state|
+          # Add your processing logic here
+          {
+            processed: true,
+            result: "Processed: #{state[:input]}"
+          }
+        end
+        
+        node :respond do |state|
+          # Generate a response
+          response = "This is a response from <%= graph_class_name %>"
+          
+          {
+            messages: [{ role: 'assistant', content: response }],
+            response: response
+          }
+        end
+        
+        # Define your edges here
+        set_entry_point :receive_input
+        edge :receive_input, :process
+        edge :process, :respond
+        set_finish_point :respond
+      end
+      
+      # Compile the graph
+      graph.compile!
+    end
+  end
+end

data/lib/generators/langgraph_rb/graph_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators/base'
+require_relative 'compatibility'
+
+module LanggraphRb
+  module Generators
+    class GraphGenerator < Rails::Generators::NamedBase
+      include LanggraphRb::Generators::Compatibility
+      source_root File.expand_path('graph/templates', __dir__)
+      
+      desc "Creates a new LangGraphRB graph in app/graphs"
+      
+      def create_graph_file
+        template "graph.rb", File.join("app/graphs", "#{file_name}_graph.rb")
+      end
+      
+      private
+      
+      def graph_class_name
+        "#{class_name}Graph"
+      end
+    end
+  end
+end

data/lib/generators/langgraph_rb/install/templates/README

@@ -0,0 +1,45 @@
+===============================================================================
+
+LangGraphRB Rails Integration
+============================
+
+Your LangGraphRB Rails integration has been successfully installed!
+
+Next steps:
+
+1. Review the configuration in config/langgraph_rb.yml and adjust as needed
+
+2. Check out the example graph in app/graphs/example_graph.rb
+
+3. Create your own graphs in the app/graphs directory
+
+4. Use your graphs in your controllers like this:
+
+   ```ruby
+   # In a controller action
+   def chat
+     user_input = params[:message]
+     result = ExampleGraph.invoke(input: user_input)
+     render json: { response: result[:response] }
+   end
+   ```
+
+5. For streaming responses, use:
+
+   ```ruby
+   # In a controller action with Turbo Streams or ActionCable
+   def stream_chat
+     ExampleGraph.stream(input: params[:message]) do |step_result|
+       # Send step_result to the client via ActionCable or Turbo Streams
+       if step_result[:completed]
+         # Final result
+       else
+         # Intermediate result
+       end
+     end
+   end
+   ```
+
+For more information, visit: https://github.com/cdaviis/langgraphrb_rails
+
+===============================================================================