shared_tools 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ae3eef4f29e12a8be7ff8db5eec7e156bcfa1e767d5375b2ffde66db35629ef
-  data.tar.gz: 6f73bca50589be410d134eb2c02be5451bed2f875dea5854984181ff9f37fc44
+  metadata.gz: b6c52f4b0cd9b70b60f1e0a9ed50c752d440f17c4d3a638932976cb4796a64e6
+  data.tar.gz: 8c15bd8b3c71f42265f4ef4b7dbc98fae5297dde626d510f43a02cd952e2a069
 SHA512:
-  metadata.gz: 42a193b5df012a25909c94a28d60e1d66347683d32bc29979a578e4fbf705738c02053625c45828c7029fe2473fa8cf40ca2e83a67ed29599ac10ab4436f2d4c
-  data.tar.gz: 57bb4e3b32137687b81257adf786d684fc1bb521a8d661fb23ea057047c64ae78e1f2af0f2273199093d1194d8553276bbba3302f76d3942677b7c24a78dfcd7
+  metadata.gz: aad7b1f18772c7b4407f86fd811141ee5c9c0cc4cddf1a5ca312a27c2f7096cb4502a6295d8c16ec0e5bfa740949faeb7f2d1106cf828f9445b5c80f31e4d2c1
+  data.tar.gz: 394c9b6b1d3f22320b3c151d8477912c34fa4e86c9e3a46a023983581d0325886a2abb6a5df536ba11c165a6d4e9454097528794122cd842cabb9a03111d75be

data/CHANGELOG.md

@@ -1,9 +1,15 @@
 # Changelog
 
-## [0.1.0] - 2025-06-05
+## Unreleased
+### [0.1.3] 2025-06-18
+- tweaking the load all tools process
 
-### Added
+## Released
 
+### [0.1.2] 2025-06-10
+- added `zeitwerk` gem
+
+### [0.1.0] - 2025-06-05
 - Initial gem release
 - SharedTools core module with automatic logger integration
 - RubyLlm tools: EditFile, ListFiles, PdfPageReader, ReadFile, RunShellCommand

data/README.md

@@ -1,9 +1,14 @@
-# shared_tools
-A Ruby gem providing a collection of shared tools and utilities for Ruby applications, including configurable logging and AI-related tools.
+<div align="center">
+  <h1>Shared Tools</h1>
+  <img src="images/shared_tools.png" alt="Two Robots sharing the same set of tools.">
+</div>
 
-## Libraries Supported
+A Ruby gem providing a collection of common tools (call-back functions) for use with the following gems:
 
-- ruby_llm: multi-provider
+- ruby_llm: multi-provider `gem install ruby_llm`
+- llm: multi-provider `gem install llm.rb`
+- omniai: multi-provider `gem install omniai-tools` (Not part of the SharedTools namespace)
+- more to come ...
 
 ## Installation
 
@@ -27,86 +32,34 @@ gem install shared_tools
 
 ## Usage
 
-```ruby
-# To load all tools for a specific library
-require 'shared_tools/ruby_llm'
-
-# OR you can load a specific tool
-require 'shared_tools/ruby_llm/edit_file'
-```
-
-## Shared Logging
-
-All classes within the SharedTools namespace automatically have access to a configurable logger without requiring any explicit includes or setup.
-
-### Basic Usage
-
-Within any class in the SharedTools namespace, you can directly use the logger:
+### Basic Loading
 
 ```ruby
-module SharedTools
-  class MyTool
-    def perform_action
-      logger.info "Starting action"
-      # Do something
-      logger.debug "Details about action"
-      # Handle errors
-    rescue => e
-      logger.error "Action failed: #{e.message}"
-      raise
-    ensure
-      logger.info "Action completed"
-    end
-  end
- end
+require 'shared_tools'
 ```
 
-### Configuration
+### Loading RubyLLM Tools
 
