harvest-worklog 0.13.11 → 0.13.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5058be1a3d81258a1e210ed3fa1a94f170dcb75ce27aee043c325b03cb321d8
-  data.tar.gz: 5351dcf95f4377f13abb294a4505f9fedb893f15239086531c25089f3f92e45d
+  metadata.gz: 694f2a596182beb6a240d9917c456acdf9e329661383db4e1c5159ea19c58663
+  data.tar.gz: bf66d8629771e93f21934cdcbb99e7f7d7cac31ddfccf098da22d38df3fe1997
 SHA512:
-  metadata.gz: 1100e335afe91f89640198a70dd564d9394ddd5331280765b88494012801755a10315998b55c2226ebd3c9573ce60e4f2f4acc65ef106d1f686d4027071d7442
-  data.tar.gz: f63ac0b3b3b8f2ac3ad49a59e3c9c7169bac83ab0281360b665d7e6a4f8e01e6d3b2773d28f07872bf5f4a00746bdd21f10ba49ed4bc028f72538cfbb4a34176
+  metadata.gz: 280ca40bcb6493adb43a9992c36b4fb1810443ed1af1a0bdc96560441a5ec8c5966d7b6af3d34bbdfd398fe9add4bbb784057dcf8a7b9eeb1e64fbfd6b2dc9f7
+  data.tar.gz: 74ad6fa40e341387c9946f1dbe1fcff057a7075aca57654d4a2ff39a748eb7126375488046e0d52c6388b903bffbf53fb7597ab684641d92fab02c0158b81ae4

data/README.md

@@ -1,6 +1,6 @@
 # Harvest Worklog
 
-Harvest Worklog is a Ruby CLI and OMP plugin that infers reviewable personal work timesheets from local Project Time evidence while keeping Harvest authoritative. It creates holiday-aware time-off entries and writes only explicitly requested ordinary-work entries.
+Harvest Worklog is a Project Time-driven Ruby CLI and OMP plugin that builds reviewable personal work timesheets from local evidence. Harvest remains a manual destination: the only Harvest operations are explicitly requested time-off and ordinary-work writes.
 
 ## Credentials
 
@@ -24,9 +24,6 @@ harvest-worklog time-off FROM TO --project NAME --task NAME [options]
 harvest-worklog time-off FROM TO --project-id ID --task-id ID [options]
 harvest-worklog work-entry DATE --project NAME --task NAME --hours HOURS --notes NOTES [options]
 harvest-worklog work-entry DATE --project-id ID --task-id ID --hours HOURS --notes NOTES [options]
-harvest-worklog aggregate FROM TO [--project NAME] [--task NAME]
-harvest-worklog timesheet DATE --project NAME [--task NAME]
-harvest-worklog reconcile DATE --project PROJECT --harvest-project NAME [--task NAME]
 ```
 
 ### Time off
@@ -49,40 +46,29 @@ The `harvest_record_time_off` OMP tool accepts the same name pair or ID pair. It
 
 ### Reviewed ordinary work
 
-The `work-entry` command checks for existing or locked entries for its project, task, and date before creating a new duration entry. Use `--dry-run` to complete that preflight without a write. OMP Project Time uses the same path.
+The `work-entry` command checks for existing or locked entries for its project, task, and date before creating a new duration entry. Use `--dry-run` to complete that preflight without a write.
 
-### Read-only aggregates
+### Project Time timesheets
 
-The `aggregate` command reads all matching Harvest time-entry pages and prints totals grouped by spent date and project/task. It lists every date in the inclusive range, including weekend or empty dates, and never writes a Harvest record.
+`/harvest-worklog timesheet DATE` reads local `human_active` Project Time evidence and produces one review-only draft for every local project active on that day. It does not call Harvest or require Harvest credentials.
 
-```bash
-harvest-worklog aggregate 2026-07-17 2026-07-19 \
-  --project WRAP \
-  --task Programming
-```
-
-The `harvest_time_aggregates` OMP tool exposes the same optional filters and is approval-gated as a read.
-
-### Timesheets
+Use `--project PROJECT` only to restrict the draft to one exact local Project Time project:
 
-The CLI `timesheet` command and `harvest_time_sheet` OMP tool read the authenticated user's compact daily Harvest view. They show task totals, entry durations, and notes already recorded in Harvest.
-
-```bash
-harvest-worklog timesheet today --project WRAP
+```text
+/harvest-worklog timesheet yesterday
+/harvest-worklog timesheet yesterday --project wrap
 ```
 
