shared_tools 0.2.1 → 0.3.0

data/lib/shared_tools/ruby_llm/incomplete/weather_tool.rb

@@ -1,110 +0,0 @@
-# weather_tool.rb - API integration example
-require 'ruby_llm/tool'
-require 'net/http'
-require 'json'
-
-module Tools
-  class WeatherTool < RubyLLM::Tool
-    def self.name = 'weather_tool'
-
-    description <<~DESCRIPTION
-      Retrieve comprehensive current weather information for any city worldwide using the OpenWeatherMap API.
-      This tool provides real-time weather data including temperature, atmospheric conditions, humidity,
-      and wind information. It supports multiple temperature units and can optionally include extended
-      forecast data. The tool requires a valid OpenWeatherMap API key to be configured in the
-      OPENWEATHER_API_KEY environment variable. All weather data is fetched in real-time and includes
-      timestamps for accuracy verification.
-    DESCRIPTION
-
-    param :city,
-          desc: <<~DESC,
-            Name of the city for weather lookup. Can include city name only (e.g., 'London')
-            or city with country code for better accuracy (e.g., 'London,UK' or 'Paris,FR').
-            For cities with common names in multiple countries, including the country code
-            is recommended to ensure accurate results. The API will attempt to find the
-            closest match if an exact match is not found.
-          DESC
-          type: :string,
-          required: true
-
-    param :units,
-          desc: <<~DESC,
-            Temperature unit system for the weather data. Options are:
-            - 'metric': Temperature in Celsius, wind speed in m/s, pressure in hPa
-            - 'imperial': Temperature in Fahrenheit, wind speed in mph, pressure in hPa
-            - 'kelvin': Temperature in Kelvin (scientific standard), wind speed in m/s
-            Default is 'metric' which is most commonly used internationally.
-          DESC
-          type: :string,
-          default: "metric",
-          enum: ["metric", "imperial", "kelvin"]
-
-    param :include_forecast,
-          desc: <<~DESC,
-            Boolean flag to include a 3-day weather forecast in addition to current conditions.
-            When set to true, the response will include forecast data with daily high/low temperatures,
-            precipitation probability, and general weather conditions for the next three days.
-            This requires additional API calls and may increase response time slightly.
-          DESC
-          type: :boolean,
-          default: false
-
-    def execute(city:, units: "metric", include_forecast: false)
-      begin
-        api_key = ENV['OPENWEATHER_API_KEY']
-        raise "OpenWeather API key not configured" unless api_key
-
-        current_weather = fetch_current_weather(city, units, api_key)
-        result = {
-          success:   true,
-          city:      city,
-          current:   current_weather,
-          units:     units,
-          timestamp: Time.now.iso8601
-        }
-
-        if include_forecast
-          forecast_data = fetch_forecast(city, units, api_key)
-          result[:forecast] = forecast_data
-        end
-
-        result
-      rescue => e
-        {
-          success:    false,
-          error:      e.message,
-          city:       city,
-          suggestion: "Verify city name and API key configuration"
-        }
-      end
-    end
-
-    private
-
-    def fetch_current_weather(city, units, api_key)
-      uri = URI("https://api.openweathermap.org/data/2.5/weather")
-      params = {
-        q:     city,
-        appid: api_key,
-        units: units
-      }
-      uri.query = URI.encode_www_form(params)
-
-      response = Net::HTTP.get_response(uri)
-      raise "Weather API error: #{response.code}" unless response.code == '200'
-
-      data = JSON.parse(response.body)
-      {
-        temperature: data['main']['temp'],
-        description: data['weather'][0]['description'],
-        humidity:    data['main']['humidity'],
-        wind_speed:  data['wind']['speed']
-      }
-    end
-
-    def fetch_forecast(city, units, api_key)
-      # Implementation for forecast data
-      # Similar pattern to current weather
-    end
-  end
-end

data/lib/shared_tools/ruby_llm/incomplete/workflow_manager_tool.rb

