shared_tools 0.2.3 → 0.3.0

data/lib/shared_tools/tools/eval/python_eval_tool.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+
+module SharedTools
+  module Tools
+    module Eval
+      # @example
+      #   tool = SharedTools::Tools::Eval::PythonEvalTool.new
+      #   tool.execute(code: "print('Hello'); result = 2 + 2")
+      class PythonEvalTool < ::RubyLLM::Tool
+        def self.name = 'eval_python'
+
+        description <<~DESCRIPTION
+                      Execute Python source code safely and return the result.
+
+                      This tool evaluates Python code by writing it to a temporary file
+                      and executing it with the python3 command, capturing both stdout
+                      and the final expression result.
+
+                      WARNING: This tool executes arbitrary Python code. Use with caution.
+                      NOTE: Requires python3 to be available in the system PATH.
+                    DESCRIPTION
+
+        params do
+          string :code, description: "The Python code to execute"
+        end
+
+        # @param logger [Logger] optional logger
+        def initialize(logger: nil)
+          @logger = logger || RubyLLM.logger
+        end
+
+        # @param code [String] Python code to execute
+        #
+        # @return [Hash] execution result
+        def execute(code:)
+          @logger.info("Requesting permission to execute Python code")
+
+          if code.strip.empty?
+            error_msg = "Python code cannot be empty"
+            @logger.error(error_msg)
+            return { error: error_msg }
+          end
+
+          # Show user the code and ask for confirmation
+          allowed = SharedTools.execute?(tool: self.class.to_s, stuff: code)
+
+          unless allowed
+            @logger.warn("User declined to execute the Python code")
+            return { error: "User declined to execute the Python code" }
+          end
+
+          @logger.info("Executing Python code")
+
+          begin
+            require 'tempfile'
+            require 'open3'
+            require 'json'
+
+            # Create a Python script that captures both output and result
+            python_script = create_python_wrapper(code)
+
+            # Write to temporary file
+            temp_file = Tempfile.new(['python_eval', '.py'])
+            temp_file.write(python_script)
+            temp_file.flush
+
+            # Execute the Python script
+            stdout, stderr, status = Open3.capture3("python3", temp_file.path)
+
+            temp_file.close
+            temp_file.unlink
+
+            if status.success?
+              @logger.debug("Python code execution completed successfully")
+              parse_python_output(stdout)
+            else
+              @logger.error("Python code execution failed: #{stderr}")
+              {
+                error: stderr.strip,
+                success: false
+              }
+            end
+          rescue => e
+            @logger.error("Failed to execute Python code: #{e.message}")
+            {
+              error: e.message,
+              backtrace: e.backtrace&.first(5),
+              success: false
+            }
+          end
+        end
+
+        private
+
+        def create_python_wrapper(user_code)
+          require 'base64'
+          encoded_code = Base64.strict_encode64(user_code)
+
+          <<~PYTHON
+            import sys
+            import json
+            import io
+            import base64
+            from contextlib import redirect_stdout
+
+            # Decode the user code
+            user_code = base64.b64decode('#{encoded_code}').decode('utf-8')
+
+            # Capture stdout
+            captured_output = io.StringIO()
+
+            try:
+                with redirect_stdout(captured_output):
+                    # Handle compound statements (semicolon-separated)
+                    if ';' in user_code and not user_code.strip().startswith('for ') and not user_code.strip().startswith('if '):
+                        # Split by semicolon, execute all but last, eval the last
+                        parts = [part.strip() for part in user_code.split(';') if part.strip()]
+                        if len(parts) > 1:
+                            for part in parts[:-1]:
+                                exec(part)
+                            # Try to eval the last part
+                            try:
+                                result = eval(parts[-1])
+                            except SyntaxError:
+                                exec(parts[-1])
+                                result = None
+                        else:
+                            # Single part, try eval then exec
+                            try:
+                                result = eval(parts[0])
+                            except SyntaxError:
+                                exec(parts[0])
+                                result = None
+                    else:
+                        # Try to evaluate as expression first
+                        try:
+                            result = eval(user_code)
+                        except SyntaxError:
+                            # If not an expression, execute as statement
+                            exec(user_code)
+                            result = None
+
+                output = captured_output.getvalue()
+
+                # Prepare result for JSON serialization
+                try:
+                    json.dumps(result)  # Test if result is JSON serializable
+                    serializable_result = result
+                except (TypeError, ValueError):
+                    serializable_result = str(result)
+
+                result_data = {
+                    "success": True,
+                    "result": serializable_result,
+                    "output": output if output else None,
+                    "python_type": type(result).__name__
+                }
+
+                print("PYTHON_EVAL_RESULT:", json.dumps(result_data))
+
+            except Exception as e:
+                error_data = {
+                    "success": False,
+                    "error": str(e),
+                    "error_type": type(e).__name__
+                }
+                print("PYTHON_EVAL_RESULT:", json.dumps(error_data))
+          PYTHON
+        end
+
+        def parse_python_output(stdout)
+          lines = stdout.split("\n")
+          result_line = lines.find { |line| line.start_with?("PYTHON_EVAL_RESULT:") }
+
+          if result_line
+            json_data = result_line.sub("PYTHON_EVAL_RESULT:", "").strip
+            result = JSON.parse(json_data)
+
+            # Add display formatting
+            if result["success"]
+              if result["output"].nil? || result["output"].empty?
+                result["display"] = result["result"].inspect
+              else
+                result_part = result["result"].nil? ? "" : "\n=> #{result["result"].inspect}"
+                result["display"] = result["output"] + result_part
+              end
+            end
+
+            # Convert string keys to symbols
+            result.transform_keys(&:to_sym)
+          else
+            {
+              error: "Failed to parse Python execution result",
+              raw_output: stdout,
+              success: false
+            }
+          end
+        rescue JSON::ParserError => e
+          {
+            error: "Failed to parse Python result as JSON: #{e.message}",
+            raw_output: stdout,
+            success: false
+          }
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/eval/ruby_eval_tool.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module SharedTools
+  module Tools
+    module Eval
+      # @example
+      #   tool = SharedTools::Tools::Eval::RubyEvalTool.new
+      #   tool.execute(code: "puts 'Hello'; 2 + 2")
+      class RubyEvalTool < ::RubyLLM::Tool
+        def self.name = 'eval_ruby'
+
+        description <<~DESCRIPTION
+                      Execute Ruby source code safely and return the result.
+
+                      This tool evaluates Ruby code in a sandboxed context and returns
+                      the result of the last expression or any output produced.
+
+                      WARNING: This tool executes arbitrary Ruby code. Use with caution.
+                    DESCRIPTION
+
+        params do
+          string :code, description: "The Ruby code to execute"
+        end
+
+        # @param logger [Logger] optional logger
+        def initialize(logger: nil)
+          @logger = logger || RubyLLM.logger
+        end
+
+        # @param code [String] Ruby code to execute
+        #
+        # @return [Hash] execution result
+        def execute(code:)
+          @logger.info("Requesting permission to execute Ruby code")
+
+          if code.strip.empty?
+            error_msg = "Ruby code cannot be empty"
+            @logger.error(error_msg)
+            return { error: error_msg }
+          end
+
+          # Show user the code and ask for confirmation
+          allowed = SharedTools.execute?(tool: self.class.to_s, stuff: code)
+
+          unless allowed
+            @logger.warn("User declined to execute the Ruby code")
+            return { error: "User declined to execute the Ruby code" }
+          end
+
+          @logger.info("Executing Ruby code")
+
+          # Capture both stdout and the result of evaluation
+          original_stdout = $stdout
+          captured_output = StringIO.new
+          $stdout = captured_output
+
+          begin
+            result = eval(code)
+            output = captured_output.string
+
+            @logger.debug("Ruby code execution completed successfully")
+
+            response = {
+              result: result,
+              output: output.empty? ? nil : output,
+              success: true
+            }
+
+            # Include both result and output in a readable format
+            if output.empty?
+              response[:display] = result.inspect
+            else
+              response[:display] = output + (result.nil? ? "" : "\n=> #{result.inspect}")
+            end
+
+            response
+          rescue SyntaxError, StandardError => e
+            @logger.error("Ruby code execution failed: #{e.message}")
+            {
+              error: e.message,
+              backtrace: e.backtrace&.first(5),
+              success: false
+            }
+          ensure
+            $stdout = original_stdout
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/eval/shell_eval_tool.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+
+module SharedTools
+  module Tools
+    module Eval
+      # @example
+      #   tool = SharedTools::Tools::Eval::ShellEvalTool.new
+      #   tool.execute(command: "ls -la")
+      class ShellEvalTool < ::RubyLLM::Tool
+        def self.name = 'eval_shell'
+
+        description "Execute a shell command safely and return the result."
+
+        params do
+          string :command, description: "The shell command to execute"
+        end
+
+        # @param logger [Logger] optional logger
+        def initialize(logger: nil)
+          @logger = logger || RubyLLM.logger
+        end
+
+        # @param command [String] shell command to execute
+        #
+        # @return [Hash] execution result
+        def execute(command:)
+          @logger.info("Requesting permission to execute command: '#{command}'")
+
+          if command.strip.empty?
+            error_msg = "Command cannot be empty"
+            @logger.error(error_msg)
+            return { error: error_msg }
+          end
+
+          # Show user the command and ask for confirmation
+          allowed = SharedTools.execute?(tool: self.class.to_s, stuff: command)
+
+          unless allowed
+            @logger.warn("User declined to execute the command: '#{command}'")
+            return { error: "User declined to execute the command" }
+          end
+
+          @logger.info("Executing command: '#{command}'")
+
+          # Use Open3 for safer command execution with proper error handling
+          require "open3"
+          stdout, stderr, status = Open3.capture3(command)
+
+          if status.success?
+            @logger.debug("Command execution completed successfully with #{stdout.bytesize} bytes of output")
+            { stdout: stdout, exit_status: status.exitstatus }
+          else
+            @logger.warn("Command execution failed with exit code #{status.exitstatus}: #{stderr}")
+            { error: "Command failed with exit code #{status.exitstatus}", stderr: stderr, exit_status: status.exitstatus }
+          end
+        rescue => e
+          @logger.error("Command execution failed: #{e.message}")
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/eval.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Collection loader for all eval tools
+# Usage: require 'shared_tools/tools/eval'
+
+require 'shared_tools'
+
+require_relative 'eval/python_eval_tool'
+require_relative 'eval/ruby_eval_tool'
+require_relative 'eval/shell_eval_tool'