-The `/harvest-worklog timesheet today --project wrap` slash command reads the requested local OMP Project Time day and renders a deterministic `Inferred work-timesheet draft (review only; nothing written)`. Only `projectTimeMappings` can supply its Harvest project/task destination. Explicit and carried-forward evidence is mapped; unassigned and ambiguous task evidence stays visible but not submittable. Every source entry shows its ID, source kind, repository identity, interval, task-attribution provenance, and any source narrative. The command never calls or changes Harvest.
-When a Project Time log has no narrative text, the draft does not turn activity labels into Harvest notes; it asks the user to add factual detail.
-`/project-time history` reports all logged dates, so its totals can be larger than the selected day.
+A configured `projectTimeMappings` destination becomes the draft's `Project` and `Task`. Evidence with no mapping, an ambiguous work item, or an unassigned work item remains visible under its local project with `Task: Review destination`; choose the Harvest project and task before submitting. Every source entry includes its ID, source kind, repository identity, interval, task-attribution provenance, and optional narrative. Nothing is submitted automatically.
 
-Type `/harvest-worklog ` in OMP to discover `timesheet`; date aliases appear only after selecting `timesheet `. After `--project`, Tab lists local human-active Project Time project names; a prefix filters them case-insensitively. Completion preserves the case-sensitive name required by the command.
+Type `/harvest-worklog ` in OMP to discover `timesheet`; date aliases appear after selecting `timesheet `. After `--project`, Tab lists local human-active Project Time project names. Completion preserves the exact local project name.
 
 ## OMP settings
 
 - `defaultHours`: hours per business day when a time-off tool call omits `hours`; defaults to `7`.
 - `holidayRegions`: comma-separated Holidays regions; defaults to `ca_yt`.
 - `command`: direct path to the `harvest-worklog` executable.
-- `projectTimeMappings`: JSON mapping from OMP Project Time project names to Harvest project/task names.
+- `projectTimeMappings`: optional JSON mapping from OMP Project Time project names to Harvest project/task names. Unmapped evidence remains a review-required local draft.
 - `projectTimeLogPath`: optional override for `~/.omp/project-time/time-log.json`.
 
 ## OMP Project Time integration
@@ -97,29 +83,13 @@ Configure `projectTimeMappings` with the recorded OMP Project Time project name
 
 Harvest Worklog reads only the documented `omp-project-time/evidence` format at version `1`. An absent, unsupported, or malformed version produces a no-write diagnostic; run a current Project Time session to persist the v1 ledger format before retrying.
 
-`harvest_preview_project_time_entries` reads only `human_active` sessions from the configured time log, splits them across local dates, combines sources that map to the same Harvest date/project/task, and performs a no-write Harvest preflight. It reports the inferred timesheet entries, source policy, and unmapped sessions; it never records Project Time-derived work in Harvest.
-
-`harvest_preview_project_time_drafts` produces one deterministic, copyable Date/Project/Task/Duration block per mapped local day and Harvest destination from `human_active` evidence. It preserves source entry IDs, intervals, source kind, repository identity, narratives, work items, and task-attribution provenance. Explicit and carried-forward evidence can use the existing project-to-Harvest mapping; unassigned and ambiguous evidence stays visible but not submittable. Generated narratives are review evidence, never task identity or a factual Harvest note. The tool reads the local log only; it never calls or mutates Harvest.
+`harvest_preview_project_time_drafts` produces deterministic, copyable Date/Project/Task/Duration blocks from all local `human_active` evidence in an inclusive date range. Mapped evidence uses its configured Harvest destination; unmapped, ambiguous, and unassigned evidence remains an explicit local-project draft. It preserves source entry IDs, intervals, source kind, repository identity, narratives, work items, and task-attribution provenance. Generated narratives are review evidence, never task identity or a factual Harvest note. The tool reads the local log only; it never calls or mutates Harvest.
 
 ### Activity transforms
 
