rcrewai-rails 0.1.1

data/lib/rcrewai/rails/agent_builder.rb

@@ -0,0 +1,123 @@
+module RcrewAI
+  module Rails
+    module AgentBuilder
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :agent
+      end
+
+      class_methods do
+        def agent_role(role = nil)
+          @agent_role = role if role
+          @agent_role || "AI Assistant"
+        end
+
+        def agent_goal(goal = nil)
+          @agent_goal = goal if goal
+          @agent_goal || "Complete assigned tasks efficiently"
+        end
+
+        def agent_backstory(backstory = nil)
+          @agent_backstory = backstory if backstory
+          @agent_backstory || "You are a helpful AI assistant."
+        end
+
+        def memory_enabled(enabled = nil)
+          @memory_enabled = enabled unless enabled.nil?
+          @memory_enabled || true
+        end
+
+        def allow_delegation(allowed = nil)
+          @allow_delegation = allowed unless allowed.nil?
+          @allow_delegation || false
+        end
+
+        def max_iterations(iterations = nil)
+          @max_iterations = iterations if iterations
+          @max_iterations || 25
+        end
+
+        def tools(*tool_classes)
+          @tools ||= []
+          @tools.concat(tool_classes) if tool_classes.any?
+          @tools
+        end
+
+        def llm_config(config = nil)
+          @llm_config = config if config
+          @llm_config || default_llm_config
+        end
+
+        private
+
+        def default_llm_config
+          {
+            provider: RcrewAI::Rails.config.default_llm_provider,
+            model: RcrewAI::Rails.config.default_llm_model
+          }
+        end
+      end
+
+      def initialize(attributes = {})
+        @attributes = attributes
+        @agent = build_agent
+        setup_tools
+        configure_agent
+      end
+
+      def to_agent
+        @agent
+      end
+
+      def to_rcrew_agent
+        @agent
+      end
+
+      protected
+
+      def build_agent
+        RCrewAI::Agent.new(
+          role: @attributes[:role] || self.class.agent_role,
+          goal: @attributes[:goal] || self.class.agent_goal,
+          backstory: @attributes[:backstory] || self.class.agent_backstory,
+          memory: @attributes[:memory] || self.class.memory_enabled,
+          verbose: verbose?,
+          allow_delegation: @attributes[:allow_delegation] || self.class.allow_delegation,
+          max_iter: @attributes[:max_iterations] || self.class.max_iterations,
+          llm: @attributes[:llm_config] || self.class.llm_config
+        )
+      end
+
+      def setup_tools
+        tools = instantiate_tools
+        @agent.tools = tools if tools.any?
+      end
+
+      def instantiate_tools
+        tool_classes = @attributes[:tools] || self.class.tools
+        tool_classes.map do |tool_class|
+          case tool_class
+          when Class
+            tool_class.new
+          when Hash
+            klass = tool_class[:class] || tool_class["class"]
+            params = tool_class[:params] || tool_class["params"] || {}
+            klass = klass.constantize if klass.is_a?(String)
+            klass.new(**params.symbolize_keys)
+          else
+            tool_class
+          end
+        end
+      end
+
+      def configure_agent
+        # Override in subclass for additional configuration
+      end
+
+      def verbose?
+        ::Rails.env.development? || ENV['RCREWAI_VERBOSE'] == 'true'
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/configuration.rb

@@ -0,0 +1,22 @@
+module RcrewAI
+  module Rails
+    class Configuration
+      attr_accessor :job_queue_name, :enable_web_ui, :persistence_backend,
+                    :default_llm_provider, :default_llm_model, :max_retries,
+                    :timeout, :enable_logging, :log_level, :async_execution
+
+      def initialize
+        @job_queue_name = "default"
+        @enable_web_ui = true
+        @persistence_backend = :active_record
+        @default_llm_provider = "openai"
+        @default_llm_model = "gpt-4"
+        @max_retries = 3
+        @timeout = 300 # 5 minutes
+        @enable_logging = true
+        @log_level = :info
+        @async_execution = true # Use ActiveJob for async by default
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/crew_builder.rb