-The logger can be configured using the `configure_logger` method:
+RubyLLM tools are loaded conditionally when needed:
 
 ```ruby
-# Configure the logger in your application initialization
-SharedTools.configure_logger do |config|
-  config.level = Logger::DEBUG                   # Set log level
-  config.log_device = "logs/shared_tools.log"    # Set output file
-  config.formatter = proc do |severity, time, progname, msg|
-    "[#{time.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
-  end
- end
-```
-
-### Using with Rails
+require 'shared_tools'
 
-To use the SharedTools logger with Rails and make it use the same logger instance:
+# Load all RubyLLM tools (requires ruby_llm gem to be available and loaded first)
+require 'shared_tools/ruby_llm'
 
-```ruby
-# In config/initializers/shared_tools.rb
-Rails.application.config.after_initialize do
-  # Make SharedTools use the Rails logger
-  SharedTools.logger = Rails.logger
-
-  # Alternatively, configure the Rails logger to use SharedTools settings
-  # SharedTools.configure_logger do |config|
-  #   config.level = Rails.logger.level
-  #   config.log_device = Rails.logger.instance_variable_get(:@logdev).dev
-  # end
-  # Rails.logger = SharedTools.logger
-
-  Rails.logger.info "SharedTools integrated with Rails logger"
-end
+# Or load a specific tool directly
+require 'shared_tools/ruby_llm/edit_file'
+require 'shared_tools/ruby_llm/read_file'
+require 'shared_tools/ruby_llm/python_eval'
+# etc.
 ```
 
-### Available Log Levels
+### Rails and Autoloader Compatibility
 
-The logger supports the standard Ruby Logger levels:
+This gem uses Zeitwerk for autoloading, making it fully compatible with Rails and other Ruby applications that use modern autoloaders. RubyLLM tools are excluded from autoloading and loaded manually to avoid namespace conflicts.
 
-- `logger.debug` - Detailed debug information
-- `logger.info` - General information messages
-- `logger.warn` - Warning messages
-- `logger.error` - Error messages
-- `logger.fatal` - Fatal error messages
 
-### Thread Safety
+### Special Thanks
 
-The shared logger is thread-safe and can be used across multiple threads in your application.
+A special shout-out to Kevin's [omniai-tools](https://github.com/your-github-url/omniai-tools) gem, which is a curated collection of tools for use with his OmniAI gem.

data/lib/shared_tools/llm_rb/run_shell_command.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  verify_gem :llm_rb
+
+  RunShellCommand = LLM.function(:system) do |fn|
+    fn.description "Run a shell command"
+
+    fn.params do |schema|
+      schema.object(command: schema.string.required)
+    end
+
+    fn.define do |params|
+      ro, wo = IO.pipe
+      re, we = IO.pipe
+      Process.wait Process.spawn(params.command, out: wo, err: we)
+      [wo, we].each(&:close)
+      { stderr: re.read, stdout: ro.read }
+    end
+  end
+end

data/lib/shared_tools/llm_rb.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../shared_tools'
+
+SharedTools.verify_gem :llm_rb
+
+Dir.glob(File.join(__dir__, "llm_rb", "*.rb")).each do |file|
+  require file
+end

data/lib/shared_tools/omniai.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../shared_tools'
+
+SharedTools.verify_gem :omniai
+
+Dir.glob(File.join(__dir__, "omniai", "*.rb")).each do |file|
+  require file
+end

data/lib/shared_tools/raix/what_is_the_weather.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+
+module SharedTools
+  verify_gem :ruby_llm
+
+  class WhatIsTheWeather
+    include Raix::ChatCompletion
+    include Raix::FunctionDispatch
+
+    function :check_weather,
+             "Check the weather for a location",
+             location: { type: "string", required: true } do |arguments|
+      "The weather in #{arguments[:location]} is hot and sunny"
+    end
+  end
+end

data/lib/shared_tools/raix.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../shared_tools'
+
+SharedTools.verify_gem :raix
+
+Dir.glob(File.join(__dir__, "raix", "*.rb")).each do |file|
+  require file
+end