-`harvest_preview_project_time_transforms` emits deterministic JSON for local raw intervals. It accepts an inclusive date range and optional exact `repositoryId`, `project`, and `sourceKind` filters; each matching interval is split by local date and grouped by activity, with missing labels reported as `unlabelled`. It defaults to `human_active` and returns the effective top-level `sourceKind`; selecting `agent_turn_elapsed` requires an explicit source-kind request. Set `applyMappings` to include configured Harvest project/task mappings. The output reports groups, source records, candidate mapped entries, and any unmapped or excluded rows; it never writes Harvest.
-
-
-## Daily reconciliation
-
-`reconcile` compares one local Project Time project against the manual Harvest total for one date. It reads only local `human_active` intervals, reports the raw duration, non-overlapping union, concurrent overlap, and both Harvest-minus-local deltas. It never creates or changes Harvest entries: manual Harvest is the benchmark.
-
-```bash
-harvest-worklog reconcile 2026-07-21 \
-  --project wrap \
-  --harvest-project WRAP \
-  --task Programming
-```
+`harvest_preview_project_time_transforms` emits deterministic JSON for local raw intervals. It accepts an inclusive date range and optional exact `repositoryId`, `project`, and `sourceKind` filters; each matching interval is split by local date and grouped by activity, with missing labels reported as `unlabelled`. It defaults to `human_active` and returns the effective top-level `sourceKind`; selecting `agent_turn_elapsed` requires an explicit source-kind request. Set `applyMappings` to create configured Harvest destinations or review-required local destinations for every included group. The output reports groups, draft entries, and excluded rows; it never writes Harvest.
 
-Empty local or Harvest data is reported as zero, so this command is suitable for daily capture checks while manual tracking remains authoritative. It never decides or applies a Harvest delta.
 
-Manual Harvest entries remain separate from inferred Project Time durations. Review the timesheet and reconciliation output, then choose the actual Harvest entry yourself; do not sum local evidence and manually recorded Harvest time as if they were independent entries.
 
 ## Migration from harvest-time-off
 

data/lib/harvest_worklog/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HarvestWorklog
-  VERSION = "0.13.11"
+  VERSION = "0.13.12"
 end

data/lib/harvest_worklog.rb

@@ -35,19 +35,11 @@ module HarvestWorklog
         TimeOffCLI.run(command_arguments, output:, error:, client:)
       when "work-entry"
         WorkEntryCLI.run(command_arguments, output:, error:, client:)
-      when "aggregate"
-        AggregateCLI.run(command_arguments, output:, error:, client:)
-      when "timesheet"
-        TimesheetCLI.run(command_arguments, output:, error:, client:)
-      when "reconcile"
-        ReconcileCLI.run(command_arguments, output:, error:, client:)
-      when "mapping-data"
-        MappingDataCLI.run(command_arguments, output:, error:, client:)
       when "-h", "--help"
         output.puts usage
         0
       else
-        error.puts "Error: choose time-off, work-entry, aggregate, timesheet, reconcile, or mapping-data"
+        error.puts "Error: choose time-off or work-entry"
         error.puts usage
         1
       end
@@ -60,18 +52,10 @@ module HarvestWorklog
           harvest-worklog time-off FROM TO --project-id ID --task-id ID [options]
           harvest-worklog work-entry DATE --project NAME --task NAME --hours HOURS --notes NOTES [options]
           harvest-worklog work-entry DATE --project-id ID --task-id ID --hours HOURS --notes NOTES [options]
-          harvest-worklog aggregate FROM TO [--project NAME] [--task NAME]
-          harvest-worklog timesheet DATE --project NAME [--task NAME]
-          harvest-worklog reconcile DATE --project PROJECT --harvest-project NAME [--task NAME]
-          harvest-worklog mapping-data FROM TO
 
         Commands:
           time-off    Create one entry per local business day in a date range.
           work-entry  Create one reviewed ordinary-work entry.
