shared_tools 0.3.0 → 0.4.1

data/lib/shared_tools/tools/notification/mac_driver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module SharedTools
+  module Tools
+    module Notification
+      # macOS notification driver using osascript and the say command.
+      class MacDriver < BaseDriver
+        # @param message [String]
+        # @param title [String, nil]
+        # @param subtitle [String, nil]
+        # @param sound [String, nil] e.g. 'Glass', 'Ping'
+        # @return [Hash]
+        def notify(message:, title: nil, subtitle: nil, sound: nil)
+          parts = ["display notification #{message.inspect}"]
+          parts << "with title #{title.inspect}" if title
+          parts << "subtitle #{subtitle.inspect}"  if subtitle
+          parts << "sound name #{sound.inspect}"   if sound
+          run_osascript(parts.join(' '))
+            .then { |r| r[:success] ? r.merge(action: 'notify') : r }
+        end
+
+        # @param message [String]
+        # @param title [String, nil]
+        # @param buttons [Array<String>]
+        # @param default_button [String, nil]
+        # @return [Hash] includes :button with label of clicked button
+        def alert(message:, title: nil, buttons: ['OK'], default_button: nil)
+          btn_list  = buttons.map(&:inspect).join(', ')
+          script    = "display dialog #{message.inspect}"
+          script   += " with title #{title.inspect}" if title
+          script   += " buttons {#{btn_list}}"
+          script   += " default button #{default_button.inspect}" if default_button
+
+          stdout, stderr, status = Open3.capture3('osascript', '-e', script)
+          if status.success?
+            button = stdout.match(/button returned:(.+)/i)&.captures&.first&.strip
+            { success: true, button: button }
+          else
+            { success: false, error: stderr.strip }
+          end
+        end
+
+        # @param text [String]
+        # @param voice [String, nil] e.g. 'Samantha'
+        # @param rate [Integer, nil] words per minute
+        # @return [Hash]
+        def speak(text:, voice: nil, rate: nil)
+          cmd  = ['say', text]
+          cmd += ['-v', voice]    if voice
+          cmd += ['-r', rate.to_s] if rate
+          _, stderr, status = Open3.capture3(*cmd)
+          status.success? ? { success: true, action: 'speak' } : { success: false, error: stderr.strip }
+        end
+
+        private
+
+        def run_osascript(script)
+          _, stderr, status = Open3.capture3('osascript', '-e', script)
+          status.success? ? { success: true } : { success: false, error: stderr.strip }
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/notification/null_driver.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SharedTools
+  module Tools
+    module Notification
+      # Fallback driver for unsupported platforms.
+      # All actions return a failure response with a clear error message.
+      class NullDriver < BaseDriver
+        def notify(message:, title: nil, subtitle: nil, sound: nil)
+          unsupported
+        end
+
+        def alert(message:, title: nil, buttons: ['OK'], default_button: nil)
+          unsupported
+        end
+
+        def speak(text:, voice: nil, rate: nil)
+          unsupported
+        end
+
+        private
+
+        def unsupported
+          { success: false, error: "NotificationTool is not supported on platform: #{RUBY_PLATFORM}" }
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/notification.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Collection loader for notification tools
+# Usage: require 'shared_tools/tools/notification'
+
+require 'shared_tools'
+
+require_relative 'notification/base_driver'
+require_relative 'notification/mac_driver'
+require_relative 'notification/linux_driver'
+require_relative 'notification/null_driver'
+require_relative 'notification_tool'