data/lib/shared_tools/ruby_llm/edit_file.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../../shared_tools'
 
 module SharedTools
-  class EditFile < RubyLLM::Tool
+  verify_gem :ruby_llm
+
+  class EditFile < ::RubyLLM::Tool
 
     description <<~DESCRIPTION
                   Make edits to a text file.
@@ -22,47 +23,47 @@ module SharedTools
     param :replace_all, desc: "Whether to replace all occurrences (true) or just the first one (false)", required: false
 
     def execute(path:, old_str:, new_str:, replace_all: false)
-      logger.info("Editing file: #{path}")
+      RubyLLM.logger.info("Editing file: #{path}")
 
       # Normalize path to absolute path
       absolute_path = File.absolute_path(path)
 
       if File.exist?(absolute_path)
-        logger.debug("File exists, reading content")
+        RubyLLM.logger.debug("File exists, reading content")
         content = File.read(absolute_path)
       else
-        logger.debug("File doesn't exist, creating new file")
+        RubyLLM.logger.debug("File doesn't exist, creating new file")
         content = ""
       end
 
       matches = content.scan(old_str).size
-      logger.debug("Found #{matches} matches for the string to replace")
+      RubyLLM.logger.debug("Found #{matches} matches for the string to replace")
 
       if matches == 0
-        logger.warn("No matches found for the string to replace. File will remain unchanged.")
+        RubyLLM.logger.warn("No matches found for the string to replace. File will remain unchanged.")
         return { success: false, warning: "No matches found for the string to replace" }
       end
 
       if matches > 1 && !replace_all
-        logger.warn("Multiple matches (#{matches}) found for the string to replace. Only the first occurrence will be replaced.")
+        RubyLLM.logger.warn("Multiple matches (#{matches}) found for the string to replace. Only the first occurrence will be replaced.")
       end
 
       if replace_all
         updated_content = content.gsub(old_str, new_str)
         replaced_count = matches
-        logger.info("Replacing all #{matches} occurrences")
+        RubyLLM.logger.info("Replacing all #{matches} occurrences")
       else
         updated_content = content.sub(old_str, new_str)
         replaced_count = 1
-        logger.info("Replacing first occurrence only")
+        RubyLLM.logger.info("Replacing first occurrence only")
       end
 
       File.write(absolute_path, updated_content)
 
-      logger.info("Successfully updated file: #{path}")
+      RubyLLM.logger.info("Successfully updated file: #{path}")
       { success: true, matches: matches, replaced: replaced_count }
     rescue => e
-      logger.error("Failed to edit file '#{path}': #{e.message}")
+      RubyLLM.logger.error("Failed to edit file '#{path}': #{e.message}")
       { error: e.message }
     end
   end

data/lib/shared_tools/ruby_llm/list_files.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../../shared_tools'
 
 module SharedTools
-  class ListFiles < RubyLLM::Tool
+  verify_gem :ruby_llm
+
+  class ListFiles < ::RubyLLM::Tool
 
     description "List files and directories at a given path. If no path is provided, lists files in the current directory."
     param :path, desc: "Optional relative path to list files from. Defaults to current directory if not provided."
 
     def execute(path: Dir.pwd)
-      logger.info("Listing files in path: #{path}")
+      RubyLLM.logger.info("Listing files in path: #{path}")
 
       # Convert to absolute path for consistency
       absolute_path = File.absolute_path(path)
@@ -18,7 +19,7 @@ module SharedTools
       # Verify the path exists and is a directory
       unless File.directory?(absolute_path)
         error_msg = "Path does not exist or is not a directory: #{path}"
-        logger.error(error_msg)
+        RubyLLM.logger.error(error_msg)
         return { error: error_msg }
       end
 
@@ -37,10 +38,10 @@ module SharedTools
         end
       end
 