@@ -0,0 +1,112 @@
+module RcrewAI
+  module Rails
+    module CrewBuilder
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :crew
+      end
+
+      class_methods do
+        def crew_name(name = nil)
+          if name
+            @crew_name = name
+          else
+            @crew_name || self.name.underscore.gsub(/_crew$/, '')
+          end
+        end
+
+        def crew_description(description = nil)
+          @crew_description = description if description
+          @crew_description
+        end
+
+        def process_type(type = nil)
+          @process_type = type if type
+          @process_type || :sequential
+        end
+
+        def memory_enabled(enabled = nil)
+          @memory_enabled = enabled unless enabled.nil?
+          @memory_enabled || false
+        end
+
+        def cache_enabled(enabled = nil)
+          @cache_enabled = enabled unless enabled.nil?
+          @cache_enabled || true
+        end
+      end
+
+      def initialize
+        @crew = find_or_create_crew
+        setup_agents
+        setup_tasks
+        setup_callbacks
+      end
+
+      def execute(inputs = {})
+        if RcrewAI::Rails.config.async_execution
+          @crew.execute_async(inputs)
+        else
+          @crew.execute_sync(inputs)
+        end
+      end
+
+      def execute_async(inputs = {})
+        @crew.execute_async(inputs)
+      end
+
+      def execute_sync(inputs = {})
+        @crew.execute_sync(inputs)
+      end
+
+      protected
+
+      def find_or_create_crew
+        RcrewAI::Rails::Crew.find_or_create_by(name: self.class.crew_name) do |crew|
+          crew.description = self.class.crew_description
+          crew.process_type = self.class.process_type.to_s
+          crew.memory_enabled = self.class.memory_enabled
+          crew.cache_enabled = self.class.cache_enabled
+          crew.verbose = verbose?
+        end
+      end
+
+      def setup_agents
+        # Override in subclass
+      end
+
+      def setup_tasks
+        # Override in subclass
+      end
+
+      def setup_callbacks
+        # Override in subclass
+      end
+
+      def verbose?
+        ::Rails.env.development? || ENV['RCREWAI_VERBOSE'] == 'true'
+      end
+
+      def create_agent(name, attributes = {})
+        @crew.agents.find_or_create_by(name: name) do |agent|
+          agent.assign_attributes(attributes)
+        end
+      end
+
+      def create_task(description, attributes = {})
+        @crew.tasks.find_or_create_by(description: description) do |task|
+          task.assign_attributes(attributes)
+        end
+      end
+
+      def assign_agent_to_task(agent, task)
+        task.agents << agent unless task.agents.include?(agent)
+      end
+
+      def add_task_dependency(task, dependency)
+        task.add_dependency(dependency)
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/engine.rb

@@ -0,0 +1,38 @@
+module RcrewAI
+  module Rails
+    class Engine < ::Rails::Engine
+      isolate_namespace RcrewAI::Rails
+
+      config.generators do |g|
+        g.test_framework :rspec
+        g.fixture_replacement :factory_bot
+        g.factory_bot dir: 'spec/factories'
+      end
+
+      initializer "rcrewai_rails.assets" do |app|
+        app.config.assets.paths << root.join("app/assets/stylesheets")
+        app.config.assets.paths << root.join("app/assets/javascripts")
+      end
+
+      initializer "rcrewai_rails.load_models" do
+        ActiveSupport.on_load(:active_record) do
+          Dir[Engine.root.join("app/models/rcrewai/rails/*.rb")].each { |f| require f }
+        end
+      end
+
+      initializer "rcrewai_rails.load_jobs" do
+        ActiveSupport.on_load(:active_job) do
+          Dir[Engine.root.join("app/jobs/rcrewai/rails/*.rb")].each { |f| require f }
+        end
+      end
+
+      initializer "rcrewai_rails.configure" do |app|
+        RcrewAI::Rails.configure do |config|
+          config.job_queue_name = ENV.fetch("RCREWAI_QUEUE", "default")
+          config.enable_web_ui = ENV.fetch("RCREWAI_WEB_UI", "true") == "true"
+          config.async_execution = ENV.fetch("RCREWAI_ASYNC", "true") == "true"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/tools/action_mailer_tool.rb

@@ -0,0 +1,60 @@
+module RcrewAI
+  module Rails
+    module Tools
+      class ActionMailerTool < RCrewAI::Tools::Base
+        def initialize(mailer_class: nil, allowed_methods: [])
+          @mailer_class = mailer_class
+          @allowed_methods = allowed_methods
+          super(
+            name: "Action Mailer Tool",
+            description: "Send emails using Rails Action Mailer"
+          )
+        end
+
+        def execute(mailer_method, params = {}, deliver_method = :deliver_later)
+          validate_mailer_method!(mailer_method)
+          
+          mailer = get_mailer_class(params.delete(:mailer) || @mailer_class)
+          
+          # Build the mail object
+          mail = mailer.send(mailer_method, **params)
+          
+          # Deliver based on specified method
+          case deliver_method.to_sym
+          when :deliver_now
+            mail.deliver_now
+            { status: "sent", method: mailer_method, delivered_at: Time.current }
+          when :deliver_later
+            job = mail.deliver_later
+            { status: "queued", method: mailer_method, job_id: job.job_id }
+          when :deliver_later_at
+            delivery_time = params.delete(:at) || 1.hour.from_now
+            job = mail.deliver_later(wait_until: delivery_time)
+            { status: "scheduled", method: mailer_method, job_id: job.job_id, scheduled_for: delivery_time }
+          else
+            { error: "Unknown delivery method: #{deliver_method}" }
+          end
+        rescue => e
+          { error: "Failed to send email", message: e.message }
+        end
+
+        private
+
+        def validate_mailer_method!(method)
+          if @allowed_methods.any? && !@allowed_methods.include?(method.to_sym)
+            raise ArgumentError, "Mailer method '#{method}' is not allowed"
+          end
+        end
+
+        def get_mailer_class(mailer_name)
+          return @mailer_class if @mailer_class && mailer_name.nil?
+          
+          mailer_name = "#{mailer_name.to_s.camelize}Mailer" unless mailer_name.to_s.end_with?("Mailer")
+          mailer_name.constantize
+        rescue NameError
+          raise ArgumentError, "Mailer class '#{mailer_name}' not found"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/tools/active_record_tool.rb

