rcrewai 0.2.0 → 0.3.0

data/lib/rcrewai/tools/base.rb

@@ -1,32 +1,72 @@
 # frozen_string_literal: true
 
+require_relative '../tool_schema'
+
 module RCrewAI
   module Tools
     class Base
-      attr_reader :name, :description
+      extend RCrewAI::ToolSchema
 
       def initialize
-        @name = self.class.name.split('::').last.downcase
-        @description = "Base tool class"
+        # @name and @description are no longer set here.
+        # Instance #name and #description delegate to the class-level DSL
+        # (tool_name / description) via the fallback in the reader methods below.
+      end
+
+      def name
+        @name || self.class.tool_name
+      end
+
+      def description
+        @description || self.class.description
+      end
+
+      def json_schema
+        self.class.json_schema
+      end
+
+      def execute_with_validation(args_hash)
+        coerced = {}
+        schema_params = self.class.params
+
+        if schema_params.empty?
+          coerced = args_hash.transform_keys(&:to_sym)
+          return execute(**coerced)
+        end
+
+        schema_params.each do |p|
+          key_str = p[:name].to_s
+          key_sym = p[:name].to_sym
+          if args_hash.key?(key_str)
+            raw = args_hash[key_str]
+          elsif args_hash.key?(key_sym)
+            raw = args_hash[key_sym]
+          else
+            raise ToolError, "missing required param: #{p[:name]}" if p[:required]
+
+            next
+          end
+          coerced[key_sym] = coerce(raw, p[:type], p[:name])
+        end
+
+        execute(**coerced)
       end
 
       def execute(**params)
-        raise NotImplementedError, "Subclasses must implement #execute method"
+        raise NotImplementedError, 'Subclasses must implement #execute method'
       end
 
       def validate_params!(params, required: [], optional: [])
         # Check required parameters
         missing = required - params.keys
-        unless missing.empty?
-          raise ToolError, "Missing required parameters: #{missing.join(', ')}"
-        end
+        raise ToolError, "Missing required parameters: #{missing.join(', ')}" unless missing.empty?
 
         # Check for unexpected parameters
         allowed = required + optional
         unexpected = params.keys - allowed
-        unless unexpected.empty?
-          raise ToolError, "Unexpected parameters: #{unexpected.join(', ')}"
-        end
+        return if unexpected.empty?
+
+        raise ToolError, "Unexpected parameters: #{unexpected.join(', ')}"
       end
 
       def self.available_tools
@@ -43,40 +83,61 @@ module RCrewAI
 
       def self.create_tool(tool_name, **options)
         tool_class = case tool_name.to_s.downcase
-                    when 'websearch', 'web_search'
-                      WebSearch
-                    when 'filereader', 'file_reader'
-                      FileReader
-                    when 'filewriter', 'file_writer'
-                      FileWriter
-                    when 'sqldatabase', 'sql_database', 'database'
-                      SqlDatabase
-                    when 'emailsender', 'email_sender', 'email'
-                      EmailSender
-                    when 'codeexecutor', 'code_executor', 'code'
-                      CodeExecutor
-                    when 'pdfprocessor', 'pdf_processor', 'pdf'
-                      PdfProcessor
-                    else
-                      raise ToolError, "Unknown tool: #{tool_name}"
-                    end
+                     when 'websearch', 'web_search'
+                       WebSearch
+                     when 'filereader', 'file_reader'
+                       FileReader
+                     when 'filewriter', 'file_writer'
+                       FileWriter
+                     when 'sqldatabase', 'sql_database', 'database'
+                       SqlDatabase
+                     when 'emailsender', 'email_sender', 'email'
+                       EmailSender
+                     when 'codeexecutor', 'code_executor', 'code'
+                       CodeExecutor
+                     when 'pdfprocessor', 'pdf_processor', 'pdf'
+                       PdfProcessor
+                     else
+                       raise ToolError, "Unknown tool: #{tool_name}"
+                     end
 
         tool_class.new(**options)
       end
 
       def self.list_available_tools
-        {
-          'websearch' => 'Search the web using DuckDuckGo',
-          'filereader' => 'Read contents from text files',
-          'filewriter' => 'Write content to text files',
-          'sqldatabase' => 'Execute SQL queries against databases',
-          'emailsender' => 'Send emails via SMTP',
-          'codeexecutor' => 'Execute code in various programming languages',
-          'pdfprocessor' => 'Read and extract text from PDF files'
-        }
+        available_tools.each_with_object({}) do |klass, h|
+          h[klass.tool_name] = klass.description
+        end
+      end
+
+      private
+
+      def coerce(value, type, name)
+        case type
+        when :integer
+          return value if value.is_a?(Integer)
+
+          Integer(value.to_s)
+        when :number
+          return value if value.is_a?(Numeric)
+
+          Float(value.to_s)
+        when :boolean
+          return value if [true, false].include?(value)
+
+          %w[true 1 yes].include?(value.to_s.downcase)
+        when :string, :enum
+          value.to_s
+        when :array, :object
+          value
+        else
+          value
+        end
+      rescue ArgumentError, TypeError
+        raise ToolError, "#{name} must be #{type}, got #{value.inspect}"
       end
     end
 
     class ToolError < RCrewAI::Error; end
   end
