rcrewai 0.2.0 → 0.3.0

data/lib/rcrewai/tools/pdf_processor.rb

@@ -7,11 +7,21 @@ require 'pathname'
 module RCrewAI
   module Tools
     class PdfProcessor < Base
+      tool_name        'pdf_processor'
+      description      'Extract text from a PDF file'
+      param :file_path,        type: :string, required: true, description: 'Path to the PDF'
+      param :pages,            type: :string, required: false,
+                               description: "Page selector: 'all', a range like '1-5', or comma-separated like '1,3,5'"
+      param :extract_text,     type: :boolean, default: true,
+                               description: 'Whether to extract page text'
+      param :extract_metadata, type: :boolean, default: true,
+                               description: 'Whether to extract PDF metadata (title, author, etc.)'
+      param :output_format,    type: :enum, default: 'text', values: %w[text json markdown],
+                               description: "Output format: 'text', 'json', or 'markdown'"
+
       def initialize(**options)
         super()
-        @name = 'pdfprocessor'
-        @description = 'Read and extract text from PDF files'
-        @max_file_size = options.fetch(:max_file_size, 50_000_000)  # 50MB
+        @max_file_size = options.fetch(:max_file_size, 50_000_000) # 50MB
         @max_pages = options.fetch(:max_pages, 100)
         @extract_metadata = options.fetch(:extract_metadata, true)
         @working_directory = options[:working_directory] || Dir.pwd
@@ -19,22 +29,22 @@ module RCrewAI
 
       def execute(**params)
         validate_params!(
-          params, 
-          required: [:file_path], 
-          optional: [:pages, :extract_text, :extract_metadata, :output_format]
+          params,
+          required: [:file_path],
+          optional: %i[pages extract_text extract_metadata output_format]
         )
-        
+
         file_path = params[:file_path]
-        pages = params[:pages]  # Can be array [1,2,3] or range "1-5" or "all"
+        pages = params[:pages] # Can be array [1,2,3] or range "1-5" or "all"
         extract_text = params.fetch(:extract_text, true)
         extract_metadata = params.fetch(:extract_metadata, @extract_metadata)
-        output_format = params.fetch(:output_format, 'text')  # 'text', 'json', 'markdown'
-        
+        output_format = params.fetch(:output_format, 'text') # 'text', 'json', 'markdown'
+
         begin
           validate_pdf_file!(file_path)
           result = process_pdf(file_path, pages, extract_text, extract_metadata)
           format_pdf_result(result, output_format)
-        rescue => e
+        rescue StandardError => e
           "PDF processing failed: #{e.message}"
         end
       end
@@ -43,45 +53,33 @@ module RCrewAI
 
       def validate_pdf_file!(file_path)
         path = Pathname.new(file_path)
-        
+
         # Security and existence checks
-        unless path.exist?
-          raise ToolError, "PDF file does not exist: #{file_path}"
-        end
-        
-        unless path.file?
-          raise ToolError, "Path is not a file: #{file_path}"
-        end
-        
-        unless path.readable?
-          raise ToolError, "PDF file is not readable: #{file_path}"
-        end
-        
+        raise ToolError, "PDF file does not exist: #{file_path}" unless path.exist?
+
+        raise ToolError, "Path is not a file: #{file_path}" unless path.file?
+
+        raise ToolError, "PDF file is not readable: #{file_path}" unless path.readable?
+
         # Check file extension
-        unless path.extname.downcase == '.pdf'
-          raise ToolError, "File is not a PDF: #{file_path}"
-        end
-        
+        raise ToolError, "File is not a PDF: #{file_path}" unless path.extname.downcase == '.pdf'
+
         # Check file size
         file_size = path.size
