rcrewai 0.2.0 → 0.3.0

data/lib/rcrewai/tools/email_sender.rb

@@ -7,10 +7,20 @@ require 'mail'
 module RCrewAI
   module Tools
     class EmailSender < Base
+      tool_name        'email_sender'
+      description      'Send an email via configured SMTP'
+      param :to,       type: :string, required: true,
+                       description: 'Recipient address. Multiple addresses may be separated by commas.'
+      param :subject,  type: :string, required: true, description: 'Email subject'
+      param :body,     type: :string, required: true, description: 'Email body (plain text or HTML)'
+      param :cc,       type: :string, required: false, description: 'CC recipients (comma-separated)'
+      param :bcc,      type: :string, required: false, description: 'BCC recipients (comma-separated)'
+      param :reply_to, type: :string, required: false, description: 'Reply-to address'
+      param :attachments, type: :array, required: false, items: { type: :string },
+                          description: 'File paths to attach. Allowed extensions: pdf, txt, doc(x), xls(x), jpg, png, gif, zip.'
+
       def initialize(**options)
         super()
-        @name = 'emailsender'
-        @description = 'Send emails via SMTP'
         @smtp_server = options[:smtp_server] || 'localhost'
         @smtp_port = options[:smtp_port] || 587
         @username = options[:username]
@@ -23,20 +33,20 @@ module RCrewAI
 
       def execute(**params)
         validate_params!(
-          params, 
-          required: [:to, :subject, :body], 
-          optional: [:cc, :bcc, :reply_to, :attachments]
+          params,
+          required: %i[to subject body],
+          optional: %i[cc bcc reply_to attachments]
         )
-        
+
         to_addresses = normalize_email_addresses(params[:to])
         cc_addresses = normalize_email_addresses(params[:cc]) if params[:cc]
         bcc_addresses = normalize_email_addresses(params[:bcc]) if params[:bcc]
-        
+
         begin
           validate_email_params!(to_addresses, cc_addresses, bcc_addresses, params)
           result = send_email(to_addresses, cc_addresses, bcc_addresses, params)
           format_email_result(result, to_addresses)
-        rescue => e
+        rescue StandardError => e
           "Email sending failed: #{e.message}"
         end
       end
@@ -70,33 +80,27 @@ module RCrewAI
       def validate_email_params!(to_addresses, cc_addresses, bcc_addresses, params)
         # Validate email addresses
         all_addresses = to_addresses + (cc_addresses || []) + (bcc_addresses || [])
-        
+
         all_addresses.each do |address|
-          unless valid_email?(address)
-            raise ToolError, "Invalid email address: #{address}"
-          end
+          raise ToolError, "Invalid email address: #{address}" unless valid_email?(address)
         end
-        
+
         # Check recipient limits
         if all_addresses.length > @max_recipients
           raise ToolError, "Too many recipients: #{all_addresses.length} (max: #{@max_recipients})"
         end
-        
+
         # Validate subject and body
-        if params[:subject].to_s.strip.empty?
-          raise ToolError, "Email subject cannot be empty"
-        end
-        
-        if params[:body].to_s.strip.empty?
-          raise ToolError, "Email body cannot be empty"
-        end
-        
+        raise ToolError, 'Email subject cannot be empty' if params[:subject].to_s.strip.empty?
+
+        raise ToolError, 'Email body cannot be empty' if params[:body].to_s.strip.empty?
+
         # Check for spam-like content
         validate_content_safety!(params[:subject], params[:body])
       end
 
       def valid_email?(address)
-        address.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+        address.match?(/\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i)
       end
 
       def validate_content_safety!(subject, body)
@@ -105,20 +109,18 @@ module RCrewAI
           'viagra', 'casino', 'lottery', 'winner', 'congratulations',
           'million dollars', 'click here', 'urgent', 'act now'
         ]
-        
+
         content = "#{subject} #{body}".downcase
-        
+
         spam_indicators.each do |indicator|
-          if content.include?(indicator)
-            raise ToolError, "Potentially spam content detected: #{indicator}"
-          end
+          raise ToolError, "Potentially spam content detected: #{indicator}" if content.include?(indicator)
         end
-        
+
         # Check for excessive caps
         caps_ratio = content.gsub(/[^A-Z]/, '').length.to_f / content.gsub(/[^A-Za-z]/, '').length