-end
+end

data/lib/rcrewai/tools/code_executor.rb

@@ -8,12 +8,21 @@ require 'fileutils'
 module RCrewAI
   module Tools
     class CodeExecutor < Base
+      tool_name        'code_executor'
+      description      'Execute code in a sandboxed subprocess'
+      param :code,     type: :string,  required: true, description: 'Source code to run'
+      param :language, type: :enum,    required: true,
+                       values: %w[ruby python javascript bash],
+                       description: 'Language: ruby, python, javascript, or bash'
+      param :args,     type: :array,   required: false, items: { type: :string },
+                       description: 'Optional command-line arguments to pass to the interpreter'
+      param :stdin,    type: :string,  required: false,
+                       description: 'Optional stdin payload'
+
       def initialize(**options)
         super()
-        @name = 'codeexecutor'
-        @description = 'Execute code in various programming languages (Python, Ruby, JavaScript, etc.)'
         @timeout = options.fetch(:timeout, 30)
-        @max_output_size = options.fetch(:max_output_size, 100_000)  # 100KB
+        @max_output_size = options.fetch(:max_output_size, 100_000) # 100KB
         @allowed_languages = options.fetch(:allowed_languages, %w[python ruby javascript bash])
         @working_directory = options[:working_directory] || Dir.mktmpdir('rcrewai_code_')
         @enable_file_operations = options.fetch(:enable_file_operations, false)
@@ -21,18 +30,18 @@ module RCrewAI
       end
 
       def execute(**params)
-        validate_params!(params, required: [:code, :language], optional: [:args, :stdin])
-        
+        validate_params!(params, required: %i[code language], optional: %i[args stdin])
+
         language = params[:language].to_s.downcase
         code = params[:code]
         args = params[:args] || []
         stdin_input = params[:stdin]
-        
+
         begin
           validate_execution_params!(language, code)
           result = execute_code(language, code, args, stdin_input)
           format_execution_result(language, code, result)
-        rescue => e
+        rescue StandardError => e
           "Code execution failed: #{e.message}"
         end
       end
@@ -43,7 +52,7 @@ module RCrewAI
         # Create secure working directory
         FileUtils.mkdir_p(@working_directory)
         File.chmod(0o755, @working_directory)
-        
+
         # Set environment variables for security
         @secure_env = {
           'PATH' => '/usr/local/bin:/usr/bin:/bin',
@@ -58,63 +67,57 @@ module RCrewAI
         unless @allowed_languages.include?(language)
           raise ToolError, "Language not allowed: #{language}. Allowed: #{@allowed_languages.join(', ')}"
         end
-        
-        if code.to_s.strip.empty?
-          raise ToolError, "Code cannot be empty"
-        end
-        
-        if code.length > 50_000  # 50KB max
-          raise ToolError, "Code too long: #{code.length} characters (max: 50,000)"
-        end
-        
+
+        raise ToolError, 'Code cannot be empty' if code.to_s.strip.empty?
+
+        raise ToolError, "Code too long: #{code.length} characters (max: 50,000)" if code.length > 50_000 # 50KB max
+
         validate_code_safety!(language, code)
       end
 
       def validate_code_safety!(language, code)
         code_lower = code.downcase
-        
+
         # Common dangerous patterns across languages
         dangerous_patterns = [
           # System operations
           'system(', 'exec(', 'eval(', 'subprocess', 'os.system',
           'shell_exec', 'passthru', '`', 'require "open3"',
-          
+
           # File operations (if not explicitly enabled)
           'file.open', 'open(', 'with open', 'fopen', 'file_get_contents',
           'file_put_contents', 'unlink', 'delete', 'remove',
-          
+
           # Network operations
           'socket', 'http', 'urllib', 'requests', 'net::',
           'tcpsocket', 'udpsocket', 'curl', 'wget',
-          
+
           # Process operations
           'fork', 'spawn', 'thread', 'process',
-          
+
           # Dangerous Python imports
           'import os', 'import sys', 'import subprocess', 'import socket',
           'from os', 'from sys', 'from subprocess',
-          
+
           # Dangerous Ruby requires
           'require "fileutils"', 'require "open3"', 'require "net/',
-          
+
           # Shell commands
           'rm -', 'sudo', 'chmod', 'chown', 'dd if=', 'mkfs',
           'iptables', 'systemctl', 'service '
         ]
-        
+
         unless @enable_file_operations
           dangerous_patterns += [
             'file.', 'open(', 'with open', 'fopen', 'file_get_contents',
             'file_put_contents', 'fileutils', 'fs.', 'path.', 'dir.'
           ]
         end
-        
+
         dangerous_patterns.each do |pattern|
-          if code_lower.include?(pattern)
-            raise ToolError, "Potentially dangerous code detected: #{pattern}"
-          end
+          raise ToolError, "Potentially dangerous code detected: #{pattern}" if code_lower.include?(pattern)
         end
-        
+
         # Language-specific checks
         case language
         when 'python'
@@ -135,11 +138,9 @@ module RCrewAI
           'compile(', 'exec(', 'eval(',
           'input(', 'raw_input('
         ]