-      logger.debug("Found #{formatted_files.size} files/directories (including #{hidden_files.size} hidden)")
+      RubyLLM.logger.debug("Found #{formatted_files.size} files/directories (including #{hidden_files.size} hidden)")
       formatted_files
     rescue => e
-      logger.error("Failed to list files in '#{path}': #{e.message}")
+      RubyLLM.logger.error("Failed to list files in '#{path}': #{e.message}")
       { error: e.message }
     end
   end

data/lib/shared_tools/ruby_llm/pdf_page_reader.rb

@@ -2,12 +2,12 @@
 # Credit: https://max.engineer/giant-pdf-llm
 
 require "pdf-reader"
-
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../../shared_tools'
 
 module SharedTools
-  class PdfPageReader < RubyLLM::Tool
+  verify_gem :ruby_llm
+
+  class PdfPageReader < ::RubyLLM::Tool
 
     description "Read the text of any set of pages from a PDF document."
     param :page_numbers,
@@ -16,21 +16,21 @@ module SharedTools
       desc: "Path to the PDF document."
 
     def execute(page_numbers:, doc_path:)
-      logger.info("Reading PDF: #{doc_path}, pages: #{page_numbers}")
+      RubyLLM.logger.info("Reading PDF: #{doc_path}, pages: #{page_numbers}")
 
       begin
         @doc ||= PDF::Reader.new(doc_path)
-        logger.debug("PDF loaded successfully, total pages: #{@doc.pages.size}")
+        RubyLLM.logger.debug("PDF loaded successfully, total pages: #{@doc.pages.size}")
 
         page_numbers = page_numbers.split(",").map { |num| num.strip.to_i }
-        logger.debug("Processing pages: #{page_numbers.join(", ")}")
+        RubyLLM.logger.debug("Processing pages: #{page_numbers.join(", ")}")
 
         # Validate page numbers
         total_pages = @doc.pages.size
         invalid_pages = page_numbers.select { |num| num < 1 || num > total_pages }
 
         if invalid_pages.any?
-          logger.warn("Invalid page numbers requested: #{invalid_pages.join(", ")}. Document has #{total_pages} pages.")
+          RubyLLM.logger.warn("Invalid page numbers requested: #{invalid_pages.join(", ")}. Document has #{total_pages} pages.")
         end
 
         # Filter valid pages and map to content
@@ -42,15 +42,15 @@ module SharedTools
           requested_pages: page_numbers,
           invalid_pages: invalid_pages,
           pages: pages.map { |num, p|
-            logger.debug("Extracted text from page #{num} (#{p&.text&.bytesize || 0} bytes)")
+            RubyLLM.logger.debug("Extracted text from page #{num} (#{p&.text&.bytesize || 0} bytes)")
             { page: num, text: p&.text }
           },
         }
 
-        logger.info("Successfully extracted #{pages.size} pages from PDF")
+        RubyLLM.logger.info("Successfully extracted #{pages.size} pages from PDF")
         result
       rescue => e
-        logger.error("Failed to read PDF '#{doc_path}': #{e.message}")
+        RubyLLM.logger.error("Failed to read PDF '#{doc_path}': #{e.message}")
         { error: e.message }
       end
     end

data/lib/shared_tools/ruby_llm/python_eval.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  verify_gem :ruby_llm
+
+  class PythonEval < ::RubyLLM::Tool
+
+    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
+    param :code, desc: "The Python code to execute"
+
+    def execute(code:)
+      RubyLLM.logger.info("Requesting permission to execute Python code")
+
+      if code.strip.empty?
+        error_msg = "Python code cannot be empty"
+        RubyLLM.logger.error(error_msg)
+        return { error: error_msg }
+      end
+
+      # Show user the code and ask for confirmation
+      allowed = SharedTools.execute?(tool: self.class.name, stuff: code)
+
+      unless allowed
+        RubyLLM.logger.warn("User declined to execute the Python code")
+        return { error: "User declined to execute the Python code" }
+      end
+
+      RubyLLM.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?
+          RubyLLM.logger.debug("Python code execution completed successfully")
+          parse_python_output(stdout)
+        else
+          RubyLLM.logger.error("Python code execution failed: #{stderr}")
+          {
+            error: stderr.strip,
+            success: false
+          }
+        end
+      rescue => e
+        RubyLLM.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