-        if file_size > @max_file_size
-          raise ToolError, "PDF file too large: #{file_size} bytes (max: #{@max_file_size})"
-        end
-        
-        if file_size == 0
-          raise ToolError, "PDF file is empty: #{file_path}"
-        end
-        
+        raise ToolError, "PDF file too large: #{file_size} bytes (max: #{@max_file_size})" if file_size > @max_file_size
+
+        raise ToolError, "PDF file is empty: #{file_path}" if file_size.zero?
+
         # Prevent directory traversal
         resolved_path = path.realpath.to_s
-        unless resolved_path.start_with?(@working_directory)
-          raise ToolError, "Access denied: file outside working directory"
-        end
+        return if resolved_path.start_with?(@working_directory)
+
+        raise ToolError, 'Access denied: file outside working directory'
       end
 
       def process_pdf(file_path, pages_param, extract_text, extract_metadata)
         reader = PDF::Reader.new(file_path)
-        
+
         result = {
           file_path: file_path,
           total_pages: reader.page_count,
@@ -90,32 +88,28 @@ module RCrewAI
           metadata: {},
           processing_errors: []
         }
-        
+
         # Check page count limit
         if reader.page_count > @max_pages
           raise ToolError, "PDF has too many pages: #{reader.page_count} (max: #{@max_pages})"
         end
-        
+
         # Extract metadata if requested
-        if extract_metadata
-          result[:metadata] = extract_pdf_metadata(reader)
-        end
-        
+        result[:metadata] = extract_pdf_metadata(reader) if extract_metadata
+
         # Determine which pages to process
         pages_to_process = determine_pages_to_process(pages_param, reader.page_count)
-        
+
         # Extract text if requested
-        if extract_text
-          result[:text_content] = extract_text_from_pages(reader, pages_to_process, result)
-        end
-        
+        result[:text_content] = extract_text_from_pages(reader, pages_to_process, result) if extract_text
+
         result[:processed_pages] = pages_to_process.length
         result
       end
 
       def extract_pdf_metadata(reader)
         metadata = {}
-        
+
         begin
           info = reader.info
           metadata[:title] = info[:Title] if info[:Title]
@@ -126,24 +120,24 @@ module RCrewAI
           metadata[:producer] = info[:Producer] if info[:Producer]
           metadata[:creation_date] = info[:CreationDate] if info[:CreationDate]
           metadata[:modification_date] = info[:ModDate] if info[:ModDate]
-        rescue => e
+        rescue StandardError => e
           metadata[:extraction_error] = "Failed to extract metadata: #{e.message}"
         end
-        
+
         # Add PDF version and security info
         begin
           metadata[:pdf_version] = reader.pdf_version
           metadata[:encrypted] = reader.encrypted?
-        rescue => e
+        rescue StandardError
           # Ignore errors for version/security info
         end
-        
+
         metadata
       end
 
       def determine_pages_to_process(pages_param, total_pages)
         return (1..total_pages).to_a if pages_param.nil? || pages_param == 'all'
-        
+
         case pages_param
         when Array
           # Array of page numbers: [1, 3, 5]
@@ -164,14 +158,14 @@ module RCrewAI
 
       def parse_page_range_string(range_string, total_pages)
         pages = []
-        
+
         range_string.split(',').each do |part|
           part = part.strip
-          
+
           if part.include?('-')
             # Range like "1-5"
             start_page, end_page = part.split('-').map(&:strip).map(&:to_i)
-            if start_page > 0 && end_page > 0 && start_page <= end_page
+            if start_page.positive? && end_page.positive? && start_page <= end_page
               (start_page..end_page).each do |p|
                 pages << p if p <= total_pages
               end
@@ -179,42 +173,39 @@ module RCrewAI
           else
             # Single page number
             page_num = part.to_i
-            pages << page_num if page_num > 0 && page_num <= total_pages
+            pages << page_num if page_num.positive? && page_num <= total_pages
           end
         end
-        
+
         pages.uniq.sort
       end
 
       def extract_text_from_pages(reader, pages_to_process, result)
         text_content = []
-        
+
         pages_to_process.each do |page_num|