data/lib/shared_tools/tools/notification_tool.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module SharedTools
+  module Tools
+    # Cross-platform notification tool for desktop banners, modal dialogs, and TTS.
+    #
+    # Supports macOS (osascript, say) and Linux (notify-send, zenity/terminal, espeak-ng/espeak).
+    # On unsupported platforms all actions return {success: false}.
+    #
+    # @example Desktop notification
+    #   tool = SharedTools::Tools::NotificationTool.new
+    #   tool.execute(action: 'notify', message: 'Build complete', title: 'CI')
+    #
+    # @example Modal alert
+    #   result = tool.execute(action: 'alert', message: 'Deploy to production?', buttons: ['Yes', 'No'])
+    #   result[:button] # => 'Yes' or 'No'
+    #
+    # @example Text-to-speech
+    #   tool.execute(action: 'speak', message: 'Task finished')
+    class NotificationTool < ::RubyLLM::Tool
+      def self.name = 'notification_tool'
+
+      description <<~DESC.strip
+        Send desktop notifications, modal alerts, or text-to-speech messages.
+        Supports macOS and Linux. On macOS uses osascript and say.
+        On Linux uses notify-send, zenity (or terminal fallback), and espeak-ng/espeak.
+      DESC
+
+      params do
+        string :action, description: <<~TEXT.strip
+          The notification action to perform:
+          * `notify` — Non-blocking desktop banner notification.
+          * `alert`  — Modal dialog; waits for the user to click a button. Returns the button label.
+          * `speak`  — Speak text aloud using text-to-speech.
+        TEXT
+
+        string :message, description: "The message to display or speak. Required for all actions."
+
+        string :title, description: "Title for the notification or alert dialog. Optional.", required: false
+
+        string :subtitle, description: "Subtitle line (notify action, macOS and Linux). Optional.", required: false
+
+        string :sound, description: "Sound name to play with a notification (macOS only, e.g. 'Glass', 'Ping'). Optional.", required: false
+
+        array :buttons, of: :string, description: <<~TEXT.strip, required: false
+          Button labels for the alert dialog (e.g. ['Yes', 'No']). Defaults to ['OK'].
+        TEXT
+
+        string :default_button, description: "Default focused button label for the alert dialog. Optional.", required: false
+
+        string :voice, description: "TTS voice name for the speak action (e.g. 'Samantha' on macOS, 'en' on Linux). Optional.", required: false
+
+        integer :rate, description: "Speech rate in words per minute for the speak action. Optional.", required: false
+      end
+
+      # @param driver [Notification::BaseDriver] optional; auto-detected from platform if omitted
+      def initialize(driver: nil)
+        @driver = driver || default_driver
+      end
+
+      def execute(action:, message: nil, title: nil, subtitle: nil, sound: nil,
+                  buttons: nil, default_button: nil, voice: nil, rate: nil)
+        buttons ||= ['OK']
+
+        case action
+        when 'notify'
+          return missing_param('message', 'notify') if blank?(message)
+          @driver.notify(message:, title:, subtitle:, sound:)
+        when 'alert'
+          return missing_param('message', 'alert') if blank?(message)
+          @driver.alert(message:, title:, buttons:, default_button:)
+        when 'speak'
+          return missing_param('message', 'speak') if blank?(message)
+          @driver.speak(text: message, voice:, rate:)
+        else
+          { success: false, error: "Unknown action: #{action.inspect}. Must be notify, alert, or speak." }
+        end
+      end
+
+      private
+
+      def default_driver
+        case RUBY_PLATFORM
+        when /darwin/ then Notification::MacDriver.new
+        when /linux/  then Notification::LinuxDriver.new
+        else               Notification::NullDriver.new
+        end
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def missing_param(param, action)
+        { success: false, error: "'#{param}' is required for the #{action} action" }
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/system_info_tool.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  module Tools
+    # Returns OS, CPU, memory, disk, network, and Ruby runtime information.
+    #
+    # @example
+    #   tool = SharedTools::Tools::SystemInfoTool.new
+    #   tool.execute                     # all categories
+    #   tool.execute(category: 'cpu')    # CPU only
+    class SystemInfoTool < ::RubyLLM::Tool
+      def self.name = 'system_info_tool'
+
+      description <<~DESC
+        Retrieve system information from the local machine.
+
+        Categories:
+        - 'os'      — Operating system name, version, hostname
+        - 'cpu'     — CPU model, core count, load averages
+        - 'memory'  — Total and available RAM in GB
+        - 'disk'    — Mounted filesystems with used/available space
+        - 'network' — Active network interfaces and their IP addresses
+        - 'ruby'    — Ruby version, platform, engine, RubyGems version
+        - 'all'     (default) — All of the above combined
+      DESC
+
+      params do
+        string :category, required: false, description: <<~DESC.strip
+          Info category. Options: 'os', 'cpu', 'memory', 'disk', 'network', 'ruby', 'all' (default).
+        DESC
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param category [String] which subsystem to query
+      # @return [Hash] system information
+      def execute(category: 'all')
+        @logger.info("SystemInfoTool#execute category=#{category}")
+
+        case category.to_s.downcase
+        when 'os'      then { success: true }.merge(os_info)
+        when 'cpu'     then { success: true }.merge(cpu_info)
+        when 'memory'  then { success: true }.merge(memory_info)
+        when 'disk'    then { success: true }.merge(disk_info)
+        when 'network' then { success: true }.merge(network_info)
+        when 'ruby'    then { success: true }.merge(ruby_info)
+        else
+          { success: true }
+            .merge(os_info)
+            .merge(cpu_info)
+            .merge(memory_info)
+            .merge(disk_info)
+            .merge(network_info)
+            .merge(ruby_info)
+        end
+      rescue => e
+        @logger.error("SystemInfoTool error: #{e.message}")
+        { success: false, error: e.message }
+      end
+
+      private
+
+      def os_info
+        {
+          os_platform: RUBY_PLATFORM,
+          os_name:     detect_os_name,
+          os_version:  detect_os_version,
+          hostname:    `hostname`.strip
+        }
+      end
+
+      def cpu_info
+        if RUBY_PLATFORM.include?('darwin')
+          model  = `sysctl -n machdep.cpu.brand_string 2>/dev/null`.strip
+          cores  = `sysctl -n hw.ncpu 2>/dev/null`.strip.to_i
+          load   = `sysctl -n vm.loadavg 2>/dev/null`.strip
+                     .gsub(/[{}]/, '').split.first(3).map(&:to_f)
+        else
+          model  = File.read('/proc/cpuinfo')
+                     .match(/model name\s*:\s*(.+)/)&.captures&.first&.strip rescue 'Unknown'
+          cores  = `nproc 2>/dev/null`.strip.to_i
+          load   = File.read('/proc/loadavg').split.first(3).map(&:to_f) rescue [0.0, 0.0, 0.0]
+        end
+
+        {
+          cpu_model:      model.empty? ? 'Unknown' : model,
+          cpu_cores:      cores,
+          load_avg_1m:    load[0],
+          load_avg_5m:    load[1],
+          load_avg_15m:   load[2]
+        }
+      end
+
+      def memory_info
+        if RUBY_PLATFORM.include?('darwin')
+          total    = `sysctl -n hw.memsize 2>/dev/null`.strip.to_i
+          vm_stat  = `vm_stat 2>/dev/null`
+          pg_size  = vm_stat.match(/page size of (\d+) bytes/)&.captures&.first&.to_i || 4096
+          free_pg  = vm_stat.match(/Pages free:\s+(\d+)/)&.captures&.first&.to_i || 0
+          inact_pg = vm_stat.match(/Pages inactive:\s+(\d+)/)&.captures&.first&.to_i || 0
+          available = (free_pg + inact_pg) * pg_size
+        else
+          mem = File.read('/proc/meminfo') rescue ''
+          total     = (mem.match(/MemTotal:\s+(\d+) kB/)&.captures&.first&.to_i || 0) * 1024
+          available = (mem.match(/MemAvailable:\s+(\d+) kB/)&.captures&.first&.to_i || 0) * 1024
+        end
+
+        gb = 1024.0**3
+        {
+          memory_total_gb:     (total     / gb).round(2),
+          memory_available_gb: (available / gb).round(2),
+          memory_used_gb:      ((total - available) / gb).round(2)
+        }
+      end
+
+      def disk_info
+        lines  = `df -k 2>/dev/null`.lines.drop(1)
+        mounts = lines.filter_map do |line|
+          parts = line.split
+          next unless parts.size >= 6
+
+          kb = 1024.0**2
+          {
+            filesystem:    parts[0],
+            mount_point:   parts[5],
+            size_gb:       (parts[1].to_i / kb).round(2),
+            used_gb:       (parts[2].to_i / kb).round(2),
+            available_gb:  (parts[3].to_i / kb).round(2),
+            use_percent:   parts[4]
+          }
+        end
+        { disks: mounts }
+      end
+
+      def network_info
+        interfaces = {}
+
+        if RUBY_PLATFORM.include?('darwin')
+          current = nil
+          `ifconfig 2>/dev/null`.lines.each do |line|
+            if (m = line.match(/^(\w[\w:]+\d+):/))
+              current = m.captures.first
+              interfaces[current] = []
+            elsif current && (m = line.match(/\s+inet6?\s+(\S+)/))
+              addr = m.captures.first.split('%').first
+              interfaces[current] << addr
+            end
+          end
+        else
+          current = nil
+          `ip addr 2>/dev/null`.lines.each do |line|
+            if (m = line.match(/^\d+: (\w+):/))
+              current = m.captures.first
+              interfaces[current] = []
+            elsif current && (m = line.match(/\s+inet6?\s+(\S+)/))
+              interfaces[current] << m.captures.first.split('/').first
+            end
+          end
+        end
+
+        { network_interfaces: interfaces.reject { |_, ips| ips.empty? } }
+      end
+
+      def ruby_info
+        {
+          ruby_version:      RUBY_VERSION,
+          ruby_platform:     RUBY_PLATFORM,
+          ruby_engine:       RUBY_ENGINE,
+          ruby_description:  RUBY_DESCRIPTION,
+          rubygems_version:  Gem::VERSION
+        }
+      end
+
+      def detect_os_name
+        if RUBY_PLATFORM.include?('darwin')
+          `sw_vers -productName 2>/dev/null`.strip
+        elsif File.exist?('/etc/os-release')
+          File.read('/etc/os-release').match(/^NAME="?([^"\n]+)"?/)&.captures&.first || 'Linux'
+        else
+          'Unknown'
+        end
+      rescue
+        'Unknown'
+      end
+
+      def detect_os_version
+        if RUBY_PLATFORM.include?('darwin')
+          `sw_vers -productVersion 2>/dev/null`.strip
+        elsif File.exist?('/etc/os-release')
+          File.read('/etc/os-release').match(/^VERSION="?([^"\n]+)"?/)&.captures&.first || 'Unknown'
+        else
+          'Unknown'
+        end
+      rescue
+        'Unknown'
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/workflow_manager_tool.rb