@@ -1,145 +0,0 @@
-# workflow_manager_tool.rb - Managing state across tool invocations
-require 'ruby_llm/tool'
-require 'securerandom'
-require 'json'
-
-module Tools
-  class WorkflowManager < RubyLLM::Tool
-    def self.name = 'workflow_manager'
-
-    description <<~DESCRIPTION
-      Manage complex multi-step workflows with persistent state tracking across tool invocations.
-      This tool enables the creation and management of stateful workflows that can span multiple
-      AI interactions and tool calls. It provides workflow initialization, step-by-step execution,
-      status monitoring, and completion tracking. Each workflow maintains its state in persistent
-      storage, allowing for resumption of long-running processes and coordination between
-      multiple tools and AI interactions. Perfect for complex automation tasks that require
-      multiple stages and decision points.
-    DESCRIPTION
-
-    param :action,
-          desc: <<~DESC,
-            Workflow management action to perform:
-            - 'start': Initialize a new workflow with initial data and return workflow ID
-            - 'step': Execute the next step in an existing workflow using provided step data
-            - 'status': Check the current status and progress of an existing workflow
-            - 'complete': Mark a workflow as finished and clean up associated resources
-            Each action requires different combinations of the other parameters.
-          DESC
-          type: :string,
-          required: true,
-          enum: ["start", "step", "status", "complete"]
-
-    param :workflow_id,
-          desc: <<~DESC,
-            Unique identifier for an existing workflow. Required for 'step', 'status', and 'complete'
-            actions. This ID is returned when starting a new workflow and should be used for all
-            subsequent operations on that workflow. The ID is a UUID string that ensures
-            uniqueness across all workflow instances.
-          DESC
-          type: :string
-
-    param :step_data,
-          desc: <<~DESC,
-            Hash containing data and parameters specific to the current workflow step.
-            For 'start' action: Initial configuration and parameters for the workflow.
-            For 'step' action: Input data, parameters, and context needed for the next step.
-            The structure depends on the specific workflow type and current step requirements.
-            Can include nested hashes, arrays, and any JSON-serializable data types.
-          DESC
-          type: :hash,
-          default: {}
-
-    def execute(action:, workflow_id: nil, step_data: {})
-      case action
-      when "start"
-        start_workflow(step_data)
-      when "step"
-        process_workflow_step(workflow_id, step_data)
-      when "status"
-        get_workflow_status(workflow_id)
-      when "complete"
-        complete_workflow(workflow_id)
-      else
-        { success: false, error: "Unknown action: #{action}" }
-      end
-    end
-
-    private
-
-    def start_workflow(initial_data)
-      workflow_id = SecureRandom.uuid
-      workflow_state = {
-        id:         workflow_id,
-        status:     "active",
-        steps:      [],
-        created_at: Time.now.iso8601,
-        data:       initial_data
-      }
-
-      save_workflow_state(workflow_id, workflow_state)
-
-      {
-        success:      true,
-        workflow_id:  workflow_id,
-        status:       "started",
-        next_actions: suggested_next_actions(initial_data)
-      }
-    end
-
-    def process_workflow_step(workflow_id, step_data)
-      workflow_state = load_workflow_state(workflow_id)
-      return { success: false, error: "Workflow not found" } unless workflow_state
-
-      step = {
-        step_number:  workflow_state[:steps].length + 1,
-        data:         step_data,
-        processed_at: Time.now.iso8601,
-        result:       process_step_logic(step_data, workflow_state)
-      }
-
-      workflow_state[:steps] << step
-      workflow_state[:updated_at] = Time.now.iso8601
-
-      save_workflow_state(workflow_id, workflow_state)
-
-      {
-        success:         true,
-        workflow_id:     workflow_id,
-        step_completed:  step,
-        workflow_status: workflow_state[:status],
-        next_actions:    suggested_next_actions(workflow_state)
-      }
-    end
-
-    def save_workflow_state(workflow_id, state)
-      # Implementation for state persistence
-      # Could use files, database, or memory store
-      File.write(".workflow_#{workflow_id}.json", state.to_json)
-    end
-
-    def load_workflow_state(workflow_id)
-      # Implementation for state loading
-      file_path = ".workflow_#{workflow_id}.json"
-      return nil unless File.exist?(file_path)
-
-      JSON.parse(File.read(file_path), symbolize_names: true)
-    end
-
-    def get_workflow_status(workflow_id)
-      # Implementation for status retrieval
-    end
-
-    def complete_workflow(workflow_id)
-      # Implementation for workflow completion
-    end
-
-    def suggested_next_actions(workflow_state)
-      # Implementation for suggesting next actions
-    end
-
-    def process_step_logic(step_data, workflow_state)
-      # Implementation for processing step logic
-    end
-  end
-end