-        
+
         python_dangerous.each do |pattern|
-          if code.include?(pattern)
-            raise ToolError, "Dangerous Python construct: #{pattern}"
-          end
+          raise ToolError, "Dangerous Python construct: #{pattern}" if code.include?(pattern)
         end
       end
 
@@ -150,11 +151,9 @@ module RCrewAI
           'const_get', 'const_set', 'remove_const',
           'gets', 'readline', 'readlines'
         ]
-        
+
         ruby_dangerous.each do |pattern|
-          if code.include?(pattern)
-            raise ToolError, "Dangerous Ruby construct: #{pattern}"
-          end
+          raise ToolError, "Dangerous Ruby construct: #{pattern}" if code.include?(pattern)
         end
       end
 
@@ -165,11 +164,9 @@ module RCrewAI
           'document.', 'window.', 'location.',
           'settimeout', 'setinterval'
         ]
-        
+
         js_dangerous.each do |pattern|
-          if code.include?(pattern)
-            raise ToolError, "Dangerous JavaScript construct: #{pattern}"
-          end
+          raise ToolError, "Dangerous JavaScript construct: #{pattern}" if code.include?(pattern)
         end
       end
 
@@ -180,11 +177,9 @@ module RCrewAI
           '$(', '`', 'eval ', 'exec ',
           '/etc/', '/proc/', '/sys/', '/dev/'
         ]
-        
+
         bash_dangerous.each do |pattern|
-          if code.include?(pattern)
-            raise ToolError, "Dangerous bash construct: #{pattern}"
-          end
+          raise ToolError, "Dangerous bash construct: #{pattern}" if code.include?(pattern)
         end
       end
 
@@ -240,15 +235,15 @@ module RCrewAI
           temp_file.close
           yield temp_file.path
         ensure
-          temp_file.unlink if temp_file
+          temp_file&.unlink
         end
       end
 
       def execute_command(command, stdin_input)
-        stdout_str = ""
-        stderr_str = ""
+        stdout_str = ''
+        stderr_str = ''
         exit_status = nil
-        
+
         # Execute with timeout and security restrictions
         Open3.popen3(@secure_env, *command, chdir: @working_directory) do |stdin, stdout, stderr, wait_thread|
           # Write stdin if provided
@@ -256,41 +251,45 @@ module RCrewAI
             stdin.write(stdin_input)
             stdin.close
           end
-          
+
           # Set up timeout
           timeout_thread = Thread.new do
             sleep @timeout
-            Process.kill('KILL', wait_thread.pid) rescue nil
+            begin
+              Process.kill('KILL', wait_thread.pid)
+            rescue StandardError
+              nil
+            end
           end
-          
+
           begin
             # Read output
             stdout_str = read_with_limit(stdout, @max_output_size)
             stderr_str = read_with_limit(stderr, @max_output_size)
-            
+
             exit_status = wait_thread.value.exitstatus
-          rescue => e
+          rescue StandardError => e
             exit_status = -1
             stderr_str += "\nExecution error: #{e.message}"
           ensure
             timeout_thread.kill
           end
         end
-        
+
         {
           stdout: stdout_str,
           stderr: stderr_str,
           exit_status: exit_status,
-          success: exit_status == 0
+          success: exit_status.zero?
         }
       end
 
       def read_with_limit(io, limit)
-        output = ""
+        output = ''
         while output.bytesize < limit && !io.eof?
           chunk = io.read(1024)
           break unless chunk
-          
+
           if output.bytesize + chunk.bytesize > limit
             remaining = limit - output.bytesize
             output += chunk[0, remaining]
@@ -303,31 +302,29 @@ module RCrewAI
         output
       end
 
-      def format_execution_result(language, code, result)
+      def format_execution_result(language, _code, result)
         output = []
         output << "Code Execution Result (#{language.upcase})"
-        output << "=" * 40
+        output << '=' * 40
         output << "Exit Status: #{result[:exit_status]} (#{result[:success] ? 'SUCCESS' : 'FAILURE'})"
-        output << ""
-        
+        output << ''
+
         if result[:stdout] && !result[:stdout].empty?
-          output << "STDOUT:"
+          output << 'STDOUT:'
           output << result[:stdout]
-          output << ""
+          output << ''
         end
-        
+
         if result[:stderr] && !result[:stderr].empty?
-          output << "STDERR:"
+          output << 'STDERR:'
           output << result[:stderr]
-          output << ""
-        end
-        
-        if result[:stdout].empty? && result[:stderr].empty?
-          output << "No output produced."
+          output << ''
         end
-        
+
+        output << 'No output produced.' if result[:stdout].empty? && result[:stderr].empty?
+
         output.join("\n")
       end
     end
   end
-end
+end