-          aggregate   Read time-entry totals without writing Harvest records.
-          timesheet  Read a compact daily project timesheet without writing Harvest records.
-          reconcile   Compare local Project Time with manual Harvest without writing.
-          mapping-data Read assigned Harvest destinations and historical entries without writing.
       USAGE
     end
   end
@@ -193,7 +177,3 @@ module HarvestWorklog
 end
 
 require "harvest_worklog/work_entry_cli"
-require "harvest_worklog/aggregate_cli"
-require "harvest_worklog/timesheet_cli"
-require "harvest_worklog/reconcile_cli"
-require "harvest_worklog/mapping_data_cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: harvest-worklog
 version: !ruby/object:Gem::Version
-  version: 0.13.11
+  version: 0.13.12
 platform: ruby
 authors:
 - Marlen Brunner
@@ -66,10 +66,6 @@ files:
 - bin/verify-plugin-release
 - harvest-worklog.rb
 - lib/harvest_worklog.rb
-- lib/harvest_worklog/aggregate_cli.rb
-- lib/harvest_worklog/mapping_data_cli.rb
-- lib/harvest_worklog/reconcile_cli.rb
-- lib/harvest_worklog/timesheet_cli.rb
 - lib/harvest_worklog/version.rb
 - lib/harvest_worklog/work_entry_cli.rb
 homepage: https://github.com/klondikemarlen/harvest-worklog
@@ -95,5 +91,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Harvest work-log CLI and OMP integration.
+summary: Project Time work-timesheet drafts with manual Harvest writes.
 test_files: []

data/lib/harvest_worklog/aggregate_cli.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module HarvestWorklog
-  class AggregateCLI
-    PER_PAGE = 100
-
-    def self.run(arguments, output: $stdout, error: $stderr, client: nil)
-      options = {}
-      parser = option_parser(options)
-      dates = parser.parse(arguments)
-      validate!(dates, options)
-
-      from = Date.iso8601(dates[0])
-      to = Date.iso8601(dates[1])
-      raise Error, "end date must not be before start date" if to < from
-
-      client ||= Marlens::HarvestApiV2::Client.from_environment
-      entries = fetch_entries(client, from:, to:).select { |entry| matches?(entry, options) }
-      print_summary(output, entries, from:, to:)
-      0
-    rescue Error, Marlens::HarvestApiV2::Error, OptionParser::ParseError, Date::Error => e
-      error.puts "Error: #{e.message}"
-      error.puts parser if parser
-      1
-    end
-
-    def self.option_parser(options)
-      OptionParser.new do |opts|
-        opts.banner = "Usage: harvest-worklog aggregate FROM TO [--project NAME] [--task NAME]"
-        opts.on("--project NAME", "Filter by Harvest project name") { |value| options[:project] = value }
-        opts.on("--task NAME", "Filter by Harvest task name") { |value| options[:task] = value }
-        opts.on("-h", "--help", "Show this help") do
-          puts opts
-          exit 0
-        end
-      end
-    end
-
-    def self.validate!(dates, options = {})
-      raise Error, "FROM and TO are required" unless dates.length == 2
-      raise Error, "--project must not be blank" if options[:project]&.strip&.empty?
-      raise Error, "--task must not be blank" if options[:task]&.strip&.empty?
-    end
-
-    def self.fetch_entries(client, from:, to:, user_id: nil)
-      entries = []
-      page = 1
-      loop do
-        params = { from: from.iso8601, to: to.iso8601, page:, per_page: PER_PAGE }
-        params[:user_id] = user_id if user_id
-        response = client.request(
-          :get,
-          "/v2/time_entries",
-          params:
-        )
-        entries.concat(response.fetch("time_entries"))
-        page = response["next_page"]
-        break if page.nil?
-      end
-      entries
-    end
-
-    def self.matches?(entry, options)
-      name_matches?(entry.dig("project", "name"), options[:project]) &&
-        name_matches?(entry.dig("task", "name"), options[:task])
-    end
-
-    def self.name_matches?(actual, expected)
-      expected.nil? || actual&.casecmp?(expected)
-    end
-
-    def self.print_summary(output, entries, from:, to:)
-      output.puts "#{entries.length} #{entry_label(entries.length)}, #{HarvestWorklog.display_hours(total_hours(entries))}h from #{from.iso8601} through #{to.iso8601}"
-      output.puts "By date:"
-      (from..to).each do |date|
-        date_entries = entries.select { |entry| entry.fetch("spent_date") == date.iso8601 }
-        output.puts "  #{date.iso8601}: #{date_entries.length} #{entry_label(date_entries.length)}, #{HarvestWorklog.display_hours(total_hours(date_entries))}h"
-      end
-      output.puts "By project/task:"
-
-      groups = entries.group_by { |entry| [entry.dig("project", "name"), entry.dig("task", "name")] }
-      if groups.empty?
-        output.puts "  none"
-        return
-      end
-
-      groups.keys.sort_by { |project, task| [project.downcase, task.downcase] }.each do |project, task|
-        group = groups.fetch([project, task])
-        output.puts "  #{project} / #{task}: #{group.length} #{entry_label(group.length)}, #{HarvestWorklog.display_hours(total_hours(group))}h"
-      end
-    end
-
-    def self.total_hours(entries)
-      entries.sum { |entry| Float(entry.fetch("hours")) }
-    end
-
-    def self.entry_label(count)
-      count == 1 ? "entry" : "entries"
-    end
-  end
-end