data/lib/shared_tools/ruby_llm/list_files.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../shared_tools'
-
-module SharedTools
-  verify_gem :ruby_llm
-
-  class ListFiles < ::RubyLLM::Tool
-      def self.name = 'list_files'
-
-    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)
-      RubyLLM.logger.info("Listing files in path: #{path}")
-
-      # Convert to absolute path for consistency
-      absolute_path = File.absolute_path(path)
-
-      # 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}"
-        RubyLLM.logger.error(error_msg)
-        return { error: error_msg }
-      end
-
-      # Get all files including hidden ones
-      visible_files = Dir.glob(File.join(absolute_path, "*"))
-      hidden_files = Dir.glob(File.join(absolute_path, ".*"))
-                        .reject { |f| f.end_with?("/.") || f.end_with?("/..") }
-
-      # Combine and format results
-      all_files = (visible_files + hidden_files).sort
-      formatted_files = all_files.map do |filename|
-        if File.directory?(filename)
-          "#{filename}/"
-        else
-          filename
-        end
-      end
-
-      RubyLLM.logger.debug("Found #{formatted_files.size} files/directories (including #{hidden_files.size} hidden)")
-      formatted_files
-    rescue => e
-      RubyLLM.logger.error("Failed to list files in '#{path}': #{e.message}")
-      { error: e.message }
-    end
-  end
-end

data/lib/shared_tools/ruby_llm/mcp/imcp.rb

@@ -1,33 +0,0 @@
-# shared_tools/ruby_llm/mcp/imcp.rb
-# iMCP is a MacOS program that provides access to notes,calendar,contacts, etc.
-# See: https://github.com/loopwork/iMCP
-# brew install --cask loopwork/tap/iMCP
-#
-# CAUTION: AIA is getting an exception when trying to use this MCP client.  Its returning to
-#          do a to_sym on a nil value.  This is due to a lack of a nil guard in the
-#          version 0.3.1 of the ruby_llm-mpc Parameter#item_type method.
-#
-# NOTE: iMCP's server is a noisy little thing shooting all its log messages to STDERR.
-#       To silence it, redirect STDERR to /dev/null.
-#       If you messages then you might want to redirect STDERR to a file.
-#
-
-require 'debug_me'
-include DebugMe
-
-require 'ruby_llm'
-require 'ruby_llm/mcp'
-
-require_relative '../../../shared_tools'
-
-module SharedTools
-  verify_gem :ruby_llm
-
-  mcp_servers << RubyLLM::MCP.client(
-    name: "imcp-server",
-    transport_type: :stdio,
-    config: {
-      command: "/Applications/iMCP.app/Contents/MacOS/imcp-server 2> /dev/null"
-    }
-  )
-end

data/lib/shared_tools/ruby_llm/mcp.rb

@@ -1,10 +0,0 @@
-# shared_tools/ruby_llm/mcp.rb
-# This file loads all Ruby files in the mcp directory
-
-# Get the directory path
-mcp_dir = File.join(__dir__, 'mcp')
-
-# Load all .rb files in the mcp directory
-Dir.glob(File.join(mcp_dir, '*.rb')).each do |file|
-  require file
-end

data/lib/shared_tools/ruby_llm/pdf_page_reader.rb

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

data/lib/shared_tools/ruby_llm/python_eval.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../shared_tools'
-
-module SharedTools
-  verify_gem :ruby_llm
-
-  class PythonEval < ::RubyLLM::Tool
-      def self.name = 'python_eval'
-
-    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.to_s, 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,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../shared_tools'
-
-module SharedTools
-  verify_gem :ruby_llm
-
-  class ReadFile < ::RubyLLM::Tool
-    def self.name = 'read_file'
-
-    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:)
-      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}"
-        RubyLLM.logger.error(error_msg)
-        return { error: error_msg }
-      end
-
-      unless File.exist?(absolute_path)
-        error_msg = "File does not exist: #{path}"
-        RubyLLM.logger.error(error_msg)
-        return { error: error_msg }
-      end
-
-      content = File.read(absolute_path)
-      RubyLLM.logger.debug("Successfully read #{content.bytesize} bytes from #{path}")
-      content
-    rescue => e
-      RubyLLM.logger.error("Failed to read file '#{path}': #{e.message}")
-      { error: e.message }
-    end
-  end
-end