mcp-datetime-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6de1db88b3a1ab058beed308b8f6f5dc13182e21bd1583dddab47cd3163bf6b5
+  data.tar.gz: f1e050574dc6efb282a8855ecd75122f981a2996c9c7c8614a96169298abdd3c
+SHA512:
+  metadata.gz: 7691d9741f8f531497fb0a910766bb4ce138724af591b3e55dada6acd144e1475899f8aba30d4ece79b842093db797c5f2bbe314e90cc21f7b4bfba611e82f3a
+  data.tar.gz: 36890bbf01deff8516c58030897faf98d06bad558b65e6b66ac82103ec21782ad67bcf52b6c94842e61a2363dca8f97be5bbc4a231bcd1133ee9aabed0065f12

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-06-10
+
+### Added
+- Initial release
+- MCP server implementation for datetime tools
+- `get_current_datetime` tool with multiple format options
+- `get_date_info` tool for detailed date information
+- Support for timezone handling
+- Debug logging to `/tmp/mcp_datetime_debug.log` 

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Wolfgang Teuber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE. 

data/README.md

@@ -0,0 +1,322 @@
+# MCP DateTime Ruby
+
+A Ruby implementation of an MCP (Model Context Protocol) server that provides datetime tools for AI assistants. This server enables AI assistants to get current date/time information and detailed date information in various formats.
+
+## Features
+
+- Get current date and time in multiple formats (ISO, human-readable, Unix timestamp, etc.)
+- Support for timezone conversions
+- Detailed date information (weekday, quarter, leap year status, etc.)
+- Full MCP protocol compliance
+- Automatic executable installation via RubyGems plugin
+
+## Requirements
+
+- Ruby 3.1.0 or higher
+- Bundler
+
+## Installation
+
+### From RubyGems (Once Published)
+
+```bash
+gem install mcp-datetime-ruby
+```
+
+The gem will automatically install an executable at `~/bin/mcp-datetime-ruby` during installation.
+
+### Local Installation (Development)
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/wteuber/mcp-datetime-ruby.git
+   cd mcp-datetime-ruby
+   ```
+
+2. **Install dependencies**:
+   ```bash
+   bundle install
+   ```
+
+3. **Build and install the gem locally**:
+   ```bash
+   gem build mcp-datetime-ruby.gemspec
+   gem install ./mcp-datetime-ruby-0.1.0.gem
+   ```
+
+   This will automatically create the executable at `~/bin/mcp-datetime-ruby`.
+
+4. **Or run directly without installing**:
+   ```bash
+   # Run directly from the repository
+   ./bin/mcp-datetime-ruby
+   
+   # Or with bundle exec
+   bundle exec ruby bin/mcp-datetime-ruby
+   ```
+
+### Verifying Installation
+
+After installation, verify the executable is available:
+
+```bash
+# Check if the executable exists
+which mcp-datetime-ruby
+
+# Or if ~/bin is not in your PATH
+ls ~/bin/mcp-datetime-ruby
+```
+
+## Configuration
+
+### Adding to Cursor
+
+To use this MCP server with Cursor:
+
+1. **Open your MCP configuration file**:
+   ```bash
+   # Create the file if it doesn't exist
+   touch ~/.cursor/mcp.json
+   ```
+
+2. **Add the datetime server configuration**:
+
+   If `~/bin` is in your PATH:
+   ```json
+   {
+     "mcpServers": {
+       "datetime": {
+         "command": "mcp-datetime-ruby"
+       }
+     }
+   }
+   ```
+
+   If you need to use the full path:
+   ```json
+   {
+     "mcpServers": {
+       "datetime": {
+         "command": "/Users/yourusername/bin/mcp-datetime-ruby"
+       }
+     }
+   }
+   ```
+
+   If running from the repository directly:
+   ```json
+   {
+     "mcpServers": {
+       "datetime": {
+         "command": "/path/to/mcp-datetime-ruby/bin/mcp-datetime-ruby"
+       }
+     }
+   }
+   ```
+
+3. **If you have existing MCP servers**, add to the existing configuration:
+   ```json
+   {
+     "mcpServers": {
+       "existing-server": {
+         "command": "existing-command"
+       },
+       "datetime": {
+         "command": "mcp-datetime-ruby"
+       }
+     }
+   }
+   ```
+
+4. **Restart Cursor** for the changes to take effect.
+
+5. **Verify the server is working** by asking the AI to "get the current time" or "what's today's date".
+
+## Available Tools
+
+### `get_current_datetime`
+
+Get the current date and time in various formats.
+
+**Parameters:**
+- `format` (optional): Output format
+  - `iso` (default): ISO 8601 format (e.g., "2024-01-15T14:30:45-05:00")
+  - `human`: Human-readable format (e.g., "January 15, 2024 at 02:30 PM")
+  - `date_only`: Date only (e.g., "2024-01-15")
+  - `time_only`: Time only (e.g., "14:30:45")
+  - `unix`: Unix timestamp (e.g., "1705342245")
+- `timezone` (optional): IANA timezone name (e.g., "America/New_York", "Europe/London", "Asia/Tokyo")
+
+**Example Response:**
+```json
+{
+  "datetime": "2024-01-15T14:30:45-05:00",
+  "timestamp": 1705342245.123456,
+  "year": 2024,
+  "month": 1,
+  "day": 15,
+  "hour": 14,
+  "minute": 30,
+  "second": 45,
+  "weekday": "Monday",
+  "timezone": "EST"
+}
+```
+
+### `get_date_info`
+
+Get detailed information about the current date.
+
+**Parameters:** None
+
+**Example Response:**
+```json
+{
+  "date": "2024-01-15",
+  "year": 2024,
+  "month": 1,
+  "month_name": "January",
+  "day": 15,
+  "weekday": "Monday",
+  "weekday_number": 1,
+  "day_of_year": 15,
+  "week_of_year": 3,
+  "quarter": 1,
+  "is_weekend": false,
+  "is_leap_year": true,
+  "days_in_month": 31,
+  "timezone": "EST"
+}
+```
+
+## Development
+
+### Setup
+
+After cloning the repository:
+
+```bash
+# Install dependencies
+bundle install
+
+# Run tests to verify everything is working
+bundle exec rake test
+```
+
+### Code Style
+
+This project uses RuboCop for code style enforcement. Run RuboCop to check for style violations:
+
+```bash
+# Check for style violations
+bundle exec rubocop
+
+# Auto-correct correctable violations
+bundle exec rubocop -a
+
+# Auto-correct with more aggressive corrections
+bundle exec rubocop -A
+```
+
+The project includes a `.rubocop.yml` configuration file that customizes the rules for this codebase.
+
+### Running Tests
+
+The gem includes comprehensive tests using Minitest:
+
+```bash
+# Run unit tests only (default)
+bundle exec rake test
+
+# Run integration tests only
+bundle exec rake integration
+
+# Run all tests (unit + integration)
+bundle exec rake test_all
+
+# Run tests with verbose output
+bundle exec rake test TESTOPTS="--verbose"
+
+# Run a specific test file
+bundle exec ruby -Ilib:test test/mcp/datetime/server_test.rb
+```
+
+The test suite includes:
+- Unit tests for all MCP protocol methods
+- Tests for each datetime format and timezone handling
+- Edge case and error handling tests
+- RubyGems plugin tests
+- Integration tests for full server communication
+
+### Building the Gem
+
+```bash
+# Build the gem
+gem build mcp-datetime-ruby.gemspec
+
+# Install locally for testing
+gem install ./mcp-datetime-ruby-0.1.0.gem
+```
+
+### Debugging
+
+The server logs debug information to `/tmp/mcp_datetime_debug.log`. You can tail this file to see server activity:
+
+```bash
+tail -f /tmp/mcp_datetime_debug.log
+```
+
+## Uninstalling
+
+### Uninstall the Gem
+
+```bash
+# Uninstall the gem (this will also remove the executable from ~/bin)
+gem uninstall mcp-datetime-ruby
+
+# If multiple versions are installed
+gem uninstall mcp-datetime-ruby --all
+```
+
+### Remove from Cursor Configuration
+
+Remove the datetime server entry from `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    // Remove this entire "datetime" section
+    "datetime": {
+      "command": "mcp-datetime-ruby"
+    }
+  }
+}
+```
+
+### Clean Up Development Files
+
+If you cloned the repository:
+
+```bash
+# Remove the cloned repository
+rm -rf /path/to/mcp-datetime-ruby
+
+# Remove any locally built gem files
+rm mcp-datetime-ruby-*.gem
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wteuber/mcp-datetime-ruby.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/my-new-feature`)
+3. Write tests for your changes
+4. Make your changes and ensure all tests pass
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin feature/my-new-feature`)
+7. Create a new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/mcp-datetime-ruby

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'mcp', 'datetime'))
+
+# Run the MCP DateTime server
+server = MCP::DateTime::Server.new
+server.run