data/lib/shared_tools/ruby_llm/read_file.rb

@@ -1,37 +1,38 @@
 # frozen_string_literal: true
 
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../../shared_tools'
 
 module SharedTools
-  class ReadFile < RubyLLM::Tool
+  verify_gem :ruby_llm
+
+  class ReadFile < ::RubyLLM::Tool
 
     description "Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names."
     param :path, desc: "The relative path of a file in the working directory."
 
     def execute(path:)
-      logger.info("Reading file: #{path}")
+      RubyLLM.logger.info("Reading file: #{path}")
 
       # Handle both relative and absolute paths consistently
       absolute_path = File.absolute_path(path)
 
       if File.directory?(absolute_path)
         error_msg = "Path is a directory, not a file: #{path}"
-        logger.error(error_msg)
+        RubyLLM.logger.error(error_msg)
         return { error: error_msg }
       end
 
       unless File.exist?(absolute_path)
         error_msg = "File does not exist: #{path}"
-        logger.error(error_msg)
+        RubyLLM.logger.error(error_msg)
         return { error: error_msg }
       end
 
       content = File.read(absolute_path)
-      logger.debug("Successfully read #{content.bytesize} bytes from #{path}")
+      RubyLLM.logger.debug("Successfully read #{content.bytesize} bytes from #{path}")
       content
     rescue => e
-      logger.error("Failed to read file '#{path}': #{e.message}")
+      RubyLLM.logger.error("Failed to read file '#{path}': #{e.message}")
       { error: e.message }
     end
   end

data/lib/shared_tools/ruby_llm/ruby_eval.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  verify_gem :ruby_llm
+
+  class RubyEval < ::RubyLLM::Tool
+
+    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
+    param :code, desc: "The Ruby code to execute"
+
+    def execute(code:)
+      RubyLLM.logger.info("Requesting permission to execute Ruby code")
+
+      if code.strip.empty?
+        error_msg = "Ruby code cannot be empty"
+        RubyLLM.logger.error(error_msg)
+        return { error: error_msg }
+      end
+
+      # Show user the code and ask for confirmation
+      allowed = SharedTools.execute?(tool: self.class.name, stuff: code)
+
+      unless allowed
+        RubyLLM.logger.warn("User declined to execute the Ruby code")
+        return { error: "User declined to execute the Ruby code" }
+      end
+
+      RubyLLM.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
+
+        RubyLLM.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
+        RubyLLM.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

data/lib/shared_tools/ruby_llm/run_shell_command.rb

@@ -1,48 +1,47 @@
 # frozen_string_literal: true
 
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../../shared_tools'
 
 module SharedTools
-  class RunShellCommand < RubyLLM::Tool
+  SharedTools.verify_gem :ruby_llm
+
+  class RunShellCommand < ::RubyLLM::Tool
 
     description "Execute a shell command"
     param :command, desc: "The command to execute"
 
     def execute(command:)
-      logger.info("Requesting permission to execute command: '#{command}'")
+      RubyLLM.logger.info("Requesting permission to execute command: '#{command}'")
 
       if command.strip.empty?
         error_msg = "Command cannot be empty"
-        logger.error(error_msg)
+        RubyLLM.logger.error(error_msg)
         return { error: error_msg }
       end
 
       # Show user the command and ask for confirmation
-      puts "AI wants to execute the following shell command: '#{command}'"
-      print "Do you want to execute it? (y/n) "
-      response = gets.chomp.downcase
+      allowed = SharedTools.execute?(tool: self.class.name, stuff: command)
 
