shared_tools 0.3.1 → 0.4.1

data/lib/shared_tools/tools/current_date_time_tool.rb

@@ -1,48 +1,32 @@
 # frozen_string_literal: true
 
-require 'ruby_llm/tool'
 require 'time'
+require_relative '../../shared_tools'
 
 module SharedTools
   module Tools
-    # A tool that returns the current date, time, and timezone information.
-    # Useful for AI assistants that need to know the current time context.
+    # Returns the current date, time, and timezone from the local system.
     #
     # @example
     #   tool = SharedTools::Tools::CurrentDateTimeTool.new
-    #   result = tool.execute
-    #   puts result[:date]      # "2025-12-17"
-    #   puts result[:time]      # "13:45:30"
-    #   puts result[:timezone]  # "America/Chicago"
-    class CurrentDateTimeTool < RubyLLM::Tool
-      def self.name = 'current_date_time'
+    #   tool.execute                    # full output
+    #   tool.execute(format: 'date')    # date fields only
+    class CurrentDateTimeTool < ::RubyLLM::Tool
+      def self.name = 'current_date_time_tool'
 
-      description <<~'DESCRIPTION'
-        Returns the current date, time, and timezone information from the system.
-        This tool provides accurate temporal context for AI assistants that need
-        to reason about time-sensitive information or schedule-related queries.
+      description <<~DESC
+        Returns the current date, time, timezone, and calendar metadata from the system clock.
 
-        The tool returns:
-        - Current date in ISO 8601 format (YYYY-MM-DD)
-        - Current time in 24-hour format (HH:MM:SS)
-        - Current timezone name and UTC offset
-        - Unix timestamp for precise time calculations
-        - Day of week and week number for scheduling context
-
-        Example usage:
-          tool = SharedTools::Tools::CurrentDateTimeTool.new
-          result = tool.execute
-          puts "Today is #{result[:day_of_week]}, #{result[:date]}"
-          puts "Current time: #{result[:time]} #{result[:timezone]}"
-      DESCRIPTION
+        Supported formats:
+        - 'full'    (default) — all fields: date, time, timezone, ISO 8601, unix timestamp, DST flag
+        - 'date'    — year, month, day, day_of_week, week_of_year, quarter, ordinal_day
+        - 'time'    — hour, minute, second, timezone, utc_offset
+        - 'iso8601' — iso8601, iso8601_utc, unix_timestamp
+      DESC
 
       params do
-        string :format, description: <<~DESC.strip, required: false
-          Output format preference. Options:
-          - 'full' (default): Returns all date/time information
-          - 'date_only': Returns only date-related fields
-          - 'time_only': Returns only time-related fields
-          - 'iso8601': Returns a single ISO 8601 formatted datetime string
+        string :format, required: false, description: <<~DESC.strip
+          Output format. Options: 'full' (default), 'date', 'time', 'iso8601'.
         DESC
       end
 
@@ -51,103 +35,53 @@ module SharedTools
         @logger = logger || RubyLLM.logger
       end
 
-      # Execute the date/time query
-      #
-      # @param format [String] Output format ('full', 'date_only', 'time_only', 'iso8601')
-      # @return [Hash] Current date/time information
+      # @param format [String] output format
+      # @return [Hash] date/time information
       def execute(format: 'full')
-        @logger.info("DateTimeTool#execute format=#{format.inspect}")
+        @logger.info("CurrentDateTimeTool#execute format=#{format}")
 
         now = Time.now