data/lib/mcp/datetime/server.rb

@@ -0,0 +1,294 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative 'tools'
+
+module MCP
+  module DateTime
+    # MCP DateTime Server implementation
+    # Provides datetime tools via the Model Context Protocol
+    class Server
+      include Tools
+
+      LOG_FILE = '/tmp/mcp_datetime_debug.log'
+
+      def initialize
+        @server_info = {
+          name: 'mcp-datetime-ruby',
+          version: VERSION
+        }
+        setup_io_streams
+        setup_signal_handlers
+        log_startup_info
+      end
+
+      def run
+        warn '[MCP::DateTime] Starting server...'
+        process_requests
+        warn '[MCP::DateTime] Server stopped'
+      end
+
+      private
+
+      def setup_io_streams
+        $stderr.sync = true
+        $stdout.sync = true
+      end
+
+      def setup_signal_handlers
+        Signal.trap('INT') { exit(0) }
+        Signal.trap('TERM') { exit(0) }
+      end
+
+      def log_startup_info
+        log("Starting MCP DateTime server (Ruby #{RUBY_VERSION})")
+        log("Script location: #{__FILE__}")
+        log("Working directory: #{Dir.pwd}")
+        log("Environment: #{ENV.to_h}")
+      end
+
+      def process_requests
+        loop do
+          line = read_request
+          next unless line
+
+          handle_request_line(line)
+        rescue JSON::ParserError => e
+          handle_parse_error(e)
+        rescue Interrupt
+          handle_interrupt
+        rescue StandardError => e
+          handle_error(e)
+        end
+      end
+
+      def read_request
+        line = $stdin.gets
+        if line.nil?
+          handle_eof
+          return nil
+        end
+        line.strip.empty? ? nil : line
+      end
+
+      def handle_eof
+        log('EOF received, shutting down gracefully')
+        warn '[MCP::DateTime] EOF received, shutting down gracefully'
+        exit(0)
+      end
+
+      def handle_request_line(line)
+        request = JSON.parse(line.strip)
+        log("Received request: #{request['method']}")
+        warn "[MCP::DateTime] Received request: #{request['method']}"
+
+        response = handle_request(request)
+        send_response(request, response)
+      end
+
+      def send_response(request, response)
+        return unless request['id'] && response
+
+        $stdout.puts(JSON.generate(response))
+        $stdout.flush
+      end
+
+      def handle_parse_error(error)
+        log("Parse error: #{error.message}")
+        error_response = build_error_response(-32_700, "Parse error: #{error.message}")
+        $stdout.puts(JSON.generate(error_response))
+        $stdout.flush
+      end
+
+      def handle_interrupt
+        log('Interrupted, shutting down')
+        warn '[MCP::DateTime] Interrupted, shutting down'
+        exit(0)
+      end
+
+      def handle_error(error)
+        log("Error: #{error.message}")
+        log(error.backtrace.join("\n"))
+        warn "[MCP::DateTime] Error: #{error.message}"
+        warn error.backtrace.join("\n")
+      end
+
+      def log(message)
+        File.open(LOG_FILE, 'a') do |f|
+          f.puts "[#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] #{message}"
+        end
+      rescue StandardError => e
+        warn "Failed to write to log: #{e.message}"
+      end
+
+      def handle_request(request)
+        method = request['method']
+        params = request['params'] || {}
+        id = request['id']
+
+        return handle_notification(method) if notification?(method)
+
+        result = dispatch_method(method, params)
+        build_success_response(result, id)
+      rescue StandardError => e
+        build_error_response(-32_603, e.message, id)
+      end
+
+      def notification?(method)
+        method == 'notifications/initialized'
+      end
+
+      def handle_notification(method)
+        return unless method == 'notifications/initialized'
+
+        log('Client initialized notification received')
+        warn '[MCP::DateTime] Client initialized notification received'
+        nil
+      end
+
+      def dispatch_method(method, params)
+        case method
+        when 'initialize'
+          handle_initialize(params)
+        when 'tools/list'
+          handle_list_tools
+        when 'tools/call'
+          handle_call_tool(params)
+        else
+          raise "Unknown method: #{method}"
+        end
+      end
+
+      def build_success_response(result, id)
+        {
+          jsonrpc: '2.0',
+          result:,
+          id:
+        }
+      end
+
+      def build_error_response(code, message, id = nil)
+        {
+          jsonrpc: '2.0',
+          error: {
+            code:,
+            message:
+          },
+          id:
+        }
+      end
+
+      def handle_initialize(_params)
+        {
+          protocolVersion: '2024-11-05',
+          capabilities: {
+            tools: {
+              listChanged: false
+            }
+          },
+          serverInfo: @server_info
+        }
+      end
+
+      def handle_list_tools
+        {
+          tools: [
+            datetime_tool_definition,
+            date_info_tool_definition
+          ]
+        }
+      end
+
+      def handle_call_tool(params)
+        tool_name = params['name']
+        arguments = params['arguments'] || {}
+
+        case tool_name
+        when 'get_current_datetime'
+          current_datetime(arguments)
+        when 'get_date_info'
+          date_info
+        else
+          raise "Unknown tool: #{tool_name}"
+        end
+      end
+
+      def current_datetime(arguments)
+        format_type = arguments['format'] || 'iso'
+        timezone = arguments['timezone']
+
+        now = get_time_in_timezone(timezone)
+        formatted = format_datetime(now, format_type)
+
+        build_content_response(datetime_data(now, formatted))
+      end
+
+      def get_time_in_timezone(timezone)
+        ENV['TZ'] = timezone if timezone
+        Time.now
+      end
+
+      def format_datetime(time, format_type)
+        case format_type
+        when 'human' then time.strftime('%B %d, %Y at %I:%M %p')
+        when 'date_only' then time.strftime('%Y-%m-%d')
+        when 'time_only' then time.strftime('%H:%M:%S')
+        when 'unix' then time.to_i.to_s
+        else time.iso8601
+        end
+      end
+
+      def datetime_data(time, formatted)
+        {
+          datetime: formatted,
+          timestamp: time.to_f,
+          year: time.year,
+          month: time.month,
+          day: time.day,
+          hour: time.hour,
+          minute: time.min,
+          second: time.sec,
+          weekday: time.strftime('%A'),
+          timezone: time.zone
+        }
+      end
+
+      def date_info
+        now = Time.now
+        today = Date.today
+
+        build_content_response(date_info_data(today, now))
+      end
+
+      def date_info_data(date, time)
+        {
+          date: date.to_s,
+          year: date.year,
+          month: date.month,
+          month_name: date.strftime('%B'),
+          day: date.day,
+          weekday: date.strftime('%A'),
+          weekday_number: date.wday,
+          day_of_year: date.yday,
+          week_of_year: date.cweek,
+          quarter: ((date.month - 1) / 3) + 1,
+          is_weekend: [0, 6].include?(date.wday),
+          is_leap_year: date.leap?,
+          days_in_month: Date.new(date.year, date.month, -1).day,
+          timezone: time.zone
+        }
+      end
+
+      def build_content_response(data)
+        {
+          content: [
+            {
+              type: 'text',
+              text: JSON.pretty_generate(data)
+            }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/mcp/datetime/tools.rb

@@ -0,0 +1,41 @@
+# typed: false
+# frozen_string_literal: true
+
+module MCP
+  module DateTime
+    # Tool definitions for the MCP DateTime server
+    module Tools
+      def datetime_tool_definition
+        {
+          name: 'get_current_datetime',
+          description: 'Get the current date and time',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              format: {
+                type: 'string',
+                description: 'Optional datetime format',
+                enum: %w[iso human date_only time_only unix]
+              },
+              timezone: {
+                type: 'string',
+                description: 'Optional timezone (e.g., "America/New_York", "Europe/London")'
+              }
+            }
+          }
+        }
+      end
+
+      def date_info_tool_definition
+        {
+          name: 'get_date_info',
+          description: 'Get detailed information about the current date',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      end
+    end
+  end
+end

data/lib/mcp/datetime/version.rb

@@ -0,0 +1,8 @@
+# typed: false
+# frozen_string_literal: true
+
+module MCP
+  module DateTime
+    VERSION = '0.1.0'
+  end
+end

data/lib/mcp/datetime.rb

@@ -0,0 +1,14 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require 'date'
+require_relative 'datetime/version'
+require_relative 'datetime/server'
+
+module MCP
+  module DateTime
+    class Error < StandardError; end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'fileutils'
+
+# This plugin creates an executable file after gem installation
+Gem.post_install do |installer|
+  next unless installer.spec.name == 'mcp-datetime-ruby'
+
+  # Get the gem's installation directory
+  gem_dir = installer.spec.gem_dir
+
+  # Create the executable content with the proper paths
+  executable_content = <<~RUBY
+    #!#{Gem.ruby}
+    # frozen_string_literal: true
+
+    # Add the gem's lib directory to the load path
+    $LOAD_PATH.unshift("#{gem_dir}/lib")
+
+    require 'json'
+    require 'date'
+    require 'time'
+    require 'mcp/datetime/version'
+    require 'mcp/datetime/server'
+
+    # Run the server
+    MCP::DateTime::Server.new.run
+  RUBY
+
+  # Determine the bin directory in user's home
+  home_bin_dir = File.expand_path('~/bin')
+  executable_path = File.join(home_bin_dir, 'mcp-datetime-ruby')
+
+  # Create the bin directory if it doesn't exist
+  FileUtils.mkdir_p(home_bin_dir) unless File.directory?(home_bin_dir)
+
+  # Check if executable already exists
+  if File.exist?(executable_path)
+    puts "Updating existing executable: #{executable_path}"
+  else
+    puts "Creating new executable: #{executable_path}"
+  end
+
+  # Write the executable file
+  File.write(executable_path, executable_content)
+
+  # Make it executable
+  File.chmod(0o755, executable_path)
+
+  puts "Executable ready at: #{executable_path}"
+  puts 'Make sure ~/bin is in your PATH to use the executable' unless ENV['PATH'].include?(home_bin_dir)
+end
+
+# Clean up the executable on uninstall
+Gem.pre_uninstall do |uninstaller|
+  next unless uninstaller.spec.name == 'mcp-datetime-ruby'
+
+  executable_path = File.expand_path('~/bin/mcp-datetime-ruby')
+
+  if File.exist?(executable_path)
+    File.delete(executable_path)
+    puts "Removed executable: #{executable_path}"
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: mcp-datetime-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wolfgang Teuber
+bindir: bin
+cert_chain: []
+date: 2025-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A Ruby implementation of an MCP server that provides datetime tools for
+  AI assistants
+email:
+- knugie@gmx.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/mcp-datetime-ruby
+- lib/mcp/datetime.rb
+- lib/mcp/datetime/server.rb
+- lib/mcp/datetime/tools.rb
+- lib/mcp/datetime/version.rb
+- lib/rubygems_plugin.rb
+homepage: https://github.com/wteuber/mcp-datetime-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wteuber/mcp-datetime-ruby
+  source_code_uri: https://github.com/wteuber/mcp-datetime-ruby
+  changelog_uri: https://github.com/wteuber/mcp-datetime-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: MCP (Model Context Protocol) DateTime Server for Ruby
+test_files: []