@@ -0,0 +1,67 @@
+module RcrewAI
+  module Rails
+    module Tools
+      class ActiveRecordTool < RCrewAI::Tools::Base
+        def initialize(model_class: nil, allowed_methods: [:find, :where, :count])
+          @model_class = model_class
+          @allowed_methods = allowed_methods
+          super(
+            name: "ActiveRecord Query Tool",
+            description: "Query Rails database using ActiveRecord"
+          )
+        end
+
+        def execute(query_type, conditions = {})
+          validate_query_type!(query_type)
+          
+          model = get_model_class(conditions.delete(:model) || @model_class)
+          
+          case query_type.to_sym
+          when :find
+            model.find(conditions[:id])
+          when :find_by
+            model.find_by(conditions)
+          when :where
+            model.where(conditions)
+          when :count
+            conditions.empty? ? model.count : model.where(conditions).count
+          when :pluck
+            field = conditions.delete(:field)
+            model.where(conditions).pluck(field)
+          when :exists?
+            model.exists?(conditions)
+          when :first
+            model.where(conditions).first
+          when :last
+            model.where(conditions).last
+          when :all
+            model.where(conditions).to_a
+          else
+            raise ArgumentError, "Unsupported query type: #{query_type}"
+          end
+        rescue ActiveRecord::RecordNotFound => e
+          { error: "Record not found", message: e.message }
+        rescue => e
+          { error: "Query failed", message: e.message }
+        end
+
+        private
+
+        def validate_query_type!(query_type)
+          unless @allowed_methods.include?(query_type.to_sym)
+            raise ArgumentError, "Query type '#{query_type}' is not allowed"
+          end
+        end
+
+        def get_model_class(model_name)
+          return @model_class if @model_class && model_name.nil?
+          
+          model_name = model_name.to_s.camelize
+          model_name.constantize
+        rescue NameError
+          raise ArgumentError, "Model class '#{model_name}' not found"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/tools/active_storage_tool.rb

@@ -0,0 +1,122 @@
+module RcrewAI
+  module Rails
+    module Tools
+      class ActiveStorageTool < RCrewAI::Tools::Base
+        def initialize(allowed_operations: [:attach, :download, :analyze])
+          @allowed_operations = allowed_operations
+          super(
+            name: "Active Storage Tool",
+            description: "Manage file attachments using Rails Active Storage"
+          )
+        end
+
+        def execute(operation, params = {})
+          validate_operation!(operation)
+          
+          case operation.to_sym
+          when :attach
+            attach_file(params)
+          when :download
+            download_file(params)
+          when :analyze
+            analyze_file(params)
+          when :delete
+            delete_file(params)
+          when :url
+            get_url(params)
+          else
+            { error: "Unknown operation: #{operation}" }
+          end
+        rescue => e
+          { error: "Active Storage operation failed", message: e.message }
+        end
+
+        private
+
+        def validate_operation!(operation)
+          unless @allowed_operations.include?(operation.to_sym)
+            raise ArgumentError, "Operation '#{operation}' is not allowed"
+          end
+        end
+
+        def attach_file(params)
+          record = find_record(params[:model], params[:id])
+          attachment_name = params[:attachment_name] || :file
+          
+          file = params[:file] || params[:io]
+          filename = params[:filename] || "attachment"
+          content_type = params[:content_type] || "application/octet-stream"
+          
+          record.send(attachment_name).attach(
+            io: file,
+            filename: filename,
+            content_type: content_type
+          )
+          
+          { attached: true, filename: filename, record_id: record.id }
+        end
+
+        def download_file(params)
+          blob = find_blob(params)
+          
+          {
+            filename: blob.filename.to_s,
+            content_type: blob.content_type,
+            byte_size: blob.byte_size,
+            data: blob.download
+          }
+        end
+
+        def analyze_file(params)
+          blob = find_blob(params)
+          blob.analyze unless blob.analyzed?
+          
+          {
+            filename: blob.filename.to_s,
+            content_type: blob.content_type,
+            byte_size: blob.byte_size,
+            metadata: blob.metadata,
+            analyzed: blob.analyzed?
+          }
+        end
+
+        def delete_file(params)
+          blob = find_blob(params)
+          filename = blob.filename.to_s
+          blob.purge
+          
+          { deleted: true, filename: filename }
+        end
+
+        def get_url(params)
+          blob = find_blob(params)
+          expires_in = params[:expires_in] || 5.minutes
+          
+          {
+            url: ::Rails.application.routes.url_helpers.rails_blob_url(blob, expires_in: expires_in),
+            expires_at: expires_in.from_now
+          }
+        end
+
+        def find_record(model_name, id)
+          model_class = model_name.to_s.camelize.constantize
+          model_class.find(id)
+        end
+
+        def find_blob(params)
+          if params[:blob_id]
+            ActiveStorage::Blob.find(params[:blob_id])
+          elsif params[:signed_id]
+            ActiveStorage::Blob.find_signed(params[:signed_id])
+          elsif params[:key]
+            ActiveStorage::Blob.find_by!(key: params[:key])
+          else
+            record = find_record(params[:model], params[:id])
+            attachment_name = params[:attachment_name] || :file
+            record.send(attachment_name).blob
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/tools/rails_cache_tool.rb

