shared_tools 0.3.1 → 0.4.2

data/lib/shared_tools/tools/composite_analysis_tool.rb

@@ -18,12 +18,22 @@ module SharedTools
       DESCRIPTION
 
       params do
-        string :data_source, description: <<~DESC.strip, required: true
+        string :data_source, description: <<~DESC.strip, required: false
           Primary data source to analyze. Can be either a local file path or a web URL.
           For files: Use relative or absolute paths to CSV, JSON, XML, or text files.
           For URLs: Use complete HTTP/HTTPS URLs to accessible data endpoints or web pages.
           The tool automatically detects the source type and uses appropriate fetching methods.
           Examples: './data/sales.csv', '/home/user/data.json', 'https://api.example.com/data'
+          Either data_source or data must be provided.
+        DESC
+
+        string :data, description: <<~DESC.strip, required: false
+          Inline data to analyze, provided directly as a string. Accepts:
+          - Pipe-delimited markdown tables (header row with | separators)
+          - CSV text (comma-separated rows, first row treated as headers)
+          - JSON text (object or array)
+          - Plain text (one item per line)
+          Either data or data_source must be provided.
         DESC
 
         string :analysis_type, description: <<~DESC.strip, required: false
@@ -48,16 +58,23 @@ module SharedTools
         @logger = logger || RubyLLM.logger
       end
 
-      def execute(data_source:, analysis_type: "standard", **options)
+      def execute(data_source: nil, data: nil, analysis_type: "standard", **options)
+        if data_source.nil? && data.nil?
+          return { success: false, error: "Either data_source or data must be provided." }
+        end
+
         results = {}
         analysis_start = Time.now
 
         begin
-          @logger.info("CompositeAnalysisTool#execute data_source=#{data_source} analysis_type=#{analysis_type}")
+          @logger.info("CompositeAnalysisTool#execute data_source=#{data_source.inspect} analysis_type=#{analysis_type}")
 
           # Step 1: Fetch data using appropriate method
           @logger.debug("Fetching data from source...")
-          if data_source.start_with?('http://', 'https://')
+          if data
+            results[:data] = parse_inline_data(data)
+            results[:source_type] = 'inline'
+          elsif data_source.start_with?('http://', 'https://')
             results[:data] = fetch_web_data(data_source)
             results[:source_type] = 'web'
           else
@@ -116,6 +133,45 @@ module SharedTools
 
       private
 
+      # Parse inline data string into a Ruby structure.
+      # Handles pipe-delimited markdown tables, CSV, JSON, and plain text.
+      def parse_inline_data(raw)
+        raw = raw.strip
+
+        # JSON
+        if raw.start_with?('{', '[')
+          begin
+            return JSON.parse(raw)
+          rescue JSON::ParserError
+            # fall through
+          end
+        end
+
+        lines = raw.lines.map(&:strip).reject(&:empty?)
+
+        # Pipe-delimited markdown table: "Col A | Col B | Col C"
+        if lines.first&.include?('|')
+          headers = lines.first.split('|').map(&:strip).reject(&:empty?)
+          data_lines = lines.drop(1).reject { |l| l.match?(/^\|?[-:\s|]+$/) }
+          return data_lines.map do |line|
+            values = line.split('|').map(&:strip).reject(&:empty?)
+            headers.zip(values).to_h
+          end
+        end
+
+        # CSV (comma-separated)
+        if lines.first&.include?(',')
+          headers = lines.first.split(',').map(&:strip)
+          return lines.drop(1).map do |line|
+            values = line.split(',').map(&:strip)
+            headers.zip(values).to_h
+          end
+        end
+
+        # Plain text — return as array of lines
+        lines
+      end
+
       # Fetch data from web URL
       def fetch_web_data(url)
         @logger.debug("Fetching web data from: #{url}")

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

@@ -21,7 +21,15 @@ module SharedTools
         # @param text [String]
         # @param duration [Integer]
         def hold_key(text:, duration:)
-          raise NotImplementedError, "#{self.class.name}##{__method__} undefined"
+          options = text.to_s.split('+')
+          key     = options.pop
+          mask    = options.reduce(0) { |m, opt| m | Library::CoreGraphics::EventFlags.find(opt) }
+
+          @keyboard.key_down(key, mask: mask)
+          Kernel.sleep(duration.to_f)
+          @keyboard.key_up(key, mask: mask)
+
+          { success: true, key: text, duration: duration }
         end
 
         # @return [Hash<{ x: Integer, y: Integer }>]
@@ -86,10 +94,35 @@ module SharedTools
           @keyboard.type(text)
         end
 
-        # @param amount [Integer]
-        # @param direction [String] e.g. "up", "down", "left", "right"
+        # @param amount [Integer]    number of scroll units
+        # @param direction [String] "up", "down", "left", or "right"
         def scroll(amount:, direction:)
-          raise NotImplementedError, "#{self.class.name}##{__method__} undefined"
+          # Attach CGEventCreateScrollWheelEvent2 if not already done
+          unless Library::CoreGraphics.respond_to?(:CGEventCreateScrollWheelEvent2)
+            Library::CoreGraphics.module_eval do
+              attach_function :CGEventCreateScrollWheelEvent2,
+                              [:pointer, :uint32, :uint32, :int32, :int32, :int32],
+                              :pointer
+            end
+          end
+
+          amt = amount.to_i
+          # kCGScrollEventUnitLine = 1; wheel_count = 2 (vertical + horizontal)
+          delta_y, delta_x = case direction.to_s.downcase
+                             when 'up'    then [ amt,  0]
+                             when 'down'  then [-amt,  0]
+                             when 'left'  then [0, -amt]
+                             when 'right' then [0,  amt]
+                             else              [0,    0]
+                             end
+
+          event = Library::CoreGraphics.CGEventCreateScrollWheelEvent2(nil, 1, 2, delta_y, delta_x, 0)
+          Library::CoreGraphics.CGEventPost(
+            Library::CoreGraphics::EventTapLocation::HID_EVENT_TAP, event
+          )
+          Library::CoreGraphics.CFRelease(event)
+
+          { success: true, direction: direction, amount: amt }
         end
 
         # @yield [file]