-          begin
-            page = reader.page(page_num)
-            page_text = page.text.strip
-            
-            text_content << {
-              page_number: page_num,
-              text: page_text,
-              character_count: page_text.length,
-              word_count: page_text.split(/\s+/).length
-            }
-            
-          rescue => e
-            error_msg = "Failed to extract text from page #{page_num}: #{e.message}"
-            result[:processing_errors] << error_msg
-            
-            text_content << {
-              page_number: page_num,
-              text: "",
-              character_count: 0,
-              word_count: 0,
-              error: error_msg
-            }
-          end
+          page = reader.page(page_num)
+          page_text = page.text.strip
+
+          text_content << {
+            page_number: page_num,
+            text: page_text,
+            character_count: page_text.length,
+            word_count: page_text.split(/\s+/).length
+          }
+        rescue StandardError => e
+          error_msg = "Failed to extract text from page #{page_num}: #{e.message}"
+          result[:processing_errors] << error_msg
+
+          text_content << {
+            page_number: page_num,
+            text: '',
+            character_count: 0,
+            word_count: 0,
+            error: error_msg
+          }
         end
-        
+
         text_content
       end
 
@@ -231,105 +222,99 @@ module RCrewAI
 
       def format_as_text(result)
         output = []
-        output << "PDF Processing Results"
-        output << "=" * 30
+        output << 'PDF Processing Results'
+        output << '=' * 30
         output << "File: #{File.basename(result[:file_path])}"
         output << "Total Pages: #{result[:total_pages]}"
         output << "Processed Pages: #{result[:processed_pages]}"
-        
+
         if result[:metadata].any?
-          output << ""
-          output << "Metadata:"
+          output << ''
+          output << 'Metadata:'
           result[:metadata].each do |key, value|
             output << "  #{key.to_s.capitalize}: #{value}"
           end
         end
-        
+
         if result[:processing_errors].any?
-          output << ""
-          output << "Processing Errors:"
+          output << ''
+          output << 'Processing Errors:'
           result[:processing_errors].each do |error|
             output << "  - #{error}"
           end
         end
-        
+
         if result[:text_content].any?
-          output << ""
-          output << "Extracted Text:"
-          output << "-" * 20
-          
+          output << ''
+          output << 'Extracted Text:'
+          output << '-' * 20
+
           result[:text_content].each do |page_content|
+            output << ''
             if page_content[:error]
-              output << ""
               output << "Page #{page_content[:page_number]} (ERROR): #{page_content[:error]}"
             elsif page_content[:text].empty?
-              output << ""
               output << "Page #{page_content[:page_number]}: [No text content]"
             else
-              output << ""
               output << "Page #{page_content[:page_number]} (#{page_content[:word_count]} words):"
-              
+
               # Truncate very long pages for readability
               text = page_content[:text]
-              if text.length > 2000
-                text = text[0..1997] + "..."
-              end
-              
+              text = "#{text[0..1997]}..." if text.length > 2000
+
               output << text
             end
           end
         end
-        
+
         output.join("\n")
       end
 
       def format_as_markdown(result)
         output = []
-        output << "# PDF Processing Results"
-        output << ""
+        output << '# PDF Processing Results'
+        output << ''
         output << "**File:** `#{File.basename(result[:file_path])}`"
         output << "**Total Pages:** #{result[:total_pages]}"
         output << "**Processed Pages:** #{result[:processed_pages]}"
-        
+
         if result[:metadata].any?
-          output << ""
-          output << "## Metadata"
+          output << ''
+          output << '## Metadata'
           result[:metadata].each do |key, value|
             output << "- **#{key.to_s.capitalize}:** #{value}"
           end
         end
-        
+
         if result[:text_content].any?
-          output << ""
-          output << "## Extracted Text"
-          
+          output << ''
+          output << '## Extracted Text'
+
           result[:text_content].each do |page_content|
-            output << ""
+            output << ''
             output << "### Page #{page_content[:page_number]}"
-            
+
+            output << ''
             if page_content[:error]