data/lib/harvest_worklog/mapping_data_cli.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module HarvestWorklog
-  class MappingDataCLI
-    def self.run(arguments, output: $stdout, error: $stderr, client: nil)
-      from, to = arguments
-      raise Error, "FROM and TO are required" unless arguments.length == 2
-
-      from = Date.iso8601(from)
-      to = Date.iso8601(to)
-      raise Error, "end date must not be before start date" if to < from
-
-      client ||= Marlens::HarvestApiV2::Client.from_environment
-      assignments = client.active_personal_task_assignments.filter_map do |assignment|
-        project = assignment["project"]
-        task = assignment["task"]
-        next unless project&.fetch("id", nil) && project&.fetch("name", nil) && task&.fetch("id", nil) && task&.fetch("name", nil)
-
-        { "project" => { "id" => project.fetch("id"), "name" => project.fetch("name") }, "task" => { "id" => task.fetch("id"), "name" => task.fetch("name") } }
-      end
-      entries = AggregateCLI.fetch_entries(client, from:, to:).filter_map do |entry|
-        project = entry["project"]
-        task = entry["task"]
-        next unless project&.fetch("id", nil) && project&.fetch("name", nil) && task&.fetch("id", nil) && task&.fetch("name", nil) && Float(entry.fetch("hours"))
-
-        { "project" => { "id" => project.fetch("id"), "name" => project.fetch("name") }, "task" => { "id" => task.fetch("id"), "name" => task.fetch("name") }, "hours" => entry.fetch("hours") }
-      end
-      output.puts JSON.generate(assignments:, entries:)
-      0
-    rescue Error, Marlens::HarvestApiV2::Error, Date::Error => e
-      error.puts "Error: #{e.message}"
-      1
-    end
-  end
-end