data/lib/shared_tools/tools/eval_tool.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  module Tools
+    # A tool for evaluating code in different programming languages
+    class EvalTool < ::RubyLLM::Tool
+      def self.name = 'eval_tool'
+
+      module Action
+        RUBY = "ruby"
+        PYTHON = "python"
+        SHELL = "shell"
+      end
+
+      ACTIONS = [
+        Action::RUBY,
+        Action::PYTHON,
+        Action::SHELL,
+      ].freeze
+
+      description <<~TEXT
+        Execute code in various programming languages (Ruby, Python, Shell).
+
+        **WARNING**: This tool executes arbitrary code. All code execution requires user authorization for security.
+
+        ## Actions:
+
+        1. `#{Action::RUBY}` - Execute Ruby code
+          Required: "action": "ruby", "code": "[Ruby code to execute]"
+
+        2. `#{Action::PYTHON}` - Execute Python code
+          Required: "action": "python", "code": "[Python code to execute]"
+          Note: Requires python3 in system PATH
+
+        3. `#{Action::SHELL}` - Execute shell commands
+          Required: "action": "shell", "command": "[Shell command to execute]"
+
+        ## Examples:
+
+        Execute Ruby code
+          {"action": "#{Action::RUBY}", "code": "puts 'Hello from Ruby'; 2 + 2"}
+
+        Execute Python code
+          {"action": "#{Action::PYTHON}", "code": "print('Hello from Python')\\nresult = 5 * 5\\nprint(result)"}
+
+        Execute shell command
+          {"action": "#{Action::SHELL}", "command": "ls -la"}
+
+        Calculate with Ruby
+          {"action": "#{Action::RUBY}", "code": "[1, 2, 3, 4, 5].sum"}
+
+        Data processing with Python
+          {"action": "#{Action::PYTHON}", "code": "import json\\ndata = {'name': 'test', 'value': 42}\\nprint(json.dumps(data))"}
+
+        System info with shell
+          {"action": "#{Action::SHELL}", "command": "uname -a"}
+      TEXT
+
+      params do
+        string :action, description: <<~TEXT.strip
+          The evaluation action to perform. Options:
+          * `#{Action::RUBY}`: Execute Ruby code
+          * `#{Action::PYTHON}`: Execute Python code (requires python3)
+          * `#{Action::SHELL}`: Execute shell commands
+        TEXT
+
+        string :code, description: <<~TEXT.strip, required: false
+          The code to execute. Required for the following actions:
+          * `#{Action::RUBY}`
+          * `#{Action::PYTHON}`
+        TEXT
+
+        string :command, description: <<~TEXT.strip, required: false
+          The shell command to execute. Required for the following actions:
+          * `#{Action::SHELL}`
+        TEXT
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param action [String] the action to perform
+      # @param code [String, nil] code to execute (for ruby/python)
+      # @param command [String, nil] shell command to execute
+      #
+      # @return [Hash, String] execution result
+      def execute(action:, code: nil, command: nil)
+        @logger.info("EvalTool#execute action=#{action}")
+
+        case action.to_s.downcase
+        when Action::RUBY
+          require_param!(:code, code)
+          ruby_eval_tool.execute(code: code)
+        when Action::PYTHON
+          require_param!(:code, code)
+          python_eval_tool.execute(code: code)
+        when Action::SHELL
+          require_param!(:command, command)
+          shell_eval_tool.execute(command: command)
+        else
+          { error: "Unsupported action: #{action}. Supported actions are: #{ACTIONS.join(', ')}" }
+        end
+      rescue StandardError => e
+        @logger.error("EvalTool execution failed: #{e.message}")
+        { error: e.message }
+      end
+
+    private
+
+      # @param name [Symbol]
+      # @param value [Object]
+      #
+      # @raise [ArgumentError]
+      # @return [void]
+      def require_param!(name, value)
+        raise ArgumentError, "#{name} param is required for this action" if value.nil?
+      end
+
+      # @return [Eval::RubyEvalTool]
+      def ruby_eval_tool
+        @ruby_eval_tool ||= Eval::RubyEvalTool.new(logger: @logger)
+      end
+
+      # @return [Eval::PythonEvalTool]
+      def python_eval_tool
+        @python_eval_tool ||= Eval::PythonEvalTool.new(logger: @logger)
+      end
+
+      # @return [Eval::ShellEvalTool]
+      def shell_eval_tool
+        @shell_eval_tool ||= Eval::ShellEvalTool.new(logger: @logger)
+      end
+    end
+  end
+end