@@ -34,6 +34,7 @@ module SharedTools
           - '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
+          - 'list': List all existing workflows with their current status and summary information
           Each action requires different combinations of the other parameters.
         DESC
 
@@ -84,6 +85,8 @@ module SharedTools
         when "complete"
           return {success: false, error: "workflow_id required for 'complete' action"} unless workflow_id
           complete_workflow(workflow_id)
+        when "list"
+          list_workflows
         else
           {success: false, error: "Unknown action: #{action}"}
         end
@@ -279,6 +282,35 @@ module SharedTools
         }
       end
 
+      # List all workflows in the storage directory
+      def list_workflows
+        pattern = File.join(@storage_dir, "workflow_*.json")
+        files = Dir.glob(pattern)
+
+        workflows = files.filter_map do |file|
+          state = JSON.parse(File.read(file), symbolize_names: true)
+          {
+            workflow_id:  state[:id],
+            status:       state[:status],
+            step_count:   state[:steps]&.length || 0,
+            created_at:   state[:created_at],
+            updated_at:   state[:updated_at],
+            completed_at: state[:completed_at]
+          }
+        rescue => e
+          @logger.warn("Skipping unreadable workflow file #{file}: #{e.message}")
+          nil
+        end
+
+        workflows.sort_by! { |w| w[:created_at] || "" }
+
+        {
+          success:        true,
+          total:          workflows.size,
+          workflows:      workflows
+        }
+      end
+
       # Save workflow state to disk
       def save_workflow_state(workflow_id, state)
         file_path = workflow_file_path(workflow_id)