-
-        case format.to_s.downcase
-        when 'date_only'
-          date_only_response(now)
-        when 'time_only'
-          time_only_response(now)
-        when 'iso8601'
-          iso8601_response(now)
-        else
-          full_response(now)
-        end
-      end
-
-      private
-
-      # Full response with all date/time information
-      def full_response(now)
-        {
-          success:       true,
-          date:          now.strftime('%Y-%m-%d'),
-          time:          now.strftime('%H:%M:%S'),
-          datetime:      now.iso8601,
-          timezone:      now.zone,
-          timezone_name: timezone_name(now),
-          utc_offset:    formatted_utc_offset(now),
-          unix_timestamp: now.to_i,
-          day_of_week:   now.strftime('%A'),
-          day_of_year:   now.yday,
-          week_number:   now.strftime('%V').to_i,
-          is_dst:        now.dst?,
-          quarter:       ((now.month - 1) / 3) + 1
+        utc = now.utc
+
+        date_info = {
+          year:            now.year,
+          month:           now.month,
+          day:             now.day,
+          day_of_week:     now.strftime('%A'),
+          day_of_week_num: now.wday,
+          week_of_year:    now.strftime('%U').to_i,
+          quarter:         ((now.month - 1) / 3) + 1,
+          ordinal_day:     now.yday
         }
-      end
 
-      # Date-only response
-      def date_only_response(now)
-        {
-          success:     true,
-          date:        now.strftime('%Y-%m-%d'),
-          year:        now.year,
-          month:       now.month,
-          month_name:  now.strftime('%B'),
-          day:         now.day,
-          day_of_week: now.strftime('%A'),
-          day_of_year: now.yday,
-          week_number: now.strftime('%V').to_i,
-          quarter:     ((now.month - 1) / 3) + 1
+        time_info = {
+          hour:             now.hour,
+          minute:           now.min,
+          second:           now.sec,
+          timezone:         now.zone,
+          utc_offset:       now.strftime('%z'),
+          utc_offset_hours: (now.utc_offset / 3600.0).round(2)
         }
-      end
 
-      # Time-only response
-      def time_only_response(now)
-        {
-          success:        true,
-          time:           now.strftime('%H:%M:%S'),
-          time_12h:       now.strftime('%I:%M:%S %p'),
-          hour:           now.hour,
-          minute:         now.min,
-          second:         now.sec,
-          timezone:       now.zone,
-          timezone_name:  timezone_name(now),
-          utc_offset:     formatted_utc_offset(now),
-          unix_timestamp: now.to_i,
-          is_dst:         now.dst?
+        iso_info = {
+          iso8601:       now.iso8601,
+          iso8601_utc:   utc.iso8601,
+          unix_timestamp: now.to_i
         }
-      end
-
-      # ISO 8601 formatted response
-      def iso8601_response(now)
-        {
-          success:  true,
-          datetime: now.iso8601,
-          utc:      now.utc.iso8601
-        }
-      end
-
-      # Get the IANA timezone name if available
-      def timezone_name(time)
-        # Try to get IANA timezone from TZ environment variable
-        ENV['TZ'] || time.zone
-      end
 
-      # Format UTC offset as "+HH:MM" or "-HH:MM"
-      def formatted_utc_offset(time)
-        offset_seconds = time.utc_offset
-        sign = offset_seconds >= 0 ? '+' : '-'
-        hours, remainder = offset_seconds.abs.divmod(3600)
-        minutes = remainder / 60
-        format('%s%02d:%02d', sign, hours, minutes)
+        case format.to_s.downcase
+        when 'date'
+          { success: true }.merge(date_info)
+        when 'time'
+          { success: true }.merge(time_info)
+        when 'iso8601'
+          { success: true }.merge(iso_info)
+        else
+          { success: true, dst: now.dst? }
+            .merge(date_info)
+            .merge(time_info)
+            .merge(iso_info)
+        end
       end
     end
   end

data/lib/shared_tools/tools/data_science_kit.rb

@@ -28,13 +28,22 @@ module SharedTools
           Each analysis type requires specific data formats and optional parameters.
         DESC
 
-        string :data_source, description: <<~DESC.strip, required: true
+        string :data_source, description: <<~DESC.strip, required: false
           Data source specification for analysis. Can be:
           - File path: Relative or absolute path to CSV, JSON, Excel, or Parquet files
           - Database query: SQL SELECT statement for database-sourced data
           - API endpoint: HTTP URL for REST API data sources
           The tool automatically detects the format and applies appropriate parsing.
           Examples: './sales_data.csv', 'SELECT * FROM transactions', 'https://api.company.com/data'
+          Either data_source or data must be provided.
+        DESC
+
+        string :data, description: <<~DESC.strip, required: false
+          Inline data to analyse, provided directly as a JSON string. Accepted formats:
+          - Array of hashes: '[{"month":"Jan","value":42},{"month":"Feb","value":45}]'
+          - Pipe-delimited table string: "Col A | Col B\n1 | 2\n3 | 4"
+          - Comma-separated numbers (single series): "42,45,51,48,55" — parsed as [{value: n}]
+          Either data or data_source must be provided.
         DESC
 
         object :parameters, description: <<~DESC.strip, required: false do
@@ -82,11 +91,18 @@ module SharedTools
         @logger = logger || RubyLLM.logger
       end
 
-      def execute(analysis_type:, data_source:, **parameters)
+      def execute(analysis_type:, data_source: nil, data: nil, **parameters)
         analysis_start = Time.now
 
         begin
-          @logger.info("DataScienceKit#execute analysis_type=#{analysis_type} data_source=#{data_source}")
+          if data_source.nil? && data.nil?
+            return {
+              success: false,
+              error: "Either data_source or data must be provided."
+            }
+          end
+
+          @logger.info("DataScienceKit#execute analysis_type=#{analysis_type}")
 
           # Validate analysis type
           unless VALID_ANALYSIS_TYPES.include?(analysis_type)
@@ -99,21 +115,21 @@ module SharedTools
           end
 
           # Load and validate data
-          data = load_data(data_source)
-          validate_data_for_analysis(data, analysis_type, parameters)
+          loaded_data = data ? parse_inline_data(data) : load_data(data_source)
+          validate_data_for_analysis(loaded_data, analysis_type, parameters)
 
           # Perform analysis
           result = case analysis_type
           when "statistical_summary"
-            generate_statistical_summary(data, parameters)
+            generate_statistical_summary(loaded_data, parameters)
           when "correlation_analysis"
-            perform_correlation_analysis(data, parameters)
+            perform_correlation_analysis(loaded_data, parameters)
           when "time_series"
-            analyze_time_series(data, parameters)
+            analyze_time_series(loaded_data, parameters)
           when "clustering"
-            perform_clustering(data, parameters)
+            perform_clustering(loaded_data, parameters)
           when "prediction"
-            generate_predictions(data, parameters)
+            generate_predictions(loaded_data, parameters)
           end
 
           analysis_duration = (Time.now - analysis_start).round(3)
@@ -123,7 +139,7 @@ module SharedTools
             success: true,
             analysis_type: analysis_type,
             result: result,
-            data_summary: summarize_data(data),
+            data_summary: summarize_data(loaded_data),
             analyzed_at: Time.now.iso8601,
             duration_seconds: analysis_duration
           }
@@ -133,8 +149,7 @@ module SharedTools
             success: false,
             error: e.message,
             error_type: e.class.name,
-            analysis_type: analysis_type,
-            data_source: data_source
+            analysis_type: analysis_type
           }
         end
       end
@@ -189,6 +204,41 @@ module SharedTools
         end
       end
 
+      def parse_inline_data(raw)
+        raw = raw.strip
+        # JSON array or object
+        if raw.start_with?('{', '[')
+          begin
+            return JSON.parse(raw)
+          rescue JSON::ParserError
+          end
+        end
+        lines = raw.lines.map(&:strip).reject(&:empty?)
+        # Pipe-delimited table
+        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 header row
+        if lines.size > 1 && lines.first.include?(',') && lines.first.match?(/[a-zA-Z]/)
+          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
+        # Comma-separated numbers — single series
+        if lines.size == 1 && lines.first.match?(/^[\d.,\s]+$/)
+          return lines.first.split(',').map { |v| { "value" => v.strip.to_f } }
+        end
+        # Plain lines
+        lines.map { |l| { "value" => l } }
+      end
+
       # Generate sample data for testing
       def generate_sample_data(size = 30)
         (1..size).map do |i|