-              output << ""
               output << "> ⚠️ **Error:** #{page_content[:error]}"
             elsif page_content[:text].empty?
-              output << ""
-              output << "> ℹ️ No text content found on this page"
+              output << '> ℹ️ No text content found on this page'
             else
-              output << ""
               output << "**Word Count:** #{page_content[:word_count]}"
-              output << ""
+              output << ''
               output << page_content[:text]
             end
           end
         end
-        
+
         if result[:processing_errors].any?
-          output << ""
-          output << "## Processing Errors"
+          output << ''
+          output << '## Processing Errors'
           result[:processing_errors].each do |error|
             output << "- #{error}"
           end
         end
-        
+
         output.join("\n")
       end
 
@@ -339,4 +324,4 @@ module RCrewAI
       end
     end
   end
-end
+end

data/lib/rcrewai/tools/sql_database.rb

@@ -6,10 +6,15 @@ require 'uri'
 module RCrewAI
   module Tools
     class SqlDatabase < Base
+      tool_name        'sql_database'
+      description      'Execute a read-only SQL query and return rows as JSON'
+      param :query, type: :string,  required: true,
+                    description: 'SQL query (SELECT only; write keywords are rejected)'
+      param :limit, type: :integer, required: false,
+                    description: 'Optional maximum number of rows to return'
+
       def initialize(**options)
         super()
-        @name = 'sqldatabase'
-        @description = 'Execute SQL queries against databases (PostgreSQL, MySQL, SQLite)'
         @connection_string = options[:connection_string]
         @database_type = detect_database_type
         @max_results = options.fetch(:max_results, 100)
@@ -19,15 +24,15 @@ module RCrewAI
 
       def execute(**params)
         validate_params!(params, required: [:query], optional: [:limit])
-        
+
         query = params[:query].strip
         limit = params[:limit] || @max_results
-        
+
         begin
           validate_query_safety!(query)
           result = execute_query(query, limit)
           format_query_result(query, result)
-        rescue => e
+        rescue StandardError => e
           "SQL execution failed: #{e.message}"
         end
       end
@@ -36,7 +41,7 @@ module RCrewAI
 
       def detect_database_type
         return :sqlite unless @connection_string
-        
+
         uri = URI.parse(@connection_string)
         case uri.scheme
         when 'postgres', 'postgresql'
@@ -67,28 +72,26 @@ module RCrewAI
 
       def validate_query_safety!(query)
         query_lower = query.downcase.strip
-        
+
         # Block dangerous operations
         dangerous_keywords = %w[
           drop truncate delete update insert create alter
           grant revoke exec execute call load_file
         ]
-        
+
         dangerous_keywords.each do |keyword|
-          if query_lower.include?(keyword)
-            raise ToolError, "Unsafe SQL operation detected: #{keyword.upcase}"
-          end
+          raise ToolError, "Unsafe SQL operation detected: #{keyword.upcase}" if query_lower.include?(keyword)
         end
-        
+
         # Only allow SELECT statements and safe functions
         unless query_lower.start_with?('select', 'show', 'describe', 'explain')
-          raise ToolError, "Only SELECT, SHOW, DESCRIBE, and EXPLAIN queries are allowed"
+          raise ToolError, 'Only SELECT, SHOW, DESCRIBE, and EXPLAIN queries are allowed'
         end
-        
+
         # Check for suspicious patterns
-        if query_lower.include?('--') || query_lower.include?('/*')
-          raise ToolError, "SQL comments not allowed for security"
-        end
+        return unless query_lower.include?('--') || query_lower.include?('/*')
+
+        raise ToolError, 'SQL comments not allowed for security'
       end
 
       def execute_query(query, limit)
@@ -106,14 +109,14 @@ module RCrewAI
 
       def execute_postgresql_query(query, limit)
         connection = PG.connect(@connection_string)
-        
+
         # Add LIMIT if not present
         limited_query = add_limit_to_query(query, limit)