data/lib/harvest_worklog/reconcile_cli.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module HarvestWorklog
-  class ReconcileCLI
-    def self.run(arguments, output: $stdout, error: $stderr, client: nil, log_path: default_log_path, today: Date.today)
-      options = {}
-      parser = option_parser(options)
-      dates = parser.parse(arguments)
-      validate!(dates, options)
-
-      date = TimesheetCLI.resolve_date(dates.first, today:)
-      client ||= Marlens::HarvestApiV2::Client.from_environment
-      user_id = TimesheetCLI.current_user_id(client)
-      harvest_entries = AggregateCLI.fetch_entries(client, from: date, to: date, user_id:).select do |entry|
-        AggregateCLI.matches?(entry, project: options[:harvest_project], task: options[:task])
-      end
-      print_reconciliation(
-        output,
-        date:,
-        local_project: options[:project],
-        intervals: local_intervals(log_path, date:, project: options[:project]),
-        harvest_entries:
-      )
-      0
-    rescue Error, Marlens::HarvestApiV2::Error, OptionParser::ParseError, Date::Error, Errno::ENOENT, JSON::ParserError => e
-      error.puts "Error: #{e.message}"
-      error.puts parser if parser
-      1
-    end
-
-    def self.option_parser(options)
-      OptionParser.new do |opts|
-        opts.banner = "Usage: harvest-worklog reconcile DATE --project PROJECT --harvest-project NAME [--task NAME]"
-        opts.on("--project NAME", "Filter local OMP Project Time project name") { |value| options[:project] = value }
-        opts.on("--harvest-project NAME", "Filter manual Harvest project name") { |value| options[:harvest_project] = value }
-        opts.on("--task NAME", "Filter manual Harvest task name") { |value| options[:task] = value }
-        opts.on("-h", "--help", "Show this help") do
-          puts opts
-          exit 0
-        end
-      end
-    end
-
-    def self.validate!(dates, options)
-      raise Error, "DATE is required" unless dates.length == 1
-      %i[project harvest_project].each do |name|
-        raise Error, "--#{name.to_s.tr('_', '-')} is required" unless options[name]&.strip&.length&.positive?
-      end
-      raise Error, "--task must not be blank" if options[:task]&.strip&.empty?
-    end
-
-    def self.default_log_path
-      File.join(Dir.home, ".omp", "project-time", "time-log.json")
-    end
-
-    def self.local_intervals(log_path, date:, project:)
-      state = JSON.parse(File.read(log_path))
-      entries = state.is_a?(Hash) ? state["entries"] : nil
-      raise Error, "OMP Project Time log is missing an entries array" unless entries.is_a?(Array)
-
-      day_start = Time.local(date.year, date.month, date.day).to_f * 1000
-      next_date = date + 1
-      day_end = Time.local(next_date.year, next_date.month, next_date.day).to_f * 1000
-      entries.filter_map do |entry|
-        next unless entry.is_a?(Hash) && entry["sourceKind"] == "human_active" && entry["project"] == project
-
-        start_at = entry["startAtMs"]
-        end_at = entry["endAtMs"]
-        raise Error, "OMP Project Time log contains an invalid session interval" unless start_at.is_a?(Numeric) && end_at.is_a?(Numeric) && start_at < end_at
-
-        start_at = [start_at, day_start].max
-        end_at = [end_at, day_end].min
-        [start_at, end_at] if start_at < end_at
-      end
-    end
-
-    def self.print_reconciliation(output, date:, local_project:, intervals:, harvest_entries:)
-      raw = intervals.sum { |start_at, end_at| end_at - start_at }
-      union = merged_duration(intervals)
-      harvest = AggregateCLI.total_hours(harvest_entries) * 3_600_000
-
-      output.puts "#{date.iso8601} reconciliation"
-      output.puts "Manual Harvest: #{duration(harvest)} (#{harvest_entries.length} #{AggregateCLI.entry_label(harvest_entries.length)})"
-      output.puts "Local OMP Project Time #{local_project}:"
-      output.puts "  Raw intervals: #{duration(raw)}"
-      output.puts "  Non-overlapping union: #{duration(union)}"
-      output.puts "  Concurrent overlap: #{duration(raw - union)}"
-      output.puts "Harvest minus local raw: #{signed_duration(harvest - raw)}"
-      output.puts "Harvest minus local union: #{signed_duration(harvest - union)}"
-      output.puts "Verdict: Manual Harvest is the benchmark. This read-only comparison creates or changes no entries."
-    end
-
-    def self.merged_duration(intervals)
-      merged = intervals.sort_by(&:first).each_with_object([]) do |(start_at, end_at), result|
-        if result.empty? || start_at > result.last.last
-          result << [start_at, end_at]
-        else
-          result.last[1] = [result.last[1], end_at].max
-        end
-      end
-      merged.sum { |start_at, end_at| end_at - start_at }
-    end
-
-    def self.signed_duration(milliseconds)
-      seconds = (milliseconds / 1000.0).round
-      return duration(0) if seconds.zero?
-
-      "#{seconds.negative? ? '-' : '+'}#{duration(seconds.abs * 1000)}"
-    end
-
-    def self.duration(milliseconds)
-      seconds = (milliseconds / 1000.0).round
-      "%dh %dm %ds" % [seconds / 3600, seconds / 60 % 60, seconds % 60]
-    end
-  end
-end

