toggl_track_mcp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df6b591be588f2f4143d0fc77150d81c38f065a86c228fc361d2f621c500d6da
+  data.tar.gz: 68299d7385388f0d403953a0546246df5042cd2a1e3a1578448d3bebec900d27
+SHA512:
+  metadata.gz: 9c561444f0ae8414c1c7283d7043572a5bcce6387170c31f4e1bfb8352184fe8a78207ac280a2be477b9ead1f4ae6276eff366d0c6d32db4c4f3e6bee6f26cd7
+  data.tar.gz: f4bbd2612692459aa6fb9ab379cb08bbc574a1583168711dfa51482fa0977614dcf9a76b7b1adf937b5066cb0f7d51ad1e8537d6e2a173cd342d86b0a2efae8b

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ima1zumi
+
+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,56 @@
+# toggl-track-mcp
+
+An MCP server for Toggl Track.
+
+## Installation
+
+```
+gem install toggl_track_mcp
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem "toggl_track_mcp"
+```
+
+## Setup
+
+Set your Toggl Track API token as the environment variable `TOGGL_API_TOKEN`. You can find it at [Toggl Track Profile](https://track.toggl.com/profile).
+
+`TOGGL_TZ` is the timezone offset (default: `+09:00`).
+
+## Usage
+
+Example configuration for Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "toggl-track": {
+      "command": "toggl-track-mcp",
+      "env": {
+        "TOGGL_API_TOKEN": "your_api_token_here"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| get_current_entry | Get the currently running time entry |
+| get_today_entries | List today's time entries |
+| get_entries_by_date | Get time entries for a specific date |
+| get_daily_summary | Get a daily summary |
+| get_projects | List projects |
+| create_entry | Create a time entry |
+| update_entry | Update a time entry |
+| stop_entry | Stop the running time entry |
+| delete_entry | Delete a time entry |
+
+## License
+
+MIT

data/exe/toggl-track-mcp

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "toggl_track_mcp"
+
+server = MCP::Server.new(
+  name: "toggl-track",
+  version: TogglTrackMcp::VERSION,
+  tools: TogglTrackMcp::TOOLS,
+  server_context: { client: TogglTrackMcp::TogglClient.new },
+)
+
+MCP::Server::Transports::StdioTransport.new(server).open

data/lib/toggl_track_mcp/duration_formatter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "time"
+
+module TogglTrackMcp
+  module DurationFormatter
+    def format_duration_human(seconds)
+      return "0min" if seconds <= 0
+
+      hours = seconds / 3600
+      minutes = (seconds % 3600) / 60
+
+      if hours > 0
+        "#{hours}h#{minutes}min"
+      else
+        "#{minutes}min"
+      end
+    end
+
+    def format_time(time_string, tz:)
+      Time.parse(time_string).getlocal(tz).strftime("%H:%M")
+    end
+
+    def parse_date(date_string, tz:)
+      case date_string
+      when "today", nil
+        today = Time.now.getlocal(tz)
+        Time.new(today.year, today.month, today.day, 0, 0, 0, tz)
+      when "yesterday"
+        yesterday = Time.now.getlocal(tz) - 86400
+        Time.new(yesterday.year, yesterday.month, yesterday.day, 0, 0, 0, tz)
+      else
+        parts = date_string.split("-").map(&:to_i)
+        Time.new(parts[0], parts[1], parts[2], 0, 0, 0, tz)
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/toggl_client.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "time"
+
+module TogglTrackMcp
+  class TogglClient
+    BASE_URL = "https://api.track.toggl.com/api/v9"
+    CREATED_WITH = "toggl-track-mcp"
+
+    attr_reader :tz
+
+    def initialize(api_token = ENV.fetch("TOGGL_API_TOKEN"), tz: ENV.fetch("TOGGL_TZ", "+09:00"))
+      @api_token = api_token
+      @tz = tz
+      @workspace_id = nil
+      @project_map = nil
+    end
+
+    def workspace_id
+      @workspace_id ||= get("/me").fetch("default_workspace_id")
+    end
+
+    def current_entry
+      get("/me/time_entries/current")
+    end
+
+    def project_map
+      @project_map ||= projects.each_with_object({}) { |p, h| h[p["id"]] = p["name"] }
+    end
+
+    def project_name(project_id)
+      return nil unless project_id
+
+      project_map[project_id]
+    end
+
+    def today_entries
+      today = Time.now.getlocal(@tz)
+      start_of_day = Time.new(today.year, today.month, today.day, 0, 0, 0, @tz)
+      end_of_day = start_of_day + 86400
+      get("/me/time_entries", start_date: start_of_day.iso8601, end_date: end_of_day.iso8601)
+    end
+
+    def entries_by_date(start_date:, end_date:)
+      get("/me/time_entries", start_date: start_date, end_date: end_date)
+    end
+
+    def create_entry(description:, project_id: nil, tags: nil, start: nil, duration: -1)
+      body = {
+        description: description,
+        workspace_id: workspace_id,
+        start: start || Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        duration: duration,
+        created_with: CREATED_WITH,
+      }
+      body[:project_id] = project_id if project_id
+      body[:tags] = tags if tags
+
+      post("/workspaces/#{workspace_id}/time_entries", body)
+    end
+
+    def update_entry(time_entry_id:, **params)
+      body = {}
+      body[:description] = params[:description] if params.key?(:description)
+      body[:project_id] = params[:project_id] if params.key?(:project_id)
+      body[:tags] = params[:tags] if params.key?(:tags)
+      body[:start] = params[:start] if params.key?(:start)
+      body[:stop] = params[:stop] if params.key?(:stop)
+
+      put("/workspaces/#{workspace_id}/time_entries/#{time_entry_id}", body)
+    end
+
+    def delete_entry(time_entry_id:)
+      delete("/workspaces/#{workspace_id}/time_entries/#{time_entry_id}")
+    end
+
+    def stop_entry(time_entry_id:)
+      patch("/workspaces/#{workspace_id}/time_entries/#{time_entry_id}/stop")
+    end
+
+    def projects
+      get("/workspaces/#{workspace_id}/projects")
+    end
+
+    private
+
+    def get(path, params = {})
+      uri = build_uri(path, params)
+      request = Net::HTTP::Get.new(uri)
+      execute(uri, request)
+    end
+
+    def post(path, body)
+      uri = build_uri(path)
+      request = Net::HTTP::Post.new(uri)
+      request.body = JSON.generate(body)
+      request["Content-Type"] = "application/json"
+      execute(uri, request)
+    end
+
+    def put(path, body)
+      uri = build_uri(path)
+      request = Net::HTTP::Put.new(uri)
+      request.body = JSON.generate(body)
+      request["Content-Type"] = "application/json"
+      execute(uri, request)
+    end
+
+    def patch(path, body = nil)
+      uri = build_uri(path)
+      request = Net::HTTP::Patch.new(uri)
+      if body
+        request.body = JSON.generate(body)
+        request["Content-Type"] = "application/json"
+      end
+      execute(uri, request)
+    end
+
+    def delete(path)
+      uri = build_uri(path)
+      request = Net::HTTP::Delete.new(uri)
+      execute(uri, request)
+    end
+
+    def build_uri(path, params = {})
+      uri = URI("#{BASE_URL}#{path}")
+      uri.query = URI.encode_www_form(params) unless params.empty?
+      uri
+    end
+
+    def execute(uri, request)
+      request.basic_auth(@api_token, "api_token")
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPSuccess
+        return nil if response.body.nil? || response.body.empty?
+        JSON.parse(response.body)
+      else
+        raise "Toggl API error: #{response.code} #{response.body}"
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/create_entry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class CreateEntry < MCP::Tool
+      description "Create a new time entry. By default starts a running timer."
+
+      input_schema(
+        properties: {
+          description: {
+            type: "string",
+            description: "What you are working on",
+          },
+          project_id: {
+            type: "integer",
+            description: "Project ID to associate with (use get_projects to find IDs)",
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for the entry (auto-created if they don't exist)",
+          },
+          start: {
+            type: "string",
+            description: "Start time in UTC (e.g. 2026-03-08T09:00:00Z). Defaults to now.",
+          },
+          duration: {
+            type: "integer",
+            description: "Duration in seconds. Use -1 to start a running timer (default). Use positive value for a completed entry.",
+          },
+        },
+        required: ["description"],
+      )
+
+      class << self
+        def call(description:, project_id: nil, tags: nil, start: nil, duration: -1, server_context: nil)
+          client = server_context[:client]
+
+          entry = client.create_entry(
+            description: description,
+            project_id: project_id,
+            tags: tags,
+            start: start,
+            duration: duration,
+          )
+
+          status = duration == -1 ? "Timer started" : "Entry created"
+          text = <<~TEXT.gsub(/^\s*\n/, "").chomp
+            #{status}:
+              Description: #{entry["description"]}
+            #{"  Project ID: #{entry["project_id"]}" if entry["project_id"]}
+            #{"  Tags: #{entry["tags"].join(", ")}" if entry["tags"]&.any?}
+              Start: #{entry["start"]}
+              Entry ID: #{entry["id"]}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/delete_entry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class DeleteEntry < MCP::Tool
+      description "Delete a time entry"
+
+      annotations(
+        destructive_hint: true,
+      )
+
+      input_schema(
+        properties: {
+          time_entry_id: {
+            type: "integer",
+            description: "The ID of the time entry to delete",
+          },
+        },
+        required: ["time_entry_id"],
+      )
+
+      class << self
+        def call(time_entry_id:, server_context: nil)
+          client = server_context[:client]
+          client.delete_entry(time_entry_id: time_entry_id)
+
+          MCP::Tool::Response.new([{ type: "text", text: "Time entry #{time_entry_id} deleted." }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/get_current_entry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class GetCurrentEntry < MCP::Tool
+      extend DurationFormatter
+
+      description "Get the currently running time entry"
+
+      annotations(
+        read_only_hint: true,
+        destructive_hint: false,
+      )
+
+      input_schema(properties: {})
+
+      class << self
+        def call(server_context: nil)
+          client = server_context[:client]
+          entry = client.current_entry
+
+          if entry.nil?
+            return MCP::Tool::Response.new([{ type: "text", text: "No timer is currently running." }])
+          end
+
+          MCP::Tool::Response.new([{ type: "text", text: format_entry(entry, client) }])
+        end
+
+        private
+
+        def format_entry(entry, client)
+          tz = client.tz
+          start_time = Time.parse(entry["start"])
+          elapsed = Time.now.to_i - start_time.to_i
+          project_name = entry["project_id"] ? client.project_name(entry["project_id"]) : nil
+
+          <<~TEXT.gsub(/^\s*\n/, "").chomp
+            Description: #{entry["description"] || "(no description)"}
+            #{"Project: #{project_name}" if project_name}
+            #{"Project ID: #{entry["project_id"]}" if entry["project_id"]}
+            #{"Tags: #{entry["tags"].join(", ")}" if entry["tags"]&.any?}
+            Start: #{start_time.getlocal(tz).strftime("%H:%M")} (#{format_duration_human(elapsed)} elapsed)
+            Entry ID: #{entry["id"]}
+          TEXT
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/get_daily_summary.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class GetDailySummary < MCP::Tool
+      extend DurationFormatter
+
+      description "Get a formatted daily summary of time entries for diary/journal use."
+
+      annotations(
+        read_only_hint: true,
+        destructive_hint: false,
+      )
+
+      input_schema(
+        properties: {
+          date: {
+            type: "string",
+            description: 'Target date (YYYY-MM-DD, "today", or "yesterday"). Defaults to today.',
+          },
+        },
+      )
+
+      class << self
+        def call(date: nil, server_context: nil)
+          client = server_context[:client]
+          tz = client.tz
+
+          start_of_day = parse_date(date, tz: tz)
+          end_of_day = (start_of_day + 86400).iso8601
+          entries = client.entries_by_date(start_date: start_of_day.iso8601, end_date: end_of_day)
+
+          if entries.nil? || entries.empty?
+            return MCP::Tool::Response.new([{ type: "text", text: "No time entries found." }])
+          end
+
+          sorted = entries.sort_by { |e| e["start"] }
+
+          timeline = build_timeline(sorted, client)
+          project_summary = build_project_summary(sorted, client)
+          total = sorted.sum { |e| entry_duration(e) }
+
+          text = <<~TEXT
+            ## Timeline
+            #{timeline.chomp}
+
+            ## By Project
+            #{project_summary.chomp}
+
+            Total: #{format_duration_human(total)}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+
+        private
+
+        def build_timeline(entries, client)
+          tz = client.tz
+          entries.map do |entry|
+            start_time = format_time(entry["start"], tz: tz)
+            stop_time = entry["stop"] ? format_time(entry["stop"], tz: tz) : "now"
+            duration = entry_duration(entry)
+            description = entry["description"] || "(no description)"
+            project = client.project_name(entry["project_id"])
+            label = project || description
+
+            "#{start_time} - #{stop_time} #{label} (#{format_duration_human(duration)})\n"
+          end.join
+        end
+
+        def build_project_summary(entries, client)
+          by_project = Hash.new(0)
+          entries.each do |entry|
+            name = client.project_name(entry["project_id"]) || entry["description"] || "(no description)"
+            by_project[name] += entry_duration(entry)
+          end
+
+          by_project.sort_by { |_, v| -v }.map do |name, seconds|
+            "#{name}: #{format_duration_human(seconds)}\n"
+          end.join
+        end
+
+        def entry_duration(entry)
+          if entry["duration"] >= 0
+            entry["duration"]
+          else
+            Time.now.to_i - Time.parse(entry["start"]).to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/get_entries_by_date.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class GetEntriesByDate < MCP::Tool
+      extend DurationFormatter
+
+      description "Get time entries by date or date range"
+
+      annotations(
+        read_only_hint: true,
+        destructive_hint: false,
+      )
+
+      input_schema(
+        properties: {
+          date: {
+            type: "string",
+            description: 'YYYY-MM-DD, "today", or "yesterday"',
+          },
+          end_date: {
+            type: "string",
+            description: "Optional end date for range query (YYYY-MM-DD)",
+          },
+        },
+        required: ["date"],
+      )
+
+      class << self
+        def call(date:, end_date: nil, server_context: nil)
+          client = server_context[:client]
+          tz = client.tz
+
+          start_of_day = parse_date(date, tz: tz)
+          end_of_range = end_date ? parse_date(end_date, tz: tz) + 86400 : start_of_day + 86400
+
+          entries = client.entries_by_date(
+            start_date: start_of_day.iso8601,
+            end_date: end_of_range.iso8601,
+          )
+
+          if entries.nil? || entries.empty?
+            return MCP::Tool::Response.new([{ type: "text", text: "No time entries found." }])
+          end
+
+          total_seconds = 0
+          lines = entries.map do |entry|
+            duration = entry["duration"]
+            if duration >= 0
+              total_seconds += duration
+            else
+              duration = Time.now.to_i - Time.parse(entry["start"]).to_i
+              total_seconds += duration
+            end
+
+            project_name = entry["project_id"] ? client.project_name(entry["project_id"]) : nil
+            <<~TEXT.gsub(/^\s*\n/, "").chomp
+                Description: #{entry["description"] || "(no description)"}
+              #{"  Project: #{project_name}" if project_name}
+              #{"  Project ID: #{entry["project_id"]}" if entry["project_id"]}
+              #{"  Tags: #{entry["tags"].join(", ")}" if entry["tags"]&.any?}
+                Start: #{format_time(entry["start"], tz: tz)}
+              #{"  Stop: #{format_time(entry["stop"], tz: tz)}" if entry["stop"]}
+                Duration: #{format_duration_human(duration)}
+              #{"  Running" if entry["duration"] < 0}
+                Entry ID: #{entry["id"]}
+            TEXT
+          end
+
+          text = <<~TEXT.chomp
+            Entries (#{entries.size} total, #{format_duration_human(total_seconds)}):
+
+            #{lines.join("\n\n")}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/get_projects.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class GetProjects < MCP::Tool
+      description "Get all projects in the workspace"
+
+      annotations(
+        read_only_hint: true,
+        destructive_hint: false,
+      )
+
+      input_schema(properties: {})
+
+      class << self
+        def call(server_context: nil)
+          client = server_context[:client]
+          projects = client.projects
+
+          if projects.nil? || projects.empty?
+            return MCP::Tool::Response.new([{ type: "text", text: "No projects found." }])
+          end
+
+          lines = projects.select { |p| p["active"] }.map do |project|
+            <<~TEXT.gsub(/^\s*\n/, "").chomp
+                Name: #{project["name"]}
+                ID: #{project["id"]}
+              #{"  Color: #{project["color"]}" if project["color"]}
+            TEXT
+          end
+
+          text = <<~TEXT.chomp
+            Projects (#{lines.size}):
+
+            #{lines.join("\n\n")}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/get_today_entries.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class GetTodayEntries < MCP::Tool
+      extend DurationFormatter
+
+      description "Get all time entries for today"
+
+      annotations(
+        read_only_hint: true,
+        destructive_hint: false,
+      )
+
+      input_schema(properties: {})
+
+      class << self
+        def call(server_context: nil)
+          client = server_context[:client]
+          entries = client.today_entries
+
+          if entries.nil? || entries.empty?
+            return MCP::Tool::Response.new([{ type: "text", text: "No time entries for today." }])
+          end
+
+          tz = client.tz
+          total_seconds = 0
+          lines = entries.map do |entry|
+            duration = entry["duration"]
+            if duration >= 0
+              total_seconds += duration
+            else
+              duration = Time.now.to_i - Time.parse(entry["start"]).to_i
+              total_seconds += duration
+            end
+
+            project_name = entry["project_id"] ? client.project_name(entry["project_id"]) : nil
+            <<~TEXT.gsub(/^\s*\n/, "").chomp
+                Description: #{entry["description"] || "(no description)"}
+              #{"  Project: #{project_name}" if project_name}
+              #{"  Project ID: #{entry["project_id"]}" if entry["project_id"]}
+              #{"  Tags: #{entry["tags"].join(", ")}" if entry["tags"]&.any?}
+                Start: #{format_time(entry["start"], tz: tz)}
+              #{"  Stop: #{format_time(entry["stop"], tz: tz)}" if entry["stop"]}
+                Duration: #{format_duration_human(duration)}
+              #{"  Running" if entry["duration"] < 0}
+                Entry ID: #{entry["id"]}
+            TEXT
+          end
+
+          text = <<~TEXT.chomp
+            Today's entries (#{entries.size} total, #{format_duration_human(total_seconds)}):
+
+            #{lines.join("\n\n")}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/stop_entry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class StopEntry < MCP::Tool
+      extend DurationFormatter
+
+      description "Stop the currently running timer"
+
+      input_schema(properties: {})
+
+      class << self
+        def call(server_context: nil)
+          client = server_context[:client]
+          current = client.current_entry
+
+          if current.nil?
+            return MCP::Tool::Response.new([{ type: "text", text: "No timer is currently running." }])
+          end
+
+          entry = client.stop_entry(time_entry_id: current["id"])
+
+          tz = client.tz
+          elapsed = Time.now.to_i - Time.parse(entry["start"]).to_i
+          project_name = entry["project_id"] ? client.project_name(entry["project_id"]) : nil
+          text = <<~TEXT.gsub(/^\s*\n/, "").chomp
+            Timer stopped:
+              Description: #{entry["description"] || "(no description)"}
+            #{"  Project: #{project_name}" if project_name}
+            #{"  Project ID: #{entry["project_id"]}" if entry["project_id"]}
+              Start: #{format_time(entry["start"], tz: tz)}
+            #{"  Stop: #{format_time(entry["stop"], tz: tz)}" if entry["stop"]}
+              Duration: #{format_duration_human(elapsed)}
+              Entry ID: #{entry["id"]}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/tools/update_entry.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module TogglTrackMcp
+  module Tools
+    class UpdateEntry < MCP::Tool
+      description "Update an existing time entry"
+
+      input_schema(
+        properties: {
+          time_entry_id: {
+            type: "integer",
+            description: "The ID of the time entry to update",
+          },
+          description: {
+            type: "string",
+            description: "New description",
+          },
+          project_id: {
+            type: "integer",
+            description: "New project ID",
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "New tags (replaces existing tags)",
+          },
+          start: {
+            type: "string",
+            description: "New start time in ISO 8601 format (e.g. 2026-03-08T09:00:00Z)",
+          },
+          stop: {
+            type: "string",
+            description: "New stop time in ISO 8601 format (e.g. 2026-03-08T10:30:00Z)",
+          },
+        },
+        required: ["time_entry_id"],
+      )
+
+      class << self
+        def call(time_entry_id:, description: nil, project_id: nil, tags: nil, start: nil, stop: nil, server_context: nil)
+          client = server_context[:client]
+
+          params = {}
+          params[:description] = description unless description.nil?
+          params[:project_id] = project_id unless project_id.nil?
+          params[:tags] = tags unless tags.nil?
+          params[:start] = start unless start.nil?
+          params[:stop] = stop unless stop.nil?
+
+          if params.empty?
+            return MCP::Tool::Response.new(
+              [{ type: "text", text: "No fields to update. Provide at least one of: description, project_id, tags, start, stop." }],
+              error: true,
+            )
+          end
+
+          entry = client.update_entry(time_entry_id: time_entry_id, **params)
+
+          text = <<~TEXT.gsub(/^\s*\n/, "").chomp
+            Entry updated:
+              Description: #{entry["description"] || "(no description)"}
+            #{"  Project ID: #{entry["project_id"]}" if entry["project_id"]}
+            #{"  Tags: #{entry["tags"].join(", ")}" if entry["tags"]&.any?}
+            #{"  Start: #{entry["start"]}" if entry["start"]}
+            #{"  Stop: #{entry["stop"]}" if entry["stop"]}
+              Entry ID: #{entry["id"]}
+          TEXT
+
+          MCP::Tool::Response.new([{ type: "text", text: text }])
+        end
+      end
+    end
+  end
+end

data/lib/toggl_track_mcp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TogglTrackMcp
+  VERSION = "0.1.0"
+end

data/lib/toggl_track_mcp.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "toggl_track_mcp/version"
+require_relative "toggl_track_mcp/duration_formatter"
+require_relative "toggl_track_mcp/toggl_client"
+require_relative "toggl_track_mcp/tools/get_current_entry"
+require_relative "toggl_track_mcp/tools/get_today_entries"
+require_relative "toggl_track_mcp/tools/get_entries_by_date"
+require_relative "toggl_track_mcp/tools/get_daily_summary"
+require_relative "toggl_track_mcp/tools/get_projects"
+require_relative "toggl_track_mcp/tools/create_entry"
+require_relative "toggl_track_mcp/tools/update_entry"
+require_relative "toggl_track_mcp/tools/stop_entry"
+require_relative "toggl_track_mcp/tools/delete_entry"
+
+module TogglTrackMcp
+  TOOLS = [
+    Tools::GetCurrentEntry,
+    Tools::GetTodayEntries,
+    Tools::GetEntriesByDate,
+    Tools::GetDailySummary,
+    Tools::GetProjects,
+    Tools::CreateEntry,
+    Tools::UpdateEntry,
+    Tools::StopEntry,
+    Tools::DeleteEntry,
+  ].freeze
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: toggl_track_mcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ima1zumi
+bindir: exe
+cert_chain: []
+date: 2026-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: A Model Context Protocol (MCP) server that provides tools to interact
+  with Toggl Track time tracking API.
+executables:
+- toggl-track-mcp
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- exe/toggl-track-mcp
+- lib/toggl_track_mcp.rb
+- lib/toggl_track_mcp/duration_formatter.rb
+- lib/toggl_track_mcp/toggl_client.rb
+- lib/toggl_track_mcp/tools/create_entry.rb
+- lib/toggl_track_mcp/tools/delete_entry.rb
+- lib/toggl_track_mcp/tools/get_current_entry.rb
+- lib/toggl_track_mcp/tools/get_daily_summary.rb
+- lib/toggl_track_mcp/tools/get_entries_by_date.rb
+- lib/toggl_track_mcp/tools/get_projects.rb
+- lib/toggl_track_mcp/tools/get_today_entries.rb
+- lib/toggl_track_mcp/tools/stop_entry.rb
+- lib/toggl_track_mcp/tools/update_entry.rb
+- lib/toggl_track_mcp/version.rb
+homepage: https://github.com/ima1zumi/toggl-track-mcp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ima1zumi/toggl-track-mcp
+  source_code_uri: https://github.com/ima1zumi/toggl-track-mcp
+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: An MCP server for Toggl Track
+test_files: []