-        
+
         result = connection.exec(limited_query)
         rows = result.to_a
         columns = result.fields
-        
+
         { rows: rows, columns: columns, row_count: rows.length }
       ensure
         connection&.close
@@ -121,14 +124,14 @@ module RCrewAI
 
       def execute_mysql_query(query, limit)
         connection = Mysql2::Client.new(@connection_string)
-        
+
         # Add LIMIT if not present
         limited_query = add_limit_to_query(query, limit)
-        
+
         result = connection.query(limited_query)
         rows = result.to_a
         columns = result.fields
-        
+
         { rows: rows, columns: columns, row_count: rows.length }
       ensure
         connection&.close
@@ -138,13 +141,13 @@ module RCrewAI
         db_path = @connection_string || ':memory:'
         db = SQLite3::Database.new(db_path)
         db.results_as_hash = true
-        
+
         # Add LIMIT if not present
         limited_query = add_limit_to_query(query, limit)
-        
+
         rows = db.execute(limited_query)
         columns = rows.first&.keys || []
-        
+
         { rows: rows, columns: columns, row_count: rows.length }
       ensure
         db&.close
@@ -152,10 +155,10 @@ module RCrewAI
 
       def add_limit_to_query(query, limit)
         query_lower = query.downcase
-        
+
         # If query already has LIMIT, don't modify
         return query if query_lower.include?('limit')
-        
+
         # Add LIMIT clause
         "#{query.chomp(';')} LIMIT #{limit}"
       end
@@ -164,63 +167,63 @@ module RCrewAI
         output = []
         output << "SQL Query: #{query}"
         output << "Rows returned: #{result[:row_count]}"
-        output << ""
-        
-        if result[:rows].empty?
-          output << "No results found."
-        else
-          # Create simple table format
-          output << format_table(result[:columns], result[:rows])
-        end
-        
+        output << ''
+
+        output << if result[:rows].empty?
+                    'No results found.'
+                  else
+                    # Create simple table format
+                    format_table(result[:columns], result[:rows])
+                  end
+
         output.join("\n")
       end
 
       def format_table(columns, rows)
-        return "No data" if rows.empty?
-        
+        return 'No data' if rows.empty?
+
         # Calculate column widths
         col_widths = {}
         columns.each do |col|
-          col_widths[col] = [col.length, 20].max  # Minimum width of 20
+          col_widths[col] = [col.length, 20].max # Minimum width of 20
         end
-        
-        rows.first(10).each do |row|  # Only check first 10 rows for width
+
+        rows.first(10).each do |row| # Only check first 10 rows for width
           row.each do |key, value|
             value_str = value.to_s
-            col_widths[key] = [col_widths[key], value_str.length].min(50)  # Max width of 50
+            col_widths[key] = [col_widths[key], value_str.length].min(50) # Max width of 50
           end
         end
-        
+
         # Build table
         table = []
-        
+
         # Header
-        header = columns.map { |col| col.ljust(col_widths[col]) }.join(" | ")
+        header = columns.map { |col| col.ljust(col_widths[col]) }.join(' | ')
         table << header
-        table << "-" * header.length
-        
+        table << '-' * header.length
+
         # Rows (limit display to first 20 rows)
         display_rows = rows.first(20)
         display_rows.each do |row|
           row_str = columns.map do |col|
-            value = row[col] || row[col.to_s] || ""
+            value = row[col] || row[col.to_s] || ''
             value_str = value.to_s
             # Truncate long values
-            value_str = value_str[0..47] + "..." if value_str.length > 50
+            value_str = "#{value_str[0..47]}..." if value_str.length > 50
             value_str.ljust(col_widths[col])
-          end.join(" | ")
+          end.join(' | ')
           table << row_str
         end
-        
+
         # Add truncation notice if needed
         if rows.length > 20
-          table << ""
+          table << ''
           table << "(Showing first 20 rows of #{rows.length} total rows)"
         end
-        
+
         table.join("\n")
       end
     end
   end
-end
+end