-      unless response == "y"
-        logger.warn("User declined to execute the command: '#{command}'")
+      unless allowed
+        RubyLLM.logger.warn("User declined to execute the command: '#{command}'")
         return { error: "User declined to execute the command" }
       end
 
-      logger.info("Executing command: '#{command}'")
+      RubyLLM.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")
+        RubyLLM.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}")
+        RubyLLM.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}")
+      RubyLLM.logger.error("Command execution failed: #{e.message}")
       { error: e.message }
     end
   end

data/lib/shared_tools/ruby_llm.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require("ruby_llm")     unless defined?(RubyLLM)
-require("shared_tools") unless defined?(SharedTools)
+require_relative '../shared_tools'
 
-require_relative "ruby_llm/edit_file"
-require_relative "ruby_llm/list_files"
-require_relative "ruby_llm/pdf_page_reader"
-require_relative "ruby_llm/read_file"
-require_relative "ruby_llm/run_shell_command"
+SharedTools.verify_gem :ruby_llm
+
+Dir.glob(File.join(__dir__, "ruby_llm", "*.rb")).each do |file|
+  require file
+end

data/lib/shared_tools/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SharedTools
-  VERSION = "0.1.0"
+  VERSION = "0.1.3"
 end

data/lib/shared_tools.rb

@@ -1,46 +1,56 @@
 # frozen_string_literal: true
 
-require "shared_tools/version"
+require 'io/console'
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+# Ignore aggregate loader files that don't define constants
+loader.ignore("#{__dir__}/shared_tools/ruby_llm.rb")
+loader.ignore("#{__dir__}/shared_tools/llm_rb.rb")
+loader.ignore("#{__dir__}/shared_tools/omniai.rb")
+loader.ignore("#{__dir__}/shared_tools/raix.rb")
+loader.setup
 
 module SharedTools
+  SUPPORTED_GEMS = %i(ruby_llm llm_rb omniai raix)
+  @auto_execute = false # Human in the loop
+
   class << self
-    # def included(base)
-    #   base.extend(ClassMethods)
-
-    #   if base.is_a?(Class)
-    #     base.class_eval do
-    #       include InstanceMethods
-    #     end
-    #   else
-    #     base.module_eval do
-    #       def self.included(sub_base)
-    #         sub_base.include(SharedTools)
-    #       end
-    #     end
-    #   end
-    # end
-
-    # def extended(object)
-    #   object.extend(ClassMethods)
-    # end
-
-    # Hook to automatically inject logger into RubyLLM::Tool subclasses
-    def const_added(const_name)
-      const = const_get(const_name)
-
-      if const.is_a?(Class) && defined?(RubyLLM::Tool) && const < RubyLLM::Tool
-        const.class_eval do
-          def logger
-            SharedTools.logger
-          end
-
-          def self.logger
-            SharedTools.logger
-          end
-        end
-      end
+    def auto_execute(wildwest=true)
+      @auto_execute = wildwest
+    end
+
+    def execute?(tool: 'unknown', stuff: '')
+      # Return true if auto_execute is explicitly enabled
+      return true if @auto_execute == true
+
+      puts "\n\nThe AI (tool: #{tool}) wants to do the following ..."
+      puts "="*42
+      puts(stuff.empty? ? "unknown strange and mysterious things" : stuff)
+      puts "="*42
+
+      sleep 0.2 if defined?(AIA) # Allows CLI spinner to recycle
+      print "\nIs it okay to proceed? (y/N"
+      STDIN.getch == "y"
+    end
+
+
+    def detected_gem
+      return :ruby_llm  if defined?(::RubyLLM::Tool)
+      return :llm_rb    if defined?(::LLM) || defined?(::Llm)
+      return :omniai    if defined?(::OmniAI) || defined?(::Omniai)
+      return :raix      if defined?(::Raix::FunctionDispatch)
+      nil
+    end
+
+    def verify_gem(a_symbol)
+      loaded = a_symbol == detected_gem
+      return true if loaded
+      raise "SharedTools: Please require '#{a_symbol}' gem before requiring 'shared_tools'."
     end
   end