@@ -0,0 +1,69 @@
+module RcrewAI
+  module Rails
+    module Tools
+      class RailsCacheTool < RCrewAI::Tools::Base
+        def initialize
+          super(
+            name: "Rails Cache Tool",
+            description: "Read and write to Rails cache"
+          )
+        end
+
+        def execute(action, key, value = nil, options = {})
+          case action.to_sym
+          when :read
+            read_cache(key)
+          when :write
+            write_cache(key, value, options)
+          when :delete
+            delete_cache(key)
+          when :exist?
+            cache_exists?(key)
+          when :fetch
+            fetch_cache(key, options) { value }
+          when :clear
+            clear_cache
+          else
+            { error: "Unknown action: #{action}" }
+          end
+        rescue => e
+          { error: "Cache operation failed", message: e.message }
+        end
+
+        private
+
+        def read_cache(key)
+          value = ::Rails.cache.read(key)
+          { key: key, value: value, exists: !value.nil? }
+        end
+
+        def write_cache(key, value, options = {})
+          success = ::Rails.cache.write(key, value, options)
+          { key: key, written: success }
+        end
+
+        def delete_cache(key)
+          deleted = ::Rails.cache.delete(key)
+          { key: key, deleted: deleted }
+        end
+
+        def cache_exists?(key)
+          exists = ::Rails.cache.exist?(key)
+          { key: key, exists: exists }
+        end
+
+        def fetch_cache(key, options = {})
+          value = ::Rails.cache.fetch(key, options) do
+            yield if block_given?
+          end
+          { key: key, value: value }
+        end
+
+        def clear_cache
+          ::Rails.cache.clear
+          { cleared: true }
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/tools/rails_logger_tool.rb

@@ -0,0 +1,57 @@
+module RcrewAI
+  module Rails
+    module Tools
+      class RailsLoggerTool < RCrewAI::Tools::Base
+        def initialize(tag: "RcrewAI")
+          @tag = tag
+          super(
+            name: "Rails Logger Tool",
+            description: "Log messages to Rails logger"
+          )
+        end
+
+        def execute(level, message, metadata = {})
+          logger = ::Rails.logger
+          
+          # Format the message with metadata
+          formatted_message = format_message(message, metadata)
+          
+          case level.to_sym
+          when :debug
+            logger.debug(formatted_message)
+          when :info
+            logger.info(formatted_message)
+          when :warn
+            logger.warn(formatted_message)
+          when :error
+            logger.error(formatted_message)
+          when :fatal
+            logger.fatal(formatted_message)
+          else
+            return { error: "Unknown log level: #{level}" }
+          end
+
+          # Also instrument for monitoring
+          ActiveSupport::Notifications.instrument("log.rcrewai", {
+            level: level,
+            message: message,
+            metadata: metadata,
+            tag: @tag
+          })
+
+          { logged: true, level: level, message: message }
+        rescue => e
+          { error: "Logging failed", message: e.message }
+        end
+
+        private
+
+        def format_message(message, metadata)
+          return "[#{@tag}] #{message}" if metadata.empty?
+          
+          "[#{@tag}] #{message} | #{metadata.to_json}"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/rails/version.rb

@@ -0,0 +1,5 @@
+module RcrewAI
+  module Rails
+    VERSION = "0.1.1"
+  end
+end