-        if caps_ratio > 0.5 && content.length > 50
-          raise ToolError, "Excessive capitalization detected (possible spam)"
-        end
+        return unless caps_ratio > 0.5 && content.length > 50
+
+        raise ToolError, 'Excessive capitalization detected (possible spam)'
       end
 
       def send_email(to_addresses, cc_addresses, bcc_addresses, params)
@@ -129,20 +131,16 @@ module RCrewAI
           bcc      bcc_addresses if bcc_addresses&.any?
           subject  params[:subject]
           body     params[:body]
-          
-          if params[:reply_to]
-            reply_to params[:reply_to]
-          end
+
+          reply_to params[:reply_to] if params[:reply_to]
         end
-        
+
         # Add attachments if provided
-        if params[:attachments]
-          add_attachments(mail, params[:attachments])
-        end
-        
+        add_attachments(mail, params[:attachments]) if params[:attachments]
+
         # Send the email
         mail.deliver!
-        
+
         {
           message_id: mail.message_id,
           to: to_addresses,
@@ -156,55 +154,49 @@ module RCrewAI
 
       def add_attachments(mail, attachments)
         attachment_list = case attachments
-                         when String
-                           [attachments]
-                         when Array
-                           attachments
-                         else
-                           [attachments.to_s]
-                         end
-        
+                          when String
+                            [attachments]
+                          when Array
+                            attachments
+                          else
+                            [attachments.to_s]
+                          end
+
         attachment_list.each do |attachment_path|
-          if File.exist?(attachment_path)
-            # Security check - only allow certain file types
-            allowed_extensions = %w[.pdf .txt .doc .docx .xls .xlsx .jpg .png .gif .zip]
-            extension = File.extname(attachment_path).downcase
-            
-            unless allowed_extensions.include?(extension)
-              raise ToolError, "Attachment file type not allowed: #{extension}"
-            end
-            
-            # Size check (max 10MB per attachment)
-            if File.size(attachment_path) > 10_000_000
-              raise ToolError, "Attachment too large: #{File.basename(attachment_path)} (max 10MB)"
-            end
-            
-            mail.add_file(attachment_path)
-          else
-            raise ToolError, "Attachment file not found: #{attachment_path}"
+          raise ToolError, "Attachment file not found: #{attachment_path}" unless File.exist?(attachment_path)
+
+          # Security check - only allow certain file types
+          allowed_extensions = %w[.pdf .txt .doc .docx .xls .xlsx .jpg .png .gif .zip]
+          extension = File.extname(attachment_path).downcase
+
+          unless allowed_extensions.include?(extension)
+            raise ToolError, "Attachment file type not allowed: #{extension}"
           end
+
+          # Size check (max 10MB per attachment)
+          if File.size(attachment_path) > 10_000_000
+            raise ToolError, "Attachment too large: #{File.basename(attachment_path)} (max 10MB)"
+          end
+
+          mail.add_file(attachment_path)
         end
       end
 
       def format_email_result(result, to_addresses)
         output = []
-        output << "Email sent successfully!"
+        output << 'Email sent successfully!'
         output << "Message ID: #{result[:message_id]}"
         output << "Recipients: #{to_addresses.join(', ')}"
         output << "Subject: #{result[:subject]}"
         output << "Sent at: #{result[:sent_at].strftime('%Y-%m-%d %H:%M:%S')}"
         output << "Message size: #{result[:size]} bytes"
-        
-        if result[:cc]&.any?
-          output << "CC: #{result[:cc].join(', ')}"
-        end
-        
-        if result[:bcc]&.any?
-          output << "BCC: #{result[:bcc].length} recipients"
-        end
-        
+
+        output << "CC: #{result[:cc].join(', ')}" if result[:cc]&.any?
+
+        output << "BCC: #{result[:bcc].length} recipients" if result[:bcc]&.any?
+
         output.join("\n")
       end
     end
   end
-end
+end

data/lib/rcrewai/tools/file_reader.rb

@@ -6,24 +6,31 @@ require 'pathname'
 module RCrewAI
   module Tools
     class FileReader < Base
+      tool_name        'file_reader'
+      description      'Read the contents of a text file from disk'
+      param :file_path, type: :string,  required: true,
+                        description: 'Absolute or relative path to the file'
+      param :encoding,  type: :string,  default: 'utf-8',
+                        description: 'Text encoding (e.g. utf-8, iso-8859-1)'
+      param :lines,     type: :integer, required: false,
+                        description: 'If set, read only the first N lines'
+
       def initialize(**options)
         super()
-        @name = 'filereader'
-        @description = 'Read contents from files'
         @max_file_size = options.fetch(:max_file_size, 10_000_000) # 10MB
         @allowed_extensions = options.fetch(:allowed_extensions, %w[.txt .md .json .yaml .yml .csv .log])
       end
 
       def execute(**params)
-        validate_params!(params, required: [:file_path], optional: [:encoding, :lines])
-        
+        validate_params!(params, required: [:file_path], optional: %i[encoding lines])
+
         file_path = params[:file_path]
         encoding = params[:encoding] || 'utf-8'
         lines = params[:lines] # Optional: read only N lines
-        
+
         begin
           read_file(file_path, encoding, lines)
-        rescue => e
+        rescue StandardError => e
           "File read failed: #{e.message}"
         end
       end
@@ -32,17 +39,17 @@ module RCrewAI
 
       def read_file(file_path, encoding, lines = nil)
         path = Pathname.new(file_path)
-        
+
         # Security checks
         validate_file_path!(path)
         validate_file_size!(path)
         validate_file_extension!(path)
-        
+
         content = if lines
-                   read_lines(path, encoding, lines)
-                 else
-                   read_full_file(path, encoding)
-                 end
+                    read_lines(path, encoding, lines)
+                  else
+                    read_full_file(path, encoding)
+                  end
 
         format_file_content(path, content, lines)
       end
@@ -51,27 +58,27 @@ module RCrewAI
         raise ToolError, "File does not exist: #{path}" unless path.exist?
         raise ToolError, "Path is not a file: #{path}" unless path.file?
         raise ToolError, "File is not readable: #{path}" unless path.readable?
-        
+
         # Prevent directory traversal
         resolved_path = path.realpath.to_s
         working_dir = Dir.pwd
-        unless resolved_path.start_with?(working_dir)
-          raise ToolError, "Access denied: file outside working directory"
-        end
+        return if resolved_path.start_with?(working_dir)
+
+        raise ToolError, 'Access denied: file outside working directory'
       end
 
       def validate_file_size!(path)
         size = path.size
-        if size > @max_file_size
-          raise ToolError, "File too large: #{size} bytes (max: #{@max_file_size})"
-        end
+        return unless size > @max_file_size
+
+        raise ToolError, "File too large: #{size} bytes (max: #{@max_file_size})"
       end
 
       def validate_file_extension!(path)
         extension = path.extname.downcase
-        unless @allowed_extensions.include?(extension) || @allowed_extensions.include?('*')
-          raise ToolError, "File type not allowed: #{extension}"
-        end
+        return if @allowed_extensions.include?(extension) || @allowed_extensions.include?('*')
+
+        raise ToolError, "File type not allowed: #{extension}"
       end
 
       def read_lines(path, encoding, line_count)
@@ -80,6 +87,7 @@ module RCrewAI
           line_count.times do
             line = file.gets
             break unless line
+
             lines << line.chomp
           end
         end
@@ -95,17 +103,17 @@ module RCrewAI
         header += " (first #{lines} lines)" if lines
         header += "\nSize: #{path.size} bytes"
         header += "\nModified: #{path.mtime.strftime('%Y-%m-%d %H:%M:%S')}"
-        header += "\n" + "="*50 + "\n"
-        
+        header += "\n#{'=' * 50}\n"
+
         # Truncate very long content for display
         display_content = if content.length > 5000
-                           content[0..4997] + "..."
-                         else
-                           content
-                         end
-        
+                            "#{content[0..4997]}..."
+                          else
+                            content
+                          end
+
         header + display_content
       end
     end
   end
-end
+end

data/lib/rcrewai/tools/file_writer.rb

@@ -7,26 +7,33 @@ require 'fileutils'
 module RCrewAI
   module Tools
     class FileWriter < Base
+      tool_name        'file_writer'
+      description      'Write content to a text file on disk'
+      param :file_path, type: :string, required: true, description: 'Path to write to'
+      param :content,   type: :string, required: true, description: 'Content to write'
+      param :mode,      type: :enum,   default: 'w',   values: %w[w a],
+                        description: "Write mode: 'w' to overwrite, 'a' to append"
+      param :encoding,  type: :string, default: 'utf-8',
+                        description: 'Text encoding'
+
       def initialize(**options)
         super()
-        @name = 'filewriter'
-        @description = 'Write content to files'
         @max_file_size = options.fetch(:max_file_size, 10_000_000) # 10MB
         @allowed_extensions = options.fetch(:allowed_extensions, %w[.txt .md .json .yaml .yml .csv .log])
         @create_directories = options.fetch(:create_directories, true)
       end
 
       def execute(**params)
-        validate_params!(params, required: [:file_path, :content], optional: [:mode, :encoding])
-        
+        validate_params!(params, required: %i[file_path content], optional: %i[mode encoding])
+
         file_path = params[:file_path]
         content = params[:content]
-        mode = params[:mode] || 'w'  # 'w' for write, 'a' for append
+        mode = params[:mode] || 'w' # 'w' for write, 'a' for append
         encoding = params[:encoding] || 'utf-8'
-        
+
         begin
           write_file(file_path, content, mode, encoding)
-        rescue => e
+        rescue StandardError => e
           "File write failed: #{e.message}"
         end
       end
@@ -35,20 +42,20 @@ module RCrewAI
 
       def write_file(file_path, content, mode, encoding)
         path = Pathname.new(file_path)
-        
+
         # Security checks
         validate_file_path!(path)
         validate_content!(content)
         validate_mode!(mode)
-        
+
         # Create directory if needed
         create_parent_directories!(path) if @create_directories
-        
+
         # Write the file
         File.open(path, mode, encoding: encoding) do |file|
           file.write(content)
         end
-        
+
         format_write_result(path, content, mode)
       end
 
@@ -56,60 +63,55 @@ module RCrewAI
         # Prevent directory traversal
         resolved_path = path.expand_path.to_s
         working_dir = Dir.pwd
-        unless resolved_path.start_with?(working_dir)
-          raise ToolError, "Access denied: file outside working directory"
-        end
-        
+        raise ToolError, 'Access denied: file outside working directory' unless resolved_path.start_with?(working_dir)
+
         # Check file extension
         extension = path.extname.downcase
         unless @allowed_extensions.include?(extension) || @allowed_extensions.include?('*')
           raise ToolError, "File type not allowed: #{extension}"
         end
-        
+
         # If file exists, check if it's writable
-        if path.exist?
-          raise ToolError, "Path is not a file: #{path}" unless path.file?
-          raise ToolError, "File is not writable: #{path}" unless path.writable?
-        end
+        return unless path.exist?
+        raise ToolError, "Path is not a file: #{path}" unless path.file?
+        raise ToolError, "File is not writable: #{path}" unless path.writable?
       end
 
       def validate_content!(content)
-        raise ToolError, "Content cannot be nil" if content.nil?
-        
+        raise ToolError, 'Content cannot be nil' if content.nil?
+
         content_size = content.bytesize
-        if content_size > @max_file_size
-          raise ToolError, "Content too large: #{content_size} bytes (max: #{@max_file_size})"
-        end
+        return unless content_size > @max_file_size
+
+        raise ToolError, "Content too large: #{content_size} bytes (max: #{@max_file_size})"
       end
 
       def validate_mode!(mode)
         valid_modes = %w[w a w+ a+ wb ab]
-        unless valid_modes.include?(mode)
-          raise ToolError, "Invalid file mode: #{mode}. Valid modes: #{valid_modes.join(', ')}"
-        end
+        return if valid_modes.include?(mode)
+
+        raise ToolError, "Invalid file mode: #{mode}. Valid modes: #{valid_modes.join(', ')}"
       end
 
       def create_parent_directories!(path)
         parent_dir = path.parent
-        unless parent_dir.exist?
-          FileUtils.mkdir_p(parent_dir)
-        end
+        return if parent_dir.exist?
+
+        FileUtils.mkdir_p(parent_dir)
       end
 
       def format_write_result(path, content, mode)
         action = mode.start_with?('a') ? 'appended to' : 'written to'
         size = content.bytesize
-        
+
         result = "Content successfully #{action} #{path.basename}\n"
         result += "File size: #{size} bytes\n"
         result += "Full path: #{path.expand_path}\n"
-        
-        if path.exist?
-          result += "File modified: #{path.mtime.strftime('%Y-%m-%d %H:%M:%S')}"
-        end
-        
+
+        result += "File modified: #{path.mtime.strftime('%Y-%m-%d %H:%M:%S')}" if path.exist?
+
         result
       end
     end
   end
-end
+end