-end
 
-require "shared_tools/core"
+  if detected_gem.nil?
+    warn "⚠️  SharedTools: No supported gem detected. Supported gems are: #{SUPPORTED_GEMS.join(', ')}"
+  end
+end

metadata

@@ -1,28 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: shared_tools
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - MadBomber Team
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: logger
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: llm.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: omniai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pdf-reader
   requirement: !ruby/object:Gem::Requirement
@@ -37,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: raix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: debug_me
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -93,8 +149,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: SharedTools provides common functionality including configurable logging
-  and LLM tools
+description: |
+  SharedTools provides a collection of reusable common tools (aka callback functions)
+  for Ruby applications using various LLM-provider API gems.
 email:
 - example@example.com
 executables: []
@@ -105,12 +162,18 @@ files:
 - LICENSE
 - README.md
 - lib/shared_tools.rb
-- lib/shared_tools/core.rb
+- lib/shared_tools/llm_rb.rb
+- lib/shared_tools/llm_rb/run_shell_command.rb
+- lib/shared_tools/omniai.rb
+- lib/shared_tools/raix.rb
+- lib/shared_tools/raix/what_is_the_weather.rb
 - lib/shared_tools/ruby_llm.rb
 - lib/shared_tools/ruby_llm/edit_file.rb
 - lib/shared_tools/ruby_llm/list_files.rb
 - lib/shared_tools/ruby_llm/pdf_page_reader.rb
+- lib/shared_tools/ruby_llm/python_eval.rb
 - lib/shared_tools/ruby_llm/read_file.rb
+- lib/shared_tools/ruby_llm/ruby_eval.rb
 - lib/shared_tools/ruby_llm/run_shell_command.rb
 - lib/shared_tools/version.rb
 homepage: https://github.com/madbomber/shared_tools
@@ -127,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -136,5 +199,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A collection of shared tools and utilities for Ruby applications
+summary: Shared utilities and AI tools for Ruby applications with configurable logging
 test_files: []

data/lib/shared_tools/core.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-require "singleton"
-
-module SharedTools
-  DEFAULT_LOG_LEVEL = Logger::INFO
-
-  module InstanceMethods
-    # @return [Logger] The shared logger instance
-    def logger
-      SharedTools.logger
-    end
-  end
-
-  module ClassMethods
-    # @return [Logger] The shared logger instance
-    def logger
-      SharedTools.logger
-    end
-  end
-
-
-  class LoggerConfiguration
-    include Singleton
-
-    attr_accessor :level, :log_device, :formatter
-
-    def initialize
-      @level = DEFAULT_LOG_LEVEL
-      @log_device = STDOUT
-      @formatter = nil
-    end
-
-
-    def apply_to(logger)
-      logger.level = @level
-      logger.formatter = @formatter if @formatter
-    end
-  end
-
-
-  class << self
-    # @return [Logger] The configured logger instance
-    def logger
-      @logger ||= create_logger
-    end
-
-    # @param new_logger [Logger] A Logger instance to use
-    def logger=(new_logger)
-      @logger = new_logger
-    end
-
-
-    # @example
-    #   SharedTools.configure_logger do |config|
-    #     config.level = Logger::DEBUG
-    #     config.log_device = 'logs/application.log'
-    #     config.formatter = proc { |severity, time, progname, msg| "[#{time}] #{severity} - #{msg}\n" }
-    #   end
-    def configure_logger
-      yield LoggerConfiguration.instance
-
-
-      if @logger
-        @logger = create_logger
-      end
-    end
-
-    private
-
-    # @return [Logger] A newly configured logger
-    def create_logger
-      config = LoggerConfiguration.instance
-      logger = Logger.new(config.log_device)
-      config.apply_to(logger)
-      logger
-    end
-  end
-
-
-  # module LoggingSupport
-  #   def self.included(base)
-  #     base.include(SharedTools)
-  #   end
-  # end
-end