data/lib/shared_tools/utilities.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+#
+# lib/shared_tools/utilities.rb
+#
+# General-purpose utility methods for SharedTools MCP clients and tools.
+# Loaded automatically by lib/shared_tools.rb.
+
+module SharedTools
+  MCP_LOG_MUTEX = Mutex.new
+  @mcp_load_log = {}
+
+  class << self
+
+    # ---------------------------------------------------------------------------
+    # MCP load tracking
+    # ---------------------------------------------------------------------------
+
+    # Record the outcome of loading a single MCP client.
+    # Called by mcp.rb from within each loader thread.
+    #
+    #   SharedTools.record_mcp_result("tavily")              # success
+    #   SharedTools.record_mcp_result("notion", error: e)    # failure
+    def record_mcp_result(name, error: nil)
+      MCP_LOG_MUTEX.synchronize do
+        @mcp_load_log[name] = error ? { status: :failed, reason: error.message } : { status: :ok }
+      end
+    end
+
+    # Returns an array of client names that loaded successfully.
+    #
+    #   SharedTools.mcp_loaded  #=> ["github", "memory", "chart"]
+    def mcp_loaded
+      MCP_LOG_MUTEX.synchronize { @mcp_load_log.select { |_, v| v[:status] == :ok }.keys }
+    end
+
+    # Returns a hash of client names that failed to load, mapped to their error messages.
+    #
+    #   SharedTools.mcp_failed  #=> {"tavily" => "Missing envars: TAVILY_API_KEY", ...}
+    def mcp_failed
+      MCP_LOG_MUTEX.synchronize do
+        @mcp_load_log.select { |_, v| v[:status] == :failed }.transform_values { |v| v[:reason] }
+      end
+    end
+
+    # Prints a summary table of MCP client load results and returns the full log hash.
+    #
+    #   SharedTools.mcp_status
+    #   # MCP Client Status
+    #   # ✓ github
+    #   # ✓ memory
+    #   # ✗ tavily   — Missing envars: TAVILY_API_KEY
+    def mcp_status
+      log = MCP_LOG_MUTEX.synchronize { @mcp_load_log.dup }
+
+      if log.empty?
+        puts "No MCP clients have been loaded yet. Try: require 'shared_tools/mcp'"
+        return log
+      end
+
+      puts "MCP Client Status"
+      puts "-" * 40
+      log.sort.each do |name, entry|
+        if entry[:status] == :ok
+          puts "  \u2713 #{name}"
+        else
+          puts "  \u2717 #{name}  \u2014 #{entry[:reason]}"
+        end
+      end
+      puts "-" * 40
+      puts "  #{log.count { |_, v| v[:status] == :ok }} loaded, " \
+           "#{log.count { |_, v| v[:status] == :failed }} skipped"
+
+      log
+    end
+
+    # Returns true if all named environment variables are set and non-empty.
+    # Warns for each missing variable and returns false if any are absent.
+    #
+    #   SharedTools.verify_envars("GITHUB_PERSONAL_ACCESS_TOKEN")
+    #   SharedTools.verify_envars("TAVILY_API_KEY", "ANOTHER_KEY")
+    def verify_envars(*names)
+      missing = names.select { |n| ENV.fetch(n, "").empty? }
+      missing.each { |n| warn "SharedTools — #{n} is not set" }
+      unless missing.empty?
+        raise LoadError, "Missing envars: #{missing.join(', ')}"
+      end
+    end
+
+    # High-level package installer. Detects the current platform and calls the
+    # appropriate *_install method. Raises LoadError if any package cannot be installed.
+    #
+    #   SharedTools.package_install("github-mcp-server")
+    #   SharedTools.package_install("curl", "jq")
+    def package_install(*packages)
+      case RUBY_PLATFORM
+      when /darwin/
+        brew_install(*packages)
+      when /linux/
+        if system("which apt-get > /dev/null 2>&1")
+          apt_install(*packages)
+        elsif system("which dnf > /dev/null 2>&1")
+          dnf_install(*packages)
+        elsif system("which brew > /dev/null 2>&1")
+          brew_install(*packages)
+        else
+          raise LoadError, "No supported package manager found (apt-get, dnf, brew)"
+        end
+      else
+        raise LoadError, "Unsupported platform: #{RUBY_PLATFORM}"
+      end
+    end
+
+    # Ensures each named binary is available in PATH, installing via brew if missing.
+    # Raises LoadError if brew is not installed or any package install fails.
+    #
+    #   SharedTools.brew_install("github-mcp-server")
+    #   SharedTools.brew_install("gh", "jq")
+    def brew_install(*packages)
+      raise LoadError, "Homebrew is not installed (https://brew.sh)" unless system("which brew > /dev/null 2>&1")
+
+      packages.each do |pkg|
+        next unless `brew list --versions #{pkg} 2>/dev/null`.strip.empty?
+
+        warn "SharedTools — #{pkg} not found, installing via brew..."
+        raise LoadError, "#{pkg} could not be installed" unless system("brew install --quiet #{pkg} > /dev/null 2>&1")
+      end
+    end
+
+    # Ensures each named binary is available in PATH, installing via apt-get if missing.
+    # Raises LoadError if any package install fails.
+    #
+    #   SharedTools.apt_install("curl")
+    #   SharedTools.apt_install("curl", "jq")
+    def apt_install(*packages)
+      packages.each do |pkg|
+        # SMELL: what if package is a library?
+        next if system("which #{pkg} > /dev/null 2>&1")
+
+        warn "SharedTools — #{pkg} not found, installing via apt-get..."
+        raise LoadError, "#{pkg} could not be installed" unless system("sudo apt-get install -y -q #{pkg} > /dev/null 2>&1")
+      end
+    end
+
+    # Ensures each named binary is available in PATH, installing via dnf if missing.
+    # Raises LoadError if any package install fails.
+    #
+    #   SharedTools.dnf_install("curl")
+    #   SharedTools.dnf_install("curl", "jq")
+    def dnf_install(*packages)
+      packages.each do |pkg|
+        # SMELL: What if package is a library?
+        next if system("which #{pkg} > /dev/null 2>&1")
+
+        warn "SharedTools — #{pkg} not found, installing via dnf..."
+        raise LoadError, "#{pkg} could not be installed" unless system("sudo dnf install -y -q #{pkg} > /dev/null 2>&1")
+      end
+    end
+
+    # Ensures each named npm package binary is available in PATH, installing
+    # globally via npm if missing. Raises LoadError if npm is not found or any install fails.
+    #
+    #   SharedTools.npm_install("typescript")
+    #   SharedTools.npm_install("typescript", "ts-node")
+    def npm_install(*packages)
+      raise LoadError, "npm is not installed (https://nodejs.org)" unless system("which npm > /dev/null 2>&1")
+
+      packages.each do |pkg|
+        # SMELL: What if package is a library?
+        next if system("which #{pkg} > /dev/null 2>&1")
+
+        warn "SharedTools — #{pkg} not found, installing via npm..."
+        raise LoadError, "#{pkg} could not be installed" unless system("npm install -g --silent #{pkg} > /dev/null 2>&1")
+      end
+    end
+
+    # Ensures each named gem is available, installing via gem install if missing.
+    # Raises LoadError if gem is not available or any install fails.
+    #
+    #   SharedTools.gem_install("nokogiri")
+    #   SharedTools.gem_install("nokogiri", "oj")
+    def gem_install(*packages)
+      raise LoadError, "gem is not available" unless system("which gem > /dev/null 2>&1")
+
+      packages.each do |pkg|
+        next if system("gem list -i #{pkg} > /dev/null 2>&1")
+
+        warn "SharedTools — #{pkg} not found, installing via gem..."
+        raise LoadError, "#{pkg} could not be installed" unless system("gem install --silent #{pkg} > /dev/null 2>&1")
+      end
+    end
+
+  end
+end

data/lib/shared_tools/version.rb

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

data/lib/shared_tools/weather_tool.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+# Shim: require 'shared_tools/weather_tool'
+require 'shared_tools'
+require 'shared_tools/tools/weather_tool'

data/lib/shared_tools/workflow_manager_tool.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+# Shim: require 'shared_tools/workflow_manager_tool'
+require 'shared_tools'
+require 'shared_tools/tools/workflow_manager_tool'