data/lib/harvest_worklog/timesheet_cli.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module HarvestWorklog
-  class TimesheetCLI
-    def self.run(arguments, output: $stdout, error: $stderr, client: nil, today: Date.today)
-      options = {}
-      parser = option_parser(options)
-      dates = parser.parse(arguments)
-      validate!(dates, options)
-
-      spent_date = resolve_date(dates.first, today:)
-      client ||= Marlens::HarvestApiV2::Client.from_environment
-      user_id = current_user_id(client)
-      entries = AggregateCLI.fetch_entries(client, from: spent_date, to: spent_date, user_id:).select { |entry| AggregateCLI.matches?(entry, options) }
-      print_timesheet(output, entries, spent_date:, requested_project: options[:project])
-      0
-    rescue Error, Marlens::HarvestApiV2::Error, OptionParser::ParseError, Date::Error => e
-      error.puts "Error: #{e.message}"
-      error.puts parser if parser
-      1
-    end
-
-    def self.option_parser(options)
-      OptionParser.new do |opts|
-        opts.banner = "Usage: harvest-worklog timesheet DATE --project NAME [--task NAME]"
-        opts.on("--project NAME", "Filter by Harvest project name") { |value| options[:project] = value }
-        opts.on("--task NAME", "Filter by Harvest task name") { |value| options[:task] = value }
-        opts.on("-h", "--help", "Show this help") do
-          puts opts
-          exit 0
-        end
-      end
-    end
-
-    def self.resolve_date(value, today: Date.today)
-      case value.downcase
-      when "today" then today
-      when "yesterday" then today - 1
-      else Date.iso8601(value)
-      end
-    end
-
-    def self.current_user_id(client)
-      client.request(:get, "/v2/users/me", params: {}).fetch("id")
-    end
-
-    def self.validate!(dates, options)
-      raise Error, "DATE is required" unless dates.length == 1
-      raise Error, "--project is required" unless options[:project] && !options[:project].strip.empty?
-      raise Error, "--task must not be blank" if options[:task]&.strip&.empty?
-    end
-
-    def self.print_timesheet(output, entries, spent_date:, requested_project:)
-      project = entries.first&.dig("project", "name") || requested_project
-      output.puts "#{project} · #{spent_date.strftime("%a, %b %-d")} · #{HarvestWorklog.display_hours(AggregateCLI.total_hours(entries))}h"
-      if entries.empty?
-        output.puts
-        output.puts "No time entries."
-        return
-      end
-
-      entries.group_by { |entry| entry.dig("task", "name") }.sort_by { |task, _| task.downcase }.each do |task, task_entries|
-        output.puts
-        output.puts "#{task} · #{HarvestWorklog.display_hours(AggregateCLI.total_hours(task_entries))}h"
-        if task_entries.one?
-          print_notes(output, task_entries.first["notes"].to_s, indent: 2)
-        else
-          task_entries.each do |entry|
-            output.puts "  #{HarvestWorklog.display_hours(Float(entry.fetch("hours")))}h"
-            print_notes(output, entry["notes"].to_s, indent: 4)
-          end
-        end
-      end
-    end
-
-    def self.print_notes(output, notes, indent:)
-      lines = notes.lines(chomp: true).reject(&:empty?)
-      lines = ["(no notes)"] if lines.empty?
-      lines.each { |line| output.puts "#{" " * indent}#{line}" }